From 3b853c771f34005d557c7e236345f7f16b3fea88 Mon Sep 17 00:00:00 2001 From: Cyrus Najmabadi Date: Tue, 4 Dec 2018 14:44:46 -0800 Subject: [PATCH] Capitalize loc string. --- .../RegexEmbeddedCompletionProvider.cs | 138 +- .../RegularExpressions/RegexCharClass.cs | 74 +- .../Portable/WorkspacesResources.Designer.cs | 732 ++--- .../Core/Portable/WorkspacesResources.resx | 366 +-- .../Portable/xlf/WorkspacesResources.cs.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.de.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.es.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.fr.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.it.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.ja.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.ko.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.pl.xlf | 2872 ++++++++--------- .../xlf/WorkspacesResources.pt-BR.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.ru.xlf | 2872 ++++++++--------- .../Portable/xlf/WorkspacesResources.tr.xlf | 2872 ++++++++--------- .../xlf/WorkspacesResources.zh-Hans.xlf | 2872 ++++++++--------- .../xlf/WorkspacesResources.zh-Hant.xlf | 2872 ++++++++--------- 17 files changed, 19323 insertions(+), 19323 deletions(-) diff --git a/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs b/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs index 40fb5d94f1e..64d9e018efa 100644 --- a/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs +++ b/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexEmbeddedCompletionProvider.cs @@ -187,30 +187,30 @@ private bool DetermineIfInCharacterClass(RegexTree tree, int pos) private void ProvideTopLevelCompletions(EmbeddedCompletionContext context) { - context.AddIfMissing("|", regex_alternation_short, regex_alternation_long, parentOpt: null); - context.AddIfMissing("^", regex_start_of_string_or_line_short, regex_start_of_string_or_line_long, parentOpt: null); - context.AddIfMissing("$", regex_end_of_string_or_line_short, regex_end_of_string_or_line_long, parentOpt: null); - context.AddIfMissing(".", regex_any_character_group_short, regex_any_character_group_long, parentOpt: null); + context.AddIfMissing("|", Regex_alternation_short, Regex_alternation_long, parentOpt: null); + context.AddIfMissing("^", Regex_start_of_string_or_line_short, Regex_start_of_string_or_line_long, parentOpt: null); + context.AddIfMissing("$", Regex_end_of_string_or_line_short, Regex_end_of_string_or_line_long, parentOpt: null); + context.AddIfMissing(".", Regex_any_character_group_short, Regex_any_character_group_long, parentOpt: null); - context.AddIfMissing("*", regex_match_zero_or_more_times_short, regex_match_zero_or_more_times_long, parentOpt: null); - context.AddIfMissing("*?", regex_match_zero_or_more_times_lazy_short, regex_match_zero_or_more_times_lazy_long, parentOpt: null); + context.AddIfMissing("*", Regex_match_zero_or_more_times_short, Regex_match_zero_or_more_times_long, parentOpt: null); + context.AddIfMissing("*?", Regex_match_zero_or_more_times_lazy_short, Regex_match_zero_or_more_times_lazy_long, parentOpt: null); - context.AddIfMissing("+", regex_match_one_or_more_times_short, regex_match_one_or_more_times_long, parentOpt: null); - context.AddIfMissing("+?", regex_match_one_or_more_times_lazy_short, regex_match_one_or_more_times_lazy_long, parentOpt: null); + context.AddIfMissing("+", Regex_match_one_or_more_times_short, Regex_match_one_or_more_times_long, parentOpt: null); + context.AddIfMissing("+?", Regex_match_one_or_more_times_lazy_short, Regex_match_one_or_more_times_lazy_long, parentOpt: null); - context.AddIfMissing("?", regex_match_zero_or_one_time_short, regex_match_zero_or_one_time_long, parentOpt: null); - context.AddIfMissing("??", regex_match_zero_or_one_time_lazy_short, regex_match_zero_or_one_time_lazy_long, parentOpt: null); + context.AddIfMissing("?", Regex_match_zero_or_one_time_short, Regex_match_zero_or_one_time_long, parentOpt: null); + context.AddIfMissing("??", Regex_match_zero_or_one_time_lazy_short, Regex_match_zero_or_one_time_lazy_long, parentOpt: null); - context.AddIfMissing("{n}", regex_match_exactly_n_times_short, regex_match_exactly_n_times_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{}"); - context.AddIfMissing("{n}?", regex_match_exactly_n_times_lazy_short, regex_match_exactly_n_times_lazy_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{}?"); + context.AddIfMissing("{n}", Regex_match_exactly_n_times_short, Regex_match_exactly_n_times_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{}"); + context.AddIfMissing("{n}?", Regex_match_exactly_n_times_lazy_short, Regex_match_exactly_n_times_lazy_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{}?"); - context.AddIfMissing("{n,}", regex_match_at_least_n_times_short, regex_match_at_least_n_times_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}"); - context.AddIfMissing("{n,}?", regex_match_at_least_n_times_lazy_short, regex_match_at_least_n_times_lazy_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}?"); + context.AddIfMissing("{n,}", Regex_match_at_least_n_times_short, Regex_match_at_least_n_times_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}"); + context.AddIfMissing("{n,}?", Regex_match_at_least_n_times_lazy_short, Regex_match_at_least_n_times_lazy_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}?"); - context.AddIfMissing("{m,n}", regex_match_between_m_and_n_times_short, regex_match_between_m_and_n_times_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}"); - context.AddIfMissing("{m,n}?", regex_match_between_m_and_n_times_lazy_short, regex_match_between_m_and_n_times_lazy_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}?"); + context.AddIfMissing("{m,n}", Regex_match_between_m_and_n_times_short, Regex_match_between_m_and_n_times_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}"); + context.AddIfMissing("{m,n}?", Regex_match_between_m_and_n_times_lazy_short, Regex_match_between_m_and_n_times_lazy_long, parentOpt: null, positionOffset: "{".Length, insertionText: "{,}?"); - context.AddIfMissing("#", regex_end_of_line_comment_short, regex_end_of_line_comment_long, parentOpt: null); + context.AddIfMissing("#", Regex_end_of_line_comment_short, Regex_end_of_line_comment_long, parentOpt: null); } private void ProvideCompletionsAfterInsertion(EmbeddedCompletionContext context) @@ -293,31 +293,31 @@ private void ProvideGroupingCompletions(EmbeddedCompletionContext context, Regex return; } - context.AddIfMissing($"( {regex_subexpression} )", regex_matched_subexpression_short, regex_matched_subexpression_long, parentOpt, positionOffset: "(".Length, insertionText: "()"); - context.AddIfMissing($"(?< {regex_name} > {regex_subexpression} )", regex_named_matched_subexpression_short, regex_named_matched_subexpression_long, parentOpt, positionOffset: "(?<".Length, insertionText: "(?<>)"); - context.AddIfMissing($"(?< {regex_name1} - {regex_name2} > {regex_subexpression} )", regex_balancing_group_short, regex_balancing_group_long, parentOpt, positionOffset: "(?<".Length, insertionText: "(?<->)"); - context.AddIfMissing($"(?: {regex_subexpression} )", regex_noncapturing_group_short, regex_noncapturing_group_long, parentOpt, positionOffset: "(?:".Length, insertionText: "(?:)"); - context.AddIfMissing($"(?= {regex_subexpression} )", regex_zero_width_positive_lookahead_assertion_short, regex_zero_width_positive_lookahead_assertion_long, parentOpt, positionOffset: "(?=".Length, insertionText: "(?=)"); - context.AddIfMissing($"(?! {regex_subexpression} )", regex_zero_width_negative_lookahead_assertion_short, regex_zero_width_negative_lookahead_assertion_long, parentOpt, positionOffset: "(?!".Length, insertionText: "(?!)"); - context.AddIfMissing($"(?<= {regex_subexpression} )", regex_zero_width_positive_lookbehind_assertion_short, regex_zero_width_positive_lookbehind_assertion_long, parentOpt, positionOffset: "(?<=".Length, insertionText: "(?<=)"); - context.AddIfMissing($"(? {regex_subexpression} )", regex_nonbacktracking_subexpression_short, regex_nonbacktracking_subexpression_long, parentOpt, positionOffset: "(?>".Length, insertionText: "(?>)"); - - context.AddIfMissing($"(?( {regex_expression} ) {regex_yes} | {regex_no} )", regex_conditional_expression_match_short, regex_conditional_expression_match_long, parentOpt, positionOffset: "(?(".Length, insertionText: "(?()|)"); - context.AddIfMissing($"(?( {regex_name_or_number} ) {regex_yes} | {regex_no} )", regex_conditional_group_match_short, regex_conditional_group_match_long, parentOpt, positionOffset: "(?(".Length, insertionText: "(?()|)"); - - context.AddIfMissing($"(?# {regex_comment} )", regex_inline_comment_short, regex_inline_comment_long, parentOpt, positionOffset: "(?#".Length, insertionText: "(?#)"); - context.AddIfMissing($"(?imnsx-imnsx)", regex_inline_options_short, regex_inline_options_long, parentOpt, positionOffset: "(?".Length, insertionText: "(?)"); - context.AddIfMissing($"(?imnsx-imnsx: {regex_subexpression} )", regex_group_options_short, regex_group_options_long, parentOpt, positionOffset: "(?".Length, insertionText: "(?:)"); + context.AddIfMissing($"( {Regex_subexpression} )", Regex_matched_subexpression_short, Regex_matched_subexpression_long, parentOpt, positionOffset: "(".Length, insertionText: "()"); + context.AddIfMissing($"(?< {Regex_name} > {Regex_subexpression} )", Regex_named_matched_subexpression_short, Regex_named_matched_subexpression_long, parentOpt, positionOffset: "(?<".Length, insertionText: "(?<>)"); + context.AddIfMissing($"(?< {Regex_name1} - {Regex_name2} > {Regex_subexpression} )", Regex_balancing_group_short, Regex_balancing_group_long, parentOpt, positionOffset: "(?<".Length, insertionText: "(?<->)"); + context.AddIfMissing($"(?: {Regex_subexpression} )", Regex_noncapturing_group_short, Regex_noncapturing_group_long, parentOpt, positionOffset: "(?:".Length, insertionText: "(?:)"); + context.AddIfMissing($"(?= {Regex_subexpression} )", Regex_zero_width_positive_lookahead_assertion_short, Regex_zero_width_positive_lookahead_assertion_long, parentOpt, positionOffset: "(?=".Length, insertionText: "(?=)"); + context.AddIfMissing($"(?! {Regex_subexpression} )", Regex_zero_width_negative_lookahead_assertion_short, Regex_zero_width_negative_lookahead_assertion_long, parentOpt, positionOffset: "(?!".Length, insertionText: "(?!)"); + context.AddIfMissing($"(?<= {Regex_subexpression} )", Regex_zero_width_positive_lookbehind_assertion_short, Regex_zero_width_positive_lookbehind_assertion_long, parentOpt, positionOffset: "(?<=".Length, insertionText: "(?<=)"); + context.AddIfMissing($"(? {Regex_subexpression} )", Regex_nonbacktracking_subexpression_short, Regex_nonbacktracking_subexpression_long, parentOpt, positionOffset: "(?>".Length, insertionText: "(?>)"); + + context.AddIfMissing($"(?( {Regex_expression} ) {Regex_yes} | {Regex_no} )", Regex_conditional_expression_match_short, Regex_conditional_expression_match_long, parentOpt, positionOffset: "(?(".Length, insertionText: "(?()|)"); + context.AddIfMissing($"(?( {Regex_name_or_number} ) {Regex_yes} | {Regex_no} )", Regex_conditional_group_match_short, Regex_conditional_group_match_long, parentOpt, positionOffset: "(?(".Length, insertionText: "(?()|)"); + + context.AddIfMissing($"(?# {Regex_comment} )", Regex_inline_comment_short, Regex_inline_comment_long, parentOpt, positionOffset: "(?#".Length, insertionText: "(?#)"); + context.AddIfMissing($"(?imnsx-imnsx)", Regex_inline_options_short, Regex_inline_options_long, parentOpt, positionOffset: "(?".Length, insertionText: "(?)"); + context.AddIfMissing($"(?imnsx-imnsx: {Regex_subexpression} )", Regex_group_options_short, Regex_group_options_long, parentOpt, positionOffset: "(?".Length, insertionText: "(?:)"); } private void ProvideCharacterClassCompletions(EmbeddedCompletionContext context, RegexNode parentOpt) { - context.AddIfMissing($"[ {regex_character_group} ]", regex_positive_character_group_short, regex_positive_character_group_long, parentOpt, positionOffset: "[".Length, insertionText: "[]"); - context.AddIfMissing($"[ firstCharacter-lastCharacter ]", regex_positive_character_range_short, regex_positive_character_range_long, parentOpt, positionOffset: "[".Length, insertionText: "[-]"); - context.AddIfMissing($"[^ {regex_character_group} ]", regex_negative_character_group_short, regex_negative_character_group_long, parentOpt, positionOffset: "[^".Length, insertionText: "[^]"); - context.AddIfMissing($"[^ firstCharacter-lastCharacter ]", regex_negative_character_group_short, regex_negative_character_range_long, parentOpt, positionOffset: "[^".Length, insertionText: "[^-]"); - context.AddIfMissing($"[ {regex_base_group} -[ {regex_excluded_group} ]", regex_character_class_subtraction_short, regex_character_class_subtraction_long, parentOpt, positionOffset: "[".Length, insertionText: "[-[]]"); + context.AddIfMissing($"[ {Regex_character_group} ]", Regex_positive_character_group_short, Regex_positive_character_group_long, parentOpt, positionOffset: "[".Length, insertionText: "[]"); + context.AddIfMissing($"[ firstCharacter-lastCharacter ]", Regex_positive_character_range_short, Regex_positive_character_range_long, parentOpt, positionOffset: "[".Length, insertionText: "[-]"); + context.AddIfMissing($"[^ {Regex_character_group} ]", Regex_negative_character_group_short, Regex_negative_character_group_long, parentOpt, positionOffset: "[^".Length, insertionText: "[^]"); + context.AddIfMissing($"[^ firstCharacter-lastCharacter ]", Regex_negative_character_group_short, Regex_negative_character_range_long, parentOpt, positionOffset: "[^".Length, insertionText: "[^-]"); + context.AddIfMissing($"[ {Regex_base_group} -[ {Regex_excluded_group} ]", Regex_character_class_subtraction_short, Regex_character_class_subtraction_long, parentOpt, positionOffset: "[".Length, insertionText: "[-[]]"); } private void ProvideEscapeCategoryCompletions(EmbeddedCompletionContext context) @@ -338,7 +338,7 @@ private void ProvideEscapeCategoryCompletions(EmbeddedCompletionContext context) var description = longDesc.Length > 0 ? longDesc - : string.Format(regex_unicode_general_category_0, name); + : string.Format(Regex_unicode_general_category_0, name); context.AddIfMissing(new RegexItem( displayText, shortDesc, description, @@ -357,39 +357,39 @@ private void ProvideEscapeCategoryCompletions(EmbeddedCompletionContext context) if (!inCharacterClass) { - context.AddIfMissing(@"\A", regex_start_of_string_only_short, regex_start_of_string_only_long, parentOpt); - context.AddIfMissing(@"\b", regex_word_boundary_short, regex_word_boundary_long, parentOpt); - context.AddIfMissing(@"\B", regex_non_word_boundary_short, regex_non_word_boundary_long, parentOpt); - context.AddIfMissing(@"\G", regex_contiguous_matches_short, regex_contiguous_matches_long, parentOpt); - context.AddIfMissing(@"\z", regex_end_of_string_only_short, regex_end_of_string_only_long, parentOpt); - context.AddIfMissing(@"\Z", regex_end_of_string_or_before_ending_newline_short, regex_end_of_string_or_before_ending_newline_long, parentOpt); - - context.AddIfMissing($@"\k< {regex_name_or_number} >", regex_named_backreference_short, regex_named_backreference_long, parentOpt, @"\k<".Length, insertionText: @"\k<>"); + context.AddIfMissing(@"\A", Regex_start_of_string_only_short, Regex_start_of_string_only_long, parentOpt); + context.AddIfMissing(@"\b", Regex_word_boundary_short, Regex_word_boundary_long, parentOpt); + context.AddIfMissing(@"\B", Regex_non_word_boundary_short, Regex_non_word_boundary_long, parentOpt); + context.AddIfMissing(@"\G", Regex_contiguous_matches_short, Regex_contiguous_matches_long, parentOpt); + context.AddIfMissing(@"\z", Regex_end_of_string_only_short, Regex_end_of_string_only_long, parentOpt); + context.AddIfMissing(@"\Z", Regex_end_of_string_or_before_ending_newline_short, Regex_end_of_string_or_before_ending_newline_long, parentOpt); + + context.AddIfMissing($@"\k< {Regex_name_or_number} >", Regex_named_backreference_short, Regex_named_backreference_long, parentOpt, @"\k<".Length, insertionText: @"\k<>"); // context.AddIfMissing(@"\<>", "", "", parentOpt, @"\<".Length)); - context.AddIfMissing(@"\1-9", regex_numbered_backreference_short, regex_numbered_backreference_long, parentOpt, @"\".Length, @"\"); + context.AddIfMissing(@"\1-9", Regex_numbered_backreference_short, Regex_numbered_backreference_long, parentOpt, @"\".Length, @"\"); } - context.AddIfMissing(@"\a", regex_bell_character_short, regex_bell_character_long, parentOpt); - context.AddIfMissing(@"\b", regex_backspace_character_short, regex_backspace_character_long, parentOpt); - context.AddIfMissing(@"\e", regex_escape_character_short, regex_escape_character_long, parentOpt); - context.AddIfMissing(@"\f", regex_form_feed_character_short, regex_form_feed_character_long, parentOpt); - context.AddIfMissing(@"\n", regex_new_line_character_short, regex_new_line_character_long, parentOpt); - context.AddIfMissing(@"\r", regex_carriage_return_character_short, regex_carriage_return_character_long, parentOpt); - context.AddIfMissing(@"\t", regex_tab_character_short, regex_tab_character_long, parentOpt); - context.AddIfMissing(@"\v", regex_vertical_tab_character_short, regex_vertical_tab_character_long, parentOpt); - - context.AddIfMissing(@"\x##", regex_hexadecimal_escape_short, regex_hexadecimal_escape_long, parentOpt, @"\x".Length, @"\x"); - context.AddIfMissing(@"\u####", regex_unicode_escape_short, regex_unicode_escape_long, parentOpt, @"\u".Length, @"\u"); - context.AddIfMissing(@"\cX", regex_control_character_short, regex_control_character_long, parentOpt, @"\c".Length, @"\c"); - - context.AddIfMissing(@"\d", regex_decimal_digit_character_short, regex_decimal_digit_character_long, parentOpt); - context.AddIfMissing(@"\D", regex_non_digit_character_short, regex_non_digit_character_long, parentOpt); - context.AddIfMissing(@"\p{...}", regex_unicode_category_short, regex_unicode_category_long, parentOpt, @"\p".Length, @"\p"); - context.AddIfMissing(@"\P{...}", regex_negative_unicode_category_short, regex_negative_unicode_category_long, parentOpt, @"\P".Length, @"\P"); - context.AddIfMissing(@"\s", regex_white_space_character_short, regex_white_space_character_long, parentOpt); - context.AddIfMissing(@"\S", regex_non_white_space_character_short, regex_non_white_space_character_long, parentOpt); - context.AddIfMissing(@"\w", regex_word_character_short, regex_word_character_long, parentOpt); - context.AddIfMissing(@"\W", regex_non_word_character_short, regex_non_word_character_long, parentOpt); + context.AddIfMissing(@"\a", Regex_bell_character_short, Regex_bell_character_long, parentOpt); + context.AddIfMissing(@"\b", Regex_backspace_character_short, Regex_backspace_character_long, parentOpt); + context.AddIfMissing(@"\e", Regex_escape_character_short, Regex_escape_character_long, parentOpt); + context.AddIfMissing(@"\f", Regex_form_feed_character_short, Regex_form_feed_character_long, parentOpt); + context.AddIfMissing(@"\n", Regex_new_line_character_short, Regex_new_line_character_long, parentOpt); + context.AddIfMissing(@"\r", Regex_carriage_return_character_short, Regex_carriage_return_character_long, parentOpt); + context.AddIfMissing(@"\t", Regex_tab_character_short, Regex_tab_character_long, parentOpt); + context.AddIfMissing(@"\v", Regex_vertical_tab_character_short, Regex_vertical_tab_character_long, parentOpt); + + context.AddIfMissing(@"\x##", Regex_hexadecimal_escape_short, Regex_hexadecimal_escape_long, parentOpt, @"\x".Length, @"\x"); + context.AddIfMissing(@"\u####", Regex_unicode_escape_short, Regex_unicode_escape_long, parentOpt, @"\u".Length, @"\u"); + context.AddIfMissing(@"\cX", Regex_control_character_short, Regex_control_character_long, parentOpt, @"\c".Length, @"\c"); + + context.AddIfMissing(@"\d", Regex_decimal_digit_character_short, Regex_decimal_digit_character_long, parentOpt); + context.AddIfMissing(@"\D", Regex_non_digit_character_short, Regex_non_digit_character_long, parentOpt); + context.AddIfMissing(@"\p{...}", Regex_unicode_category_short, Regex_unicode_category_long, parentOpt, @"\p".Length, @"\p"); + context.AddIfMissing(@"\P{...}", Regex_negative_unicode_category_short, Regex_negative_unicode_category_long, parentOpt, @"\P".Length, @"\P"); + context.AddIfMissing(@"\s", Regex_white_space_character_short, Regex_white_space_character_long, parentOpt); + context.AddIfMissing(@"\S", Regex_non_white_space_character_short, Regex_non_white_space_character_long, parentOpt); + context.AddIfMissing(@"\w", Regex_word_character_short, Regex_word_character_long, parentOpt); + context.AddIfMissing(@"\W", Regex_non_word_character_short, Regex_non_word_character_long, parentOpt); } private RegexItem CreateItem( diff --git a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs index 5ef7fc3050f..e19bda64f9f 100644 --- a/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs +++ b/src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexCharClass.cs @@ -40,49 +40,49 @@ internal static class RegexCharClass new Dictionary { // Others - { "Cc", (regex_other_control, "") }, - { "Cf", (regex_other_format, "") }, - { "Cn", (regex_other_not_assigned, "") }, - { "Co", (regex_other_private_use, "") }, - { "Cs", (regex_other_surrogate, "") }, - { "C", (regex_all_control_characters_short, regex_all_control_characters_long) }, + { "Cc", (Regex_other_control, "") }, + { "Cf", (Regex_other_format, "") }, + { "Cn", (Regex_other_not_assigned, "") }, + { "Co", (Regex_other_private_use, "") }, + { "Cs", (Regex_other_surrogate, "") }, + { "C", (Regex_all_control_characters_short, Regex_all_control_characters_long) }, // Letters - { "Ll", (regex_letter_lowercase, "") }, - { "Lm", (regex_letter_modifier, "") }, - { "Lo", (regex_letter_other, "") }, - { "Lt", (regex_letter_titlecase, "") }, - { "Lu", (regex_letter_uppercase, "") }, - { "L", (regex_all_letter_characters_short, regex_all_letter_characters_long) }, + { "Ll", (Regex_letter_lowercase, "") }, + { "Lm", (Regex_letter_modifier, "") }, + { "Lo", (Regex_letter_other, "") }, + { "Lt", (Regex_letter_titlecase, "") }, + { "Lu", (Regex_letter_uppercase, "") }, + { "L", (Regex_all_letter_characters_short, Regex_all_letter_characters_long) }, // Marks - { "Mc", (regex_mark_spacing_combining, "") }, - { "Me", (regex_mark_enclosing, "") }, - { "Mn", (regex_mark_nonspacing, "") }, - { "M", (regex_all_diacritic_marks_short, regex_all_diacritic_marks_long) }, + { "Mc", (Regex_mark_spacing_combining, "") }, + { "Me", (Regex_mark_enclosing, "") }, + { "Mn", (Regex_mark_nonspacing, "") }, + { "M", (Regex_all_diacritic_marks_short, Regex_all_diacritic_marks_long) }, // Numbers - { "Nd", (regex_number_decimal_digit, "") }, - { "Nl", (regex_number_letter, "") }, - { "No", (regex_number_other, "") }, - { "N", (regex_all_numbers_short, regex_all_numbers_long) }, + { "Nd", (Regex_number_decimal_digit, "") }, + { "Nl", (Regex_number_letter, "") }, + { "No", (Regex_number_other, "") }, + { "N", (Regex_all_numbers_short, Regex_all_numbers_long) }, // Punctuation - { "Pc", (regex_punctuation_connector, "") }, - { "Pd", (regex_punctuation_dash, "") }, - { "Pe", (regex_punctuation_close, "") }, - { "Po", (regex_punctuation_other, "") }, - { "Ps", (regex_punctuation_open, "") }, - { "Pf", (regex_punctuation_final_quote, "") }, - { "Pi", (regex_punctuation_initial_quote, "") }, - { "P", (regex_all_punctuation_characters_short, regex_all_punctuation_characters_long) }, + { "Pc", (Regex_punctuation_connector, "") }, + { "Pd", (Regex_punctuation_dash, "") }, + { "Pe", (Regex_punctuation_close, "") }, + { "Po", (Regex_punctuation_other, "") }, + { "Ps", (Regex_punctuation_open, "") }, + { "Pf", (Regex_punctuation_final_quote, "") }, + { "Pi", (Regex_punctuation_initial_quote, "") }, + { "P", (Regex_all_punctuation_characters_short, Regex_all_punctuation_characters_long) }, // Symbols - { "Sc", (regex_symbol_currency, "") }, - { "Sk", (regex_symbol_modifier, "") }, - { "Sm", (regex_symbol_math, "") }, - { "So", (regex_symbol_other, "") }, - { "S", (regex_all_symbols_short, regex_all_symbols_long) }, + { "Sc", (Regex_symbol_currency, "") }, + { "Sk", (Regex_symbol_modifier, "") }, + { "Sm", (Regex_symbol_math, "") }, + { "So", (Regex_symbol_other, "") }, + { "S", (Regex_all_symbols_short, Regex_all_symbols_long) }, // Separators - { "Zl", (regex_separator_line, "") }, - { "Zp", (regex_separator_paragraph, "") }, - { "Zs", (regex_separator_space, "") }, - { "Z", (regex_all_separator_characters_short, regex_all_separator_characters_long) }, + { "Zl", (Regex_separator_line, "") }, + { "Zp", (Regex_separator_paragraph, "") }, + { "Zs", (Regex_separator_space, "") }, + { "Z", (Regex_all_separator_characters_short, Regex_all_separator_characters_long) }, { "IsAlphabeticPresentationForms", ("", "") }, { "IsArabic", ("", "") }, diff --git a/src/Workspaces/Core/Portable/WorkspacesResources.Designer.cs b/src/Workspaces/Core/Portable/WorkspacesResources.Designer.cs index 858b7c9fd11..7d4b6b70e32 100644 --- a/src/Workspaces/Core/Portable/WorkspacesResources.Designer.cs +++ b/src/Workspaces/Core/Portable/WorkspacesResources.Designer.cs @@ -1369,180 +1369,180 @@ internal class WorkspacesResources { /// /// Looks up a localized string similar to All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories.. /// - internal static string regex_all_control_characters_long { + internal static string Regex_all_control_characters_long { get { - return ResourceManager.GetString("regex_all_control_characters_long", resourceCulture); + return ResourceManager.GetString("Regex_all_control_characters_long", resourceCulture); } } /// /// Looks up a localized string similar to all control characters. /// - internal static string regex_all_control_characters_short { + internal static string Regex_all_control_characters_short { get { - return ResourceManager.GetString("regex_all_control_characters_short", resourceCulture); + return ResourceManager.GetString("Regex_all_control_characters_short", resourceCulture); } } /// /// Looks up a localized string similar to All diacritic marks. This includes the Mn, Mc, and Me categories.. /// - internal static string regex_all_diacritic_marks_long { + internal static string Regex_all_diacritic_marks_long { get { - return ResourceManager.GetString("regex_all_diacritic_marks_long", resourceCulture); + return ResourceManager.GetString("Regex_all_diacritic_marks_long", resourceCulture); } } /// /// Looks up a localized string similar to all diacritic marks. /// - internal static string regex_all_diacritic_marks_short { + internal static string Regex_all_diacritic_marks_short { get { - return ResourceManager.GetString("regex_all_diacritic_marks_short", resourceCulture); + return ResourceManager.GetString("Regex_all_diacritic_marks_short", resourceCulture); } } /// /// Looks up a localized string similar to All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters.. /// - internal static string regex_all_letter_characters_long { + internal static string Regex_all_letter_characters_long { get { - return ResourceManager.GetString("regex_all_letter_characters_long", resourceCulture); + return ResourceManager.GetString("Regex_all_letter_characters_long", resourceCulture); } } /// /// Looks up a localized string similar to all letter characters. /// - internal static string regex_all_letter_characters_short { + internal static string Regex_all_letter_characters_short { get { - return ResourceManager.GetString("regex_all_letter_characters_short", resourceCulture); + return ResourceManager.GetString("Regex_all_letter_characters_short", resourceCulture); } } /// /// Looks up a localized string similar to All numbers. This includes the Nd, Nl, and No categories.. /// - internal static string regex_all_numbers_long { + internal static string Regex_all_numbers_long { get { - return ResourceManager.GetString("regex_all_numbers_long", resourceCulture); + return ResourceManager.GetString("Regex_all_numbers_long", resourceCulture); } } /// /// Looks up a localized string similar to all numbers. /// - internal static string regex_all_numbers_short { + internal static string Regex_all_numbers_short { get { - return ResourceManager.GetString("regex_all_numbers_short", resourceCulture); + return ResourceManager.GetString("Regex_all_numbers_short", resourceCulture); } } /// /// Looks up a localized string similar to All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.. /// - internal static string regex_all_punctuation_characters_long { + internal static string Regex_all_punctuation_characters_long { get { - return ResourceManager.GetString("regex_all_punctuation_characters_long", resourceCulture); + return ResourceManager.GetString("Regex_all_punctuation_characters_long", resourceCulture); } } /// /// Looks up a localized string similar to all punctuation characters. /// - internal static string regex_all_punctuation_characters_short { + internal static string Regex_all_punctuation_characters_short { get { - return ResourceManager.GetString("regex_all_punctuation_characters_short", resourceCulture); + return ResourceManager.GetString("Regex_all_punctuation_characters_short", resourceCulture); } } /// /// Looks up a localized string similar to All separator characters. This includes the Zs, Zl, and Zp categories.. /// - internal static string regex_all_separator_characters_long { + internal static string Regex_all_separator_characters_long { get { - return ResourceManager.GetString("regex_all_separator_characters_long", resourceCulture); + return ResourceManager.GetString("Regex_all_separator_characters_long", resourceCulture); } } /// /// Looks up a localized string similar to all separator characters. /// - internal static string regex_all_separator_characters_short { + internal static string Regex_all_separator_characters_short { get { - return ResourceManager.GetString("regex_all_separator_characters_short", resourceCulture); + return ResourceManager.GetString("Regex_all_separator_characters_short", resourceCulture); } } /// /// Looks up a localized string similar to All symbols. This includes the Sm, Sc, Sk, and So categories.. /// - internal static string regex_all_symbols_long { + internal static string Regex_all_symbols_long { get { - return ResourceManager.GetString("regex_all_symbols_long", resourceCulture); + return ResourceManager.GetString("Regex_all_symbols_long", resourceCulture); } } /// /// Looks up a localized string similar to all symbols. /// - internal static string regex_all_symbols_short { + internal static string Regex_all_symbols_short { get { - return ResourceManager.GetString("regex_all_symbols_short", resourceCulture); + return ResourceManager.GetString("Regex_all_symbols_short", resourceCulture); } } /// /// Looks up a localized string similar to You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern.. /// - internal static string regex_alternation_long { + internal static string Regex_alternation_long { get { - return ResourceManager.GetString("regex_alternation_long", resourceCulture); + return ResourceManager.GetString("Regex_alternation_long", resourceCulture); } } /// /// Looks up a localized string similar to alternation. /// - internal static string regex_alternation_short { + internal static string Regex_alternation_short { get { - return ResourceManager.GetString("regex_alternation_short", resourceCulture); + return ResourceManager.GetString("Regex_alternation_short", resourceCulture); } } /// /// Looks up a localized string similar to The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character.. /// - internal static string regex_any_character_group_long { + internal static string Regex_any_character_group_long { get { - return ResourceManager.GetString("regex_any_character_group_long", resourceCulture); + return ResourceManager.GetString("Regex_any_character_group_long", resourceCulture); } } /// /// Looks up a localized string similar to any character. /// - internal static string regex_any_character_group_short { + internal static string Regex_any_character_group_short { get { - return ResourceManager.GetString("regex_any_character_group_short", resourceCulture); + return ResourceManager.GetString("Regex_any_character_group_short", resourceCulture); } } /// /// Looks up a localized string similar to Matches a backspace character, \u0008. /// - internal static string regex_backspace_character_long { + internal static string Regex_backspace_character_long { get { - return ResourceManager.GetString("regex_backspace_character_long", resourceCulture); + return ResourceManager.GetString("Regex_backspace_character_long", resourceCulture); } } /// /// Looks up a localized string similar to backspace character. /// - internal static string regex_backspace_character_short { + internal static string Regex_backspace_character_short { get { - return ResourceManager.GetString("regex_backspace_character_short", resourceCulture); + return ResourceManager.GetString("Regex_backspace_character_short", resourceCulture); } } @@ -1551,63 +1551,63 @@ internal class WorkspacesResources { /// ///'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Be [rest of string was truncated]";. /// - internal static string regex_balancing_group_long { + internal static string Regex_balancing_group_long { get { - return ResourceManager.GetString("regex_balancing_group_long", resourceCulture); + return ResourceManager.GetString("Regex_balancing_group_long", resourceCulture); } } /// /// Looks up a localized string similar to balancing group. /// - internal static string regex_balancing_group_short { + internal static string Regex_balancing_group_short { get { - return ResourceManager.GetString("regex_balancing_group_short", resourceCulture); + return ResourceManager.GetString("Regex_balancing_group_short", resourceCulture); } } /// /// Looks up a localized string similar to base-group. /// - internal static string regex_base_group { + internal static string Regex_base_group { get { - return ResourceManager.GetString("regex_base_group", resourceCulture); + return ResourceManager.GetString("Regex_base_group", resourceCulture); } } /// /// Looks up a localized string similar to Matches a bell (alarm) character, \u0007. /// - internal static string regex_bell_character_long { + internal static string Regex_bell_character_long { get { - return ResourceManager.GetString("regex_bell_character_long", resourceCulture); + return ResourceManager.GetString("Regex_bell_character_long", resourceCulture); } } /// /// Looks up a localized string similar to bell character. /// - internal static string regex_bell_character_short { + internal static string Regex_bell_character_short { get { - return ResourceManager.GetString("regex_bell_character_short", resourceCulture); + return ResourceManager.GetString("Regex_bell_character_short", resourceCulture); } } /// /// Looks up a localized string similar to Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n.. /// - internal static string regex_carriage_return_character_long { + internal static string Regex_carriage_return_character_long { get { - return ResourceManager.GetString("regex_carriage_return_character_long", resourceCulture); + return ResourceManager.GetString("Regex_carriage_return_character_long", resourceCulture); } } /// /// Looks up a localized string similar to carriage-return character. /// - internal static string regex_carriage_return_character_short { + internal static string Regex_carriage_return_character_short { get { - return ResourceManager.GetString("regex_carriage_return_character_short", resourceCulture); + return ResourceManager.GetString("Regex_carriage_return_character_short", resourceCulture); } } @@ -1616,36 +1616,36 @@ internal class WorkspacesResources { /// ///'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).. /// - internal static string regex_character_class_subtraction_long { + internal static string Regex_character_class_subtraction_long { get { - return ResourceManager.GetString("regex_character_class_subtraction_long", resourceCulture); + return ResourceManager.GetString("Regex_character_class_subtraction_long", resourceCulture); } } /// /// Looks up a localized string similar to character class subtraction. /// - internal static string regex_character_class_subtraction_short { + internal static string Regex_character_class_subtraction_short { get { - return ResourceManager.GetString("regex_character_class_subtraction_short", resourceCulture); + return ResourceManager.GetString("Regex_character_class_subtraction_short", resourceCulture); } } /// /// Looks up a localized string similar to character-group. /// - internal static string regex_character_group { + internal static string Regex_character_group { get { - return ResourceManager.GetString("regex_character_group", resourceCulture); + return ResourceManager.GetString("Regex_character_group", resourceCulture); } } /// /// Looks up a localized string similar to comment. /// - internal static string regex_comment { + internal static string Regex_comment { get { - return ResourceManager.GetString("regex_comment", resourceCulture); + return ResourceManager.GetString("Regex_comment", resourceCulture); } } @@ -1654,18 +1654,18 @@ internal class WorkspacesResources { /// ///'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched.. /// - internal static string regex_conditional_expression_match_long { + internal static string Regex_conditional_expression_match_long { get { - return ResourceManager.GetString("regex_conditional_expression_match_long", resourceCulture); + return ResourceManager.GetString("Regex_conditional_expression_match_long", resourceCulture); } } /// /// Looks up a localized string similar to conditional expression match. /// - internal static string regex_conditional_expression_match_short { + internal static string Regex_conditional_expression_match_short { get { - return ResourceManager.GetString("regex_conditional_expression_match_short", resourceCulture); + return ResourceManager.GetString("Regex_conditional_expression_match_short", resourceCulture); } } @@ -1674,54 +1674,54 @@ internal class WorkspacesResources { /// ///'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not.. /// - internal static string regex_conditional_group_match_long { + internal static string Regex_conditional_group_match_long { get { - return ResourceManager.GetString("regex_conditional_group_match_long", resourceCulture); + return ResourceManager.GetString("Regex_conditional_group_match_long", resourceCulture); } } /// /// Looks up a localized string similar to conditional group match. /// - internal static string regex_conditional_group_match_short { + internal static string Regex_conditional_group_match_short { get { - return ResourceManager.GetString("regex_conditional_group_match_short", resourceCulture); + return ResourceManager.GetString("Regex_conditional_group_match_short", resourceCulture); } } /// /// Looks up a localized string similar to The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous.. /// - internal static string regex_contiguous_matches_long { + internal static string Regex_contiguous_matches_long { get { - return ResourceManager.GetString("regex_contiguous_matches_long", resourceCulture); + return ResourceManager.GetString("Regex_contiguous_matches_long", resourceCulture); } } /// /// Looks up a localized string similar to contiguous matches. /// - internal static string regex_contiguous_matches_short { + internal static string Regex_contiguous_matches_short { get { - return ResourceManager.GetString("regex_contiguous_matches_short", resourceCulture); + return ResourceManager.GetString("Regex_contiguous_matches_short", resourceCulture); } } /// /// Looks up a localized string similar to Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C.. /// - internal static string regex_control_character_long { + internal static string Regex_control_character_long { get { - return ResourceManager.GetString("regex_control_character_long", resourceCulture); + return ResourceManager.GetString("Regex_control_character_long", resourceCulture); } } /// /// Looks up a localized string similar to control character. /// - internal static string regex_control_character_short { + internal static string Regex_control_character_short { get { - return ResourceManager.GetString("regex_control_character_short", resourceCulture); + return ResourceManager.GetString("Regex_control_character_short", resourceCulture); } } @@ -1730,54 +1730,54 @@ internal class WorkspacesResources { /// ///If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]. /// - internal static string regex_decimal_digit_character_long { + internal static string Regex_decimal_digit_character_long { get { - return ResourceManager.GetString("regex_decimal_digit_character_long", resourceCulture); + return ResourceManager.GetString("Regex_decimal_digit_character_long", resourceCulture); } } /// /// Looks up a localized string similar to decimal-digit character. /// - internal static string regex_decimal_digit_character_short { + internal static string Regex_decimal_digit_character_short { get { - return ResourceManager.GetString("regex_decimal_digit_character_short", resourceCulture); + return ResourceManager.GetString("Regex_decimal_digit_character_short", resourceCulture); } } /// /// Looks up a localized string similar to A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method.. /// - internal static string regex_end_of_line_comment_long { + internal static string Regex_end_of_line_comment_long { get { - return ResourceManager.GetString("regex_end_of_line_comment_long", resourceCulture); + return ResourceManager.GetString("Regex_end_of_line_comment_long", resourceCulture); } } /// /// Looks up a localized string similar to end-of-line comment. /// - internal static string regex_end_of_line_comment_short { + internal static string Regex_end_of_line_comment_short { get { - return ResourceManager.GetString("regex_end_of_line_comment_short", resourceCulture); + return ResourceManager.GetString("Regex_end_of_line_comment_short", resourceCulture); } } /// /// Looks up a localized string similar to The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string.. /// - internal static string regex_end_of_string_only_long { + internal static string Regex_end_of_string_only_long { get { - return ResourceManager.GetString("regex_end_of_string_only_long", resourceCulture); + return ResourceManager.GetString("Regex_end_of_string_only_long", resourceCulture); } } /// /// Looks up a localized string similar to end of string only. /// - internal static string regex_end_of_string_only_short { + internal static string Regex_end_of_string_only_short { get { - return ResourceManager.GetString("regex_end_of_string_only_short", resourceCulture); + return ResourceManager.GetString("Regex_end_of_string_only_short", resourceCulture); } } @@ -1786,18 +1786,18 @@ internal class WorkspacesResources { /// ///The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern.. /// - internal static string regex_end_of_string_or_before_ending_newline_long { + internal static string Regex_end_of_string_or_before_ending_newline_long { get { - return ResourceManager.GetString("regex_end_of_string_or_before_ending_newline_long", resourceCulture); + return ResourceManager.GetString("Regex_end_of_string_or_before_ending_newline_long", resourceCulture); } } /// /// Looks up a localized string similar to end of string or before ending newline. /// - internal static string regex_end_of_string_or_before_ending_newline_short { + internal static string Regex_end_of_string_or_before_ending_newline_short { get { - return ResourceManager.GetString("regex_end_of_string_or_before_ending_newline_short", resourceCulture); + return ResourceManager.GetString("Regex_end_of_string_or_before_ending_newline_short", resourceCulture); } } @@ -1806,72 +1806,72 @@ internal class WorkspacesResources { /// ///The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern.. /// - internal static string regex_end_of_string_or_line_long { + internal static string Regex_end_of_string_or_line_long { get { - return ResourceManager.GetString("regex_end_of_string_or_line_long", resourceCulture); + return ResourceManager.GetString("Regex_end_of_string_or_line_long", resourceCulture); } } /// /// Looks up a localized string similar to end of string or line. /// - internal static string regex_end_of_string_or_line_short { + internal static string Regex_end_of_string_or_line_short { get { - return ResourceManager.GetString("regex_end_of_string_or_line_short", resourceCulture); + return ResourceManager.GetString("Regex_end_of_string_or_line_short", resourceCulture); } } /// /// Looks up a localized string similar to Matches an escape character, \u001B. /// - internal static string regex_escape_character_long { + internal static string Regex_escape_character_long { get { - return ResourceManager.GetString("regex_escape_character_long", resourceCulture); + return ResourceManager.GetString("Regex_escape_character_long", resourceCulture); } } /// /// Looks up a localized string similar to escape character. /// - internal static string regex_escape_character_short { + internal static string Regex_escape_character_short { get { - return ResourceManager.GetString("regex_escape_character_short", resourceCulture); + return ResourceManager.GetString("Regex_escape_character_short", resourceCulture); } } /// /// Looks up a localized string similar to excluded-group. /// - internal static string regex_excluded_group { + internal static string Regex_excluded_group { get { - return ResourceManager.GetString("regex_excluded_group", resourceCulture); + return ResourceManager.GetString("Regex_excluded_group", resourceCulture); } } /// /// Looks up a localized string similar to expression. /// - internal static string regex_expression { + internal static string Regex_expression { get { - return ResourceManager.GetString("regex_expression", resourceCulture); + return ResourceManager.GetString("Regex_expression", resourceCulture); } } /// /// Looks up a localized string similar to Matches a form-feed character, \u000C. /// - internal static string regex_form_feed_character_long { + internal static string Regex_form_feed_character_long { get { - return ResourceManager.GetString("regex_form_feed_character_long", resourceCulture); + return ResourceManager.GetString("Regex_form_feed_character_long", resourceCulture); } } /// /// Looks up a localized string similar to form-feed character. /// - internal static string regex_form_feed_character_short { + internal static string Regex_form_feed_character_short { get { - return ResourceManager.GetString("regex_form_feed_character_short", resourceCulture); + return ResourceManager.GetString("Regex_form_feed_character_short", resourceCulture); } } @@ -1884,54 +1884,54 @@ internal class WorkspacesResources { /// s Use single-line mode, where the period (.) matches every character /// (instead of every character exc [rest of string was truncated]";. /// - internal static string regex_group_options_long { + internal static string Regex_group_options_long { get { - return ResourceManager.GetString("regex_group_options_long", resourceCulture); + return ResourceManager.GetString("Regex_group_options_long", resourceCulture); } } /// /// Looks up a localized string similar to group options. /// - internal static string regex_group_options_short { + internal static string Regex_group_options_short { get { - return ResourceManager.GetString("regex_group_options_short", resourceCulture); + return ResourceManager.GetString("Regex_group_options_short", resourceCulture); } } /// /// Looks up a localized string similar to Matches an ASCII character, where ## is a two-digit hexadecimal character code.. /// - internal static string regex_hexadecimal_escape_long { + internal static string Regex_hexadecimal_escape_long { get { - return ResourceManager.GetString("regex_hexadecimal_escape_long", resourceCulture); + return ResourceManager.GetString("Regex_hexadecimal_escape_long", resourceCulture); } } /// /// Looks up a localized string similar to hexidecimal escape. /// - internal static string regex_hexadecimal_escape_short { + internal static string Regex_hexadecimal_escape_short { get { - return ResourceManager.GetString("regex_hexadecimal_escape_short", resourceCulture); + return ResourceManager.GetString("Regex_hexadecimal_escape_short", resourceCulture); } } /// /// Looks up a localized string similar to The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis.. /// - internal static string regex_inline_comment_long { + internal static string Regex_inline_comment_long { get { - return ResourceManager.GetString("regex_inline_comment_long", resourceCulture); + return ResourceManager.GetString("Regex_inline_comment_long", resourceCulture); } } /// /// Looks up a localized string similar to inline comment. /// - internal static string regex_inline_comment_short { + internal static string Regex_inline_comment_short { get { - return ResourceManager.GetString("regex_inline_comment_short", resourceCulture); + return ResourceManager.GetString("Regex_inline_comment_short", resourceCulture); } } @@ -1944,18 +1944,18 @@ internal class WorkspacesResources { /// s Use single-line mode, where the period (.) matches every character /// (instead of every charac [rest of string was truncated]";. /// - internal static string regex_inline_options_long { + internal static string Regex_inline_options_long { get { - return ResourceManager.GetString("regex_inline_options_long", resourceCulture); + return ResourceManager.GetString("Regex_inline_options_long", resourceCulture); } } /// /// Looks up a localized string similar to inline options. /// - internal static string regex_inline_options_short { + internal static string Regex_inline_options_short { get { - return ResourceManager.GetString("regex_inline_options_short", resourceCulture); + return ResourceManager.GetString("Regex_inline_options_short", resourceCulture); } } @@ -1971,342 +1971,342 @@ internal class WorkspacesResources { /// /// Looks up a localized string similar to letter, lowercase. /// - internal static string regex_letter_lowercase { + internal static string Regex_letter_lowercase { get { - return ResourceManager.GetString("regex_letter_lowercase", resourceCulture); + return ResourceManager.GetString("Regex_letter_lowercase", resourceCulture); } } /// /// Looks up a localized string similar to letter, modifier. /// - internal static string regex_letter_modifier { + internal static string Regex_letter_modifier { get { - return ResourceManager.GetString("regex_letter_modifier", resourceCulture); + return ResourceManager.GetString("Regex_letter_modifier", resourceCulture); } } /// /// Looks up a localized string similar to letter, other. /// - internal static string regex_letter_other { + internal static string Regex_letter_other { get { - return ResourceManager.GetString("regex_letter_other", resourceCulture); + return ResourceManager.GetString("Regex_letter_other", resourceCulture); } } /// /// Looks up a localized string similar to letter, titlecase. /// - internal static string regex_letter_titlecase { + internal static string Regex_letter_titlecase { get { - return ResourceManager.GetString("regex_letter_titlecase", resourceCulture); + return ResourceManager.GetString("Regex_letter_titlecase", resourceCulture); } } /// /// Looks up a localized string similar to letter, uppercase. /// - internal static string regex_letter_uppercase { + internal static string Regex_letter_uppercase { get { - return ResourceManager.GetString("regex_letter_uppercase", resourceCulture); + return ResourceManager.GetString("Regex_letter_uppercase", resourceCulture); } } /// /// Looks up a localized string similar to mark, enclosing. /// - internal static string regex_mark_enclosing { + internal static string Regex_mark_enclosing { get { - return ResourceManager.GetString("regex_mark_enclosing", resourceCulture); + return ResourceManager.GetString("Regex_mark_enclosing", resourceCulture); } } /// /// Looks up a localized string similar to mark, nonspacing. /// - internal static string regex_mark_nonspacing { + internal static string Regex_mark_nonspacing { get { - return ResourceManager.GetString("regex_mark_nonspacing", resourceCulture); + return ResourceManager.GetString("Regex_mark_nonspacing", resourceCulture); } } /// /// Looks up a localized string similar to mark, spacing combining. /// - internal static string regex_mark_spacing_combining { + internal static string Regex_mark_spacing_combining { get { - return ResourceManager.GetString("regex_mark_spacing_combining", resourceCulture); + return ResourceManager.GetString("Regex_mark_spacing_combining", resourceCulture); } } /// /// Looks up a localized string similar to The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,}. /// - internal static string regex_match_at_least_n_times_lazy_long { + internal static string Regex_match_at_least_n_times_lazy_long { get { - return ResourceManager.GetString("regex_match_at_least_n_times_lazy_long", resourceCulture); + return ResourceManager.GetString("Regex_match_at_least_n_times_lazy_long", resourceCulture); } } /// /// Looks up a localized string similar to match at least 'n' times (lazy). /// - internal static string regex_match_at_least_n_times_lazy_short { + internal static string Regex_match_at_least_n_times_lazy_short { get { - return ResourceManager.GetString("regex_match_at_least_n_times_lazy_short", resourceCulture); + return ResourceManager.GetString("Regex_match_at_least_n_times_lazy_short", resourceCulture); } } /// /// Looks up a localized string similar to The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}?. /// - internal static string regex_match_at_least_n_times_long { + internal static string Regex_match_at_least_n_times_long { get { - return ResourceManager.GetString("regex_match_at_least_n_times_long", resourceCulture); + return ResourceManager.GetString("Regex_match_at_least_n_times_long", resourceCulture); } } /// /// Looks up a localized string similar to match at least 'n' times. /// - internal static string regex_match_at_least_n_times_short { + internal static string Regex_match_at_least_n_times_short { get { - return ResourceManager.GetString("regex_match_at_least_n_times_short", resourceCulture); + return ResourceManager.GetString("Regex_match_at_least_n_times_short", resourceCulture); } } /// /// Looks up a localized string similar to The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m}. /// - internal static string regex_match_between_m_and_n_times_lazy_long { + internal static string Regex_match_between_m_and_n_times_lazy_long { get { - return ResourceManager.GetString("regex_match_between_m_and_n_times_lazy_long", resourceCulture); + return ResourceManager.GetString("Regex_match_between_m_and_n_times_lazy_long", resourceCulture); } } /// /// Looks up a localized string similar to match at least 'n' times (lazy). /// - internal static string regex_match_between_m_and_n_times_lazy_short { + internal static string Regex_match_between_m_and_n_times_lazy_short { get { - return ResourceManager.GetString("regex_match_between_m_and_n_times_lazy_short", resourceCulture); + return ResourceManager.GetString("Regex_match_between_m_and_n_times_lazy_short", resourceCulture); } } /// /// Looks up a localized string similar to The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}?. /// - internal static string regex_match_between_m_and_n_times_long { + internal static string Regex_match_between_m_and_n_times_long { get { - return ResourceManager.GetString("regex_match_between_m_and_n_times_long", resourceCulture); + return ResourceManager.GetString("Regex_match_between_m_and_n_times_long", resourceCulture); } } /// /// Looks up a localized string similar to match between 'm' and 'n' times. /// - internal static string regex_match_between_m_and_n_times_short { + internal static string Regex_match_between_m_and_n_times_short { get { - return ResourceManager.GetString("regex_match_between_m_and_n_times_short", resourceCulture); + return ResourceManager.GetString("Regex_match_between_m_and_n_times_short", resourceCulture); } } /// /// Looks up a localized string similar to The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+. /// - internal static string regex_match_exactly_n_times_lazy_long { + internal static string Regex_match_exactly_n_times_lazy_long { get { - return ResourceManager.GetString("regex_match_exactly_n_times_lazy_long", resourceCulture); + return ResourceManager.GetString("Regex_match_exactly_n_times_lazy_long", resourceCulture); } } /// /// Looks up a localized string similar to match exactly 'n' times (lazy). /// - internal static string regex_match_exactly_n_times_lazy_short { + internal static string Regex_match_exactly_n_times_lazy_short { get { - return ResourceManager.GetString("regex_match_exactly_n_times_lazy_short", resourceCulture); + return ResourceManager.GetString("Regex_match_exactly_n_times_lazy_short", resourceCulture); } } /// /// Looks up a localized string similar to The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}?. /// - internal static string regex_match_exactly_n_times_long { + internal static string Regex_match_exactly_n_times_long { get { - return ResourceManager.GetString("regex_match_exactly_n_times_long", resourceCulture); + return ResourceManager.GetString("Regex_match_exactly_n_times_long", resourceCulture); } } /// /// Looks up a localized string similar to match exactly 'n' times. /// - internal static string regex_match_exactly_n_times_short { + internal static string Regex_match_exactly_n_times_short { get { - return ResourceManager.GetString("regex_match_exactly_n_times_short", resourceCulture); + return ResourceManager.GetString("Regex_match_exactly_n_times_short", resourceCulture); } } /// /// Looks up a localized string similar to The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier +. /// - internal static string regex_match_one_or_more_times_lazy_long { + internal static string Regex_match_one_or_more_times_lazy_long { get { - return ResourceManager.GetString("regex_match_one_or_more_times_lazy_long", resourceCulture); + return ResourceManager.GetString("Regex_match_one_or_more_times_lazy_long", resourceCulture); } } /// /// Looks up a localized string similar to match one or more times (lazy). /// - internal static string regex_match_one_or_more_times_lazy_short { + internal static string Regex_match_one_or_more_times_lazy_short { get { - return ResourceManager.GetString("regex_match_one_or_more_times_lazy_short", resourceCulture); + return ResourceManager.GetString("Regex_match_one_or_more_times_lazy_short", resourceCulture); } } /// /// Looks up a localized string similar to The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?.. /// - internal static string regex_match_one_or_more_times_long { + internal static string Regex_match_one_or_more_times_long { get { - return ResourceManager.GetString("regex_match_one_or_more_times_long", resourceCulture); + return ResourceManager.GetString("Regex_match_one_or_more_times_long", resourceCulture); } } /// /// Looks up a localized string similar to match one or more times. /// - internal static string regex_match_one_or_more_times_short { + internal static string Regex_match_one_or_more_times_short { get { - return ResourceManager.GetString("regex_match_one_or_more_times_short", resourceCulture); + return ResourceManager.GetString("Regex_match_one_or_more_times_short", resourceCulture); } } /// /// Looks up a localized string similar to The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier *. /// - internal static string regex_match_zero_or_more_times_lazy_long { + internal static string Regex_match_zero_or_more_times_lazy_long { get { - return ResourceManager.GetString("regex_match_zero_or_more_times_lazy_long", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_more_times_lazy_long", resourceCulture); } } /// /// Looks up a localized string similar to match zero or more times (lazy). /// - internal static string regex_match_zero_or_more_times_lazy_short { + internal static string Regex_match_zero_or_more_times_lazy_short { get { - return ResourceManager.GetString("regex_match_zero_or_more_times_lazy_short", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_more_times_lazy_short", resourceCulture); } } /// /// Looks up a localized string similar to The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?.. /// - internal static string regex_match_zero_or_more_times_long { + internal static string Regex_match_zero_or_more_times_long { get { - return ResourceManager.GetString("regex_match_zero_or_more_times_long", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_more_times_long", resourceCulture); } } /// /// Looks up a localized string similar to match zero or more times. /// - internal static string regex_match_zero_or_more_times_short { + internal static string Regex_match_zero_or_more_times_short { get { - return ResourceManager.GetString("regex_match_zero_or_more_times_short", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_more_times_short", resourceCulture); } } /// /// Looks up a localized string similar to The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ?. /// - internal static string regex_match_zero_or_one_time_lazy_long { + internal static string Regex_match_zero_or_one_time_lazy_long { get { - return ResourceManager.GetString("regex_match_zero_or_one_time_lazy_long", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_one_time_lazy_long", resourceCulture); } } /// /// Looks up a localized string similar to match zero or one time (lazy). /// - internal static string regex_match_zero_or_one_time_lazy_short { + internal static string Regex_match_zero_or_one_time_lazy_short { get { - return ResourceManager.GetString("regex_match_zero_or_one_time_lazy_short", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_one_time_lazy_short", resourceCulture); } } /// /// Looks up a localized string similar to The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??.. /// - internal static string regex_match_zero_or_one_time_long { + internal static string Regex_match_zero_or_one_time_long { get { - return ResourceManager.GetString("regex_match_zero_or_one_time_long", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_one_time_long", resourceCulture); } } /// /// Looks up a localized string similar to match zero or one time. /// - internal static string regex_match_zero_or_one_time_short { + internal static string Regex_match_zero_or_one_time_short { get { - return ResourceManager.GetString("regex_match_zero_or_one_time_short", resourceCulture); + return ResourceManager.GetString("Regex_match_zero_or_one_time_short", resourceCulture); } } /// /// Looks up a localized string similar to This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern.. /// - internal static string regex_matched_subexpression_long { + internal static string Regex_matched_subexpression_long { get { - return ResourceManager.GetString("regex_matched_subexpression_long", resourceCulture); + return ResourceManager.GetString("Regex_matched_subexpression_long", resourceCulture); } } /// /// Looks up a localized string similar to matched subexpression. /// - internal static string regex_matched_subexpression_short { + internal static string Regex_matched_subexpression_short { get { - return ResourceManager.GetString("regex_matched_subexpression_short", resourceCulture); + return ResourceManager.GetString("Regex_matched_subexpression_short", resourceCulture); } } /// /// Looks up a localized string similar to name. /// - internal static string regex_name { + internal static string Regex_name { get { - return ResourceManager.GetString("regex_name", resourceCulture); + return ResourceManager.GetString("Regex_name", resourceCulture); } } /// /// Looks up a localized string similar to name-or-number. /// - internal static string regex_name_or_number { + internal static string Regex_name_or_number { get { - return ResourceManager.GetString("regex_name_or_number", resourceCulture); + return ResourceManager.GetString("Regex_name_or_number", resourceCulture); } } /// /// Looks up a localized string similar to name1. /// - internal static string regex_name1 { + internal static string Regex_name1 { get { - return ResourceManager.GetString("regex_name1", resourceCulture); + return ResourceManager.GetString("Regex_name1", resourceCulture); } } /// /// Looks up a localized string similar to name2. /// - internal static string regex_name2 { + internal static string Regex_name2 { get { - return ResourceManager.GetString("regex_name2", resourceCulture); + return ResourceManager.GetString("Regex_name2", resourceCulture); } } @@ -2315,18 +2315,18 @@ internal class WorkspacesResources { /// ///'name' is the name of a capturing group defined in the regular expression pattern.. /// - internal static string regex_named_backreference_long { + internal static string Regex_named_backreference_long { get { - return ResourceManager.GetString("regex_named_backreference_long", resourceCulture); + return ResourceManager.GetString("Regex_named_backreference_long", resourceCulture); } } /// /// Looks up a localized string similar to named backreference. /// - internal static string regex_named_backreference_short { + internal static string Regex_named_backreference_short { get { - return ResourceManager.GetString("regex_named_backreference_short", resourceCulture); + return ResourceManager.GetString("Regex_named_backreference_short", resourceCulture); } } @@ -2337,18 +2337,18 @@ internal class WorkspacesResources { /// ///If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing gro [rest of string was truncated]";. /// - internal static string regex_named_matched_subexpression_long { + internal static string Regex_named_matched_subexpression_long { get { - return ResourceManager.GetString("regex_named_matched_subexpression_long", resourceCulture); + return ResourceManager.GetString("Regex_named_matched_subexpression_long", resourceCulture); } } /// /// Looks up a localized string similar to named matched subexpression. /// - internal static string regex_named_matched_subexpression_short { + internal static string Regex_named_matched_subexpression_short { get { - return ResourceManager.GetString("regex_named_matched_subexpression_short", resourceCulture); + return ResourceManager.GetString("Regex_named_matched_subexpression_short", resourceCulture); } } @@ -2357,18 +2357,18 @@ internal class WorkspacesResources { /// ///Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].. /// - internal static string regex_negative_character_group_long { + internal static string Regex_negative_character_group_long { get { - return ResourceManager.GetString("regex_negative_character_group_long", resourceCulture); + return ResourceManager.GetString("Regex_negative_character_group_long", resourceCulture); } } /// /// Looks up a localized string similar to negative character group. /// - internal static string regex_negative_character_group_short { + internal static string Regex_negative_character_group_short { get { - return ResourceManager.GetString("regex_negative_character_group_short", resourceCulture); + return ResourceManager.GetString("Regex_negative_character_group_short", resourceCulture); } } @@ -2377,63 +2377,63 @@ internal class WorkspacesResources { /// ///Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].. /// - internal static string regex_negative_character_range_long { + internal static string Regex_negative_character_range_long { get { - return ResourceManager.GetString("regex_negative_character_range_long", resourceCulture); + return ResourceManager.GetString("Regex_negative_character_range_long", resourceCulture); } } /// /// Looks up a localized string similar to negative character range. /// - internal static string regex_negative_character_range_short { + internal static string Regex_negative_character_range_short { get { - return ResourceManager.GetString("regex_negative_character_range_short", resourceCulture); + return ResourceManager.GetString("Regex_negative_character_range_short", resourceCulture); } } /// /// Looks up a localized string similar to The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name.. /// - internal static string regex_negative_unicode_category_long { + internal static string Regex_negative_unicode_category_long { get { - return ResourceManager.GetString("regex_negative_unicode_category_long", resourceCulture); + return ResourceManager.GetString("Regex_negative_unicode_category_long", resourceCulture); } } /// /// Looks up a localized string similar to negative unicode category. /// - internal static string regex_negative_unicode_category_short { + internal static string Regex_negative_unicode_category_short { get { - return ResourceManager.GetString("regex_negative_unicode_category_short", resourceCulture); + return ResourceManager.GetString("Regex_negative_unicode_category_short", resourceCulture); } } /// /// Looks up a localized string similar to Matches a new-line character, \u000A. /// - internal static string regex_new_line_character_long { + internal static string Regex_new_line_character_long { get { - return ResourceManager.GetString("regex_new_line_character_long", resourceCulture); + return ResourceManager.GetString("Regex_new_line_character_long", resourceCulture); } } /// /// Looks up a localized string similar to new-line character. /// - internal static string regex_new_line_character_short { + internal static string Regex_new_line_character_short { get { - return ResourceManager.GetString("regex_new_line_character_short", resourceCulture); + return ResourceManager.GetString("Regex_new_line_character_short", resourceCulture); } } /// /// Looks up a localized string similar to no. /// - internal static string regex_no { + internal static string Regex_no { get { - return ResourceManager.GetString("regex_no", resourceCulture); + return ResourceManager.GetString("Regex_no", resourceCulture); } } @@ -2442,18 +2442,18 @@ internal class WorkspacesResources { /// ///If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]. /// - internal static string regex_non_digit_character_long { + internal static string Regex_non_digit_character_long { get { - return ResourceManager.GetString("regex_non_digit_character_long", resourceCulture); + return ResourceManager.GetString("Regex_non_digit_character_long", resourceCulture); } } /// /// Looks up a localized string similar to non-digit character. /// - internal static string regex_non_digit_character_short { + internal static string Regex_non_digit_character_short { get { - return ResourceManager.GetString("regex_non_digit_character_short", resourceCulture); + return ResourceManager.GetString("Regex_non_digit_character_short", resourceCulture); } } @@ -2462,36 +2462,36 @@ internal class WorkspacesResources { /// ///If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]. /// - internal static string regex_non_white_space_character_long { + internal static string Regex_non_white_space_character_long { get { - return ResourceManager.GetString("regex_non_white_space_character_long", resourceCulture); + return ResourceManager.GetString("Regex_non_white_space_character_long", resourceCulture); } } /// /// Looks up a localized string similar to non-white-space character. /// - internal static string regex_non_white_space_character_short { + internal static string Regex_non_white_space_character_short { get { - return ResourceManager.GetString("regex_non_white_space_character_short", resourceCulture); + return ResourceManager.GetString("Regex_non_white_space_character_short", resourceCulture); } } /// /// Looks up a localized string similar to The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor.. /// - internal static string regex_non_word_boundary_long { + internal static string Regex_non_word_boundary_long { get { - return ResourceManager.GetString("regex_non_word_boundary_long", resourceCulture); + return ResourceManager.GetString("Regex_non_word_boundary_long", resourceCulture); } } /// /// Looks up a localized string similar to non-word boundary. /// - internal static string regex_non_word_boundary_short { + internal static string Regex_non_word_boundary_short { get { - return ResourceManager.GetString("regex_non_word_boundary_short", resourceCulture); + return ResourceManager.GetString("Regex_non_word_boundary_short", resourceCulture); } } @@ -2509,18 +2509,18 @@ internal class WorkspacesResources { /// ///If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]. /// - internal static string regex_non_word_character_long { + internal static string Regex_non_word_character_long { get { - return ResourceManager.GetString("regex_non_word_character_long", resourceCulture); + return ResourceManager.GetString("Regex_non_word_character_long", resourceCulture); } } /// /// Looks up a localized string similar to non-word character. /// - internal static string regex_non_word_character_short { + internal static string Regex_non_word_character_short { get { - return ResourceManager.GetString("regex_non_word_character_short", resourceCulture); + return ResourceManager.GetString("Regex_non_word_character_short", resourceCulture); } } @@ -2529,18 +2529,18 @@ internal class WorkspacesResources { /// ///This option is recommended if you know that backtracking will not succeed. Preven [rest of string was truncated]";. /// - internal static string regex_nonbacktracking_subexpression_long { + internal static string Regex_nonbacktracking_subexpression_long { get { - return ResourceManager.GetString("regex_nonbacktracking_subexpression_long", resourceCulture); + return ResourceManager.GetString("Regex_nonbacktracking_subexpression_long", resourceCulture); } } /// /// Looks up a localized string similar to nonbacktracking subexpression. /// - internal static string regex_nonbacktracking_subexpression_short { + internal static string Regex_nonbacktracking_subexpression_short { get { - return ResourceManager.GetString("regex_nonbacktracking_subexpression_short", resourceCulture); + return ResourceManager.GetString("Regex_nonbacktracking_subexpression_short", resourceCulture); } } @@ -2551,45 +2551,45 @@ internal class WorkspacesResources { /// ///If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs.. /// - internal static string regex_noncapturing_group_long { + internal static string Regex_noncapturing_group_long { get { - return ResourceManager.GetString("regex_noncapturing_group_long", resourceCulture); + return ResourceManager.GetString("Regex_noncapturing_group_long", resourceCulture); } } /// /// Looks up a localized string similar to noncapturing group. /// - internal static string regex_noncapturing_group_short { + internal static string Regex_noncapturing_group_short { get { - return ResourceManager.GetString("regex_noncapturing_group_short", resourceCulture); + return ResourceManager.GetString("Regex_noncapturing_group_short", resourceCulture); } } /// /// Looks up a localized string similar to number, decimal digit. /// - internal static string regex_number_decimal_digit { + internal static string Regex_number_decimal_digit { get { - return ResourceManager.GetString("regex_number_decimal_digit", resourceCulture); + return ResourceManager.GetString("Regex_number_decimal_digit", resourceCulture); } } /// /// Looks up a localized string similar to number, letter. /// - internal static string regex_number_letter { + internal static string Regex_number_letter { get { - return ResourceManager.GetString("regex_number_letter", resourceCulture); + return ResourceManager.GetString("Regex_number_letter", resourceCulture); } } /// /// Looks up a localized string similar to number, other. /// - internal static string regex_number_other { + internal static string Regex_number_other { get { - return ResourceManager.GetString("regex_number_other", resourceCulture); + return ResourceManager.GetString("Regex_number_other", resourceCulture); } } @@ -2598,351 +2598,351 @@ internal class WorkspacesResources { /// ///There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot b [rest of string was truncated]";. /// - internal static string regex_numbered_backreference_long { + internal static string Regex_numbered_backreference_long { get { - return ResourceManager.GetString("regex_numbered_backreference_long", resourceCulture); + return ResourceManager.GetString("Regex_numbered_backreference_long", resourceCulture); } } /// /// Looks up a localized string similar to numbered backreference. /// - internal static string regex_numbered_backreference_short { + internal static string Regex_numbered_backreference_short { get { - return ResourceManager.GetString("regex_numbered_backreference_short", resourceCulture); + return ResourceManager.GetString("Regex_numbered_backreference_short", resourceCulture); } } /// /// Looks up a localized string similar to other, control. /// - internal static string regex_other_control { + internal static string Regex_other_control { get { - return ResourceManager.GetString("regex_other_control", resourceCulture); + return ResourceManager.GetString("Regex_other_control", resourceCulture); } } /// /// Looks up a localized string similar to other, format. /// - internal static string regex_other_format { + internal static string Regex_other_format { get { - return ResourceManager.GetString("regex_other_format", resourceCulture); + return ResourceManager.GetString("Regex_other_format", resourceCulture); } } /// /// Looks up a localized string similar to other, not assigned. /// - internal static string regex_other_not_assigned { + internal static string Regex_other_not_assigned { get { - return ResourceManager.GetString("regex_other_not_assigned", resourceCulture); + return ResourceManager.GetString("Regex_other_not_assigned", resourceCulture); } } /// /// Looks up a localized string similar to other, private use. /// - internal static string regex_other_private_use { + internal static string Regex_other_private_use { get { - return ResourceManager.GetString("regex_other_private_use", resourceCulture); + return ResourceManager.GetString("Regex_other_private_use", resourceCulture); } } /// /// Looks up a localized string similar to other, surrogate. /// - internal static string regex_other_surrogate { + internal static string Regex_other_surrogate { get { - return ResourceManager.GetString("regex_other_surrogate", resourceCulture); + return ResourceManager.GetString("Regex_other_surrogate", resourceCulture); } } /// /// Looks up a localized string similar to A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur.. /// - internal static string regex_positive_character_group_long { + internal static string Regex_positive_character_group_long { get { - return ResourceManager.GetString("regex_positive_character_group_long", resourceCulture); + return ResourceManager.GetString("Regex_positive_character_group_long", resourceCulture); } } /// /// Looks up a localized string similar to positive character group. /// - internal static string regex_positive_character_group_short { + internal static string Regex_positive_character_group_short { get { - return ResourceManager.GetString("regex_positive_character_group_short", resourceCulture); + return ResourceManager.GetString("Regex_positive_character_group_short", resourceCulture); } } /// /// Looks up a localized string similar to A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. . /// - internal static string regex_positive_character_range_long { + internal static string Regex_positive_character_range_long { get { - return ResourceManager.GetString("regex_positive_character_range_long", resourceCulture); + return ResourceManager.GetString("Regex_positive_character_range_long", resourceCulture); } } /// /// Looks up a localized string similar to positive character range. /// - internal static string regex_positive_character_range_short { + internal static string Regex_positive_character_range_short { get { - return ResourceManager.GetString("regex_positive_character_range_short", resourceCulture); + return ResourceManager.GetString("Regex_positive_character_range_short", resourceCulture); } } /// /// Looks up a localized string similar to punctuation, close. /// - internal static string regex_punctuation_close { + internal static string Regex_punctuation_close { get { - return ResourceManager.GetString("regex_punctuation_close", resourceCulture); + return ResourceManager.GetString("Regex_punctuation_close", resourceCulture); } } /// /// Looks up a localized string similar to punctuation, connector. /// - internal static string regex_punctuation_connector { + internal static string Regex_punctuation_connector { get { - return ResourceManager.GetString("regex_punctuation_connector", resourceCulture); + return ResourceManager.GetString("Regex_punctuation_connector", resourceCulture); } } /// /// Looks up a localized string similar to punctuation, dash. /// - internal static string regex_punctuation_dash { + internal static string Regex_punctuation_dash { get { - return ResourceManager.GetString("regex_punctuation_dash", resourceCulture); + return ResourceManager.GetString("Regex_punctuation_dash", resourceCulture); } } /// /// Looks up a localized string similar to punctuation, final quote. /// - internal static string regex_punctuation_final_quote { + internal static string Regex_punctuation_final_quote { get { - return ResourceManager.GetString("regex_punctuation_final_quote", resourceCulture); + return ResourceManager.GetString("Regex_punctuation_final_quote", resourceCulture); } } /// /// Looks up a localized string similar to punctuation, initial quote. /// - internal static string regex_punctuation_initial_quote { + internal static string Regex_punctuation_initial_quote { get { - return ResourceManager.GetString("regex_punctuation_initial_quote", resourceCulture); + return ResourceManager.GetString("Regex_punctuation_initial_quote", resourceCulture); } } /// /// Looks up a localized string similar to punctuation, open. /// - internal static string regex_punctuation_open { + internal static string Regex_punctuation_open { get { - return ResourceManager.GetString("regex_punctuation_open", resourceCulture); + return ResourceManager.GetString("Regex_punctuation_open", resourceCulture); } } /// /// Looks up a localized string similar to punctuation, other. /// - internal static string regex_punctuation_other { + internal static string Regex_punctuation_other { get { - return ResourceManager.GetString("regex_punctuation_other", resourceCulture); + return ResourceManager.GetString("Regex_punctuation_other", resourceCulture); } } /// /// Looks up a localized string similar to separator, line. /// - internal static string regex_separator_line { + internal static string Regex_separator_line { get { - return ResourceManager.GetString("regex_separator_line", resourceCulture); + return ResourceManager.GetString("Regex_separator_line", resourceCulture); } } /// /// Looks up a localized string similar to separator, paragraph. /// - internal static string regex_separator_paragraph { + internal static string Regex_separator_paragraph { get { - return ResourceManager.GetString("regex_separator_paragraph", resourceCulture); + return ResourceManager.GetString("Regex_separator_paragraph", resourceCulture); } } /// /// Looks up a localized string similar to separator, space. /// - internal static string regex_separator_space { + internal static string Regex_separator_space { get { - return ResourceManager.GetString("regex_separator_space", resourceCulture); + return ResourceManager.GetString("Regex_separator_space", resourceCulture); } } /// /// Looks up a localized string similar to The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.. /// - internal static string regex_start_of_string_only_long { + internal static string Regex_start_of_string_only_long { get { - return ResourceManager.GetString("regex_start_of_string_only_long", resourceCulture); + return ResourceManager.GetString("Regex_start_of_string_only_long", resourceCulture); } } /// /// Looks up a localized string similar to start of string only. /// - internal static string regex_start_of_string_only_short { + internal static string Regex_start_of_string_only_short { get { - return ResourceManager.GetString("regex_start_of_string_only_short", resourceCulture); + return ResourceManager.GetString("Regex_start_of_string_only_short", resourceCulture); } } /// /// Looks up a localized string similar to The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line.. /// - internal static string regex_start_of_string_or_line_long { + internal static string Regex_start_of_string_or_line_long { get { - return ResourceManager.GetString("regex_start_of_string_or_line_long", resourceCulture); + return ResourceManager.GetString("Regex_start_of_string_or_line_long", resourceCulture); } } /// /// Looks up a localized string similar to start of string or line. /// - internal static string regex_start_of_string_or_line_short { + internal static string Regex_start_of_string_or_line_short { get { - return ResourceManager.GetString("regex_start_of_string_or_line_short", resourceCulture); + return ResourceManager.GetString("Regex_start_of_string_or_line_short", resourceCulture); } } /// /// Looks up a localized string similar to subexpression. /// - internal static string regex_subexpression { + internal static string Regex_subexpression { get { - return ResourceManager.GetString("regex_subexpression", resourceCulture); + return ResourceManager.GetString("Regex_subexpression", resourceCulture); } } /// /// Looks up a localized string similar to symbol, currency. /// - internal static string regex_symbol_currency { + internal static string Regex_symbol_currency { get { - return ResourceManager.GetString("regex_symbol_currency", resourceCulture); + return ResourceManager.GetString("Regex_symbol_currency", resourceCulture); } } /// /// Looks up a localized string similar to symbol, math. /// - internal static string regex_symbol_math { + internal static string Regex_symbol_math { get { - return ResourceManager.GetString("regex_symbol_math", resourceCulture); + return ResourceManager.GetString("Regex_symbol_math", resourceCulture); } } /// /// Looks up a localized string similar to symbol, modifier. /// - internal static string regex_symbol_modifier { + internal static string Regex_symbol_modifier { get { - return ResourceManager.GetString("regex_symbol_modifier", resourceCulture); + return ResourceManager.GetString("Regex_symbol_modifier", resourceCulture); } } /// /// Looks up a localized string similar to symbol, other. /// - internal static string regex_symbol_other { + internal static string Regex_symbol_other { get { - return ResourceManager.GetString("regex_symbol_other", resourceCulture); + return ResourceManager.GetString("Regex_symbol_other", resourceCulture); } } /// /// Looks up a localized string similar to Matches a tab character, \u0009. /// - internal static string regex_tab_character_long { + internal static string Regex_tab_character_long { get { - return ResourceManager.GetString("regex_tab_character_long", resourceCulture); + return ResourceManager.GetString("Regex_tab_character_long", resourceCulture); } } /// /// Looks up a localized string similar to tab character. /// - internal static string regex_tab_character_short { + internal static string Regex_tab_character_short { get { - return ResourceManager.GetString("regex_tab_character_short", resourceCulture); + return ResourceManager.GetString("Regex_tab_character_short", resourceCulture); } } /// /// Looks up a localized string similar to The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name.. /// - internal static string regex_unicode_category_long { + internal static string Regex_unicode_category_long { get { - return ResourceManager.GetString("regex_unicode_category_long", resourceCulture); + return ResourceManager.GetString("Regex_unicode_category_long", resourceCulture); } } /// /// Looks up a localized string similar to unicode category. /// - internal static string regex_unicode_category_short { + internal static string Regex_unicode_category_short { get { - return ResourceManager.GetString("regex_unicode_category_short", resourceCulture); + return ResourceManager.GetString("Regex_unicode_category_short", resourceCulture); } } /// /// Looks up a localized string similar to Matches a UTF-16 code unit whose value is #### hexadecimal.. /// - internal static string regex_unicode_escape_long { + internal static string Regex_unicode_escape_long { get { - return ResourceManager.GetString("regex_unicode_escape_long", resourceCulture); + return ResourceManager.GetString("Regex_unicode_escape_long", resourceCulture); } } /// /// Looks up a localized string similar to unicode escape. /// - internal static string regex_unicode_escape_short { + internal static string Regex_unicode_escape_short { get { - return ResourceManager.GetString("regex_unicode_escape_short", resourceCulture); + return ResourceManager.GetString("Regex_unicode_escape_short", resourceCulture); } } /// /// Looks up a localized string similar to Unicode General Category: {0}. /// - internal static string regex_unicode_general_category_0 { + internal static string Regex_unicode_general_category_0 { get { - return ResourceManager.GetString("regex_unicode_general_category_0", resourceCulture); + return ResourceManager.GetString("Regex_unicode_general_category_0", resourceCulture); } } /// /// Looks up a localized string similar to Matches a vertical-tab character, \u000B. /// - internal static string regex_vertical_tab_character_long { + internal static string Regex_vertical_tab_character_long { get { - return ResourceManager.GetString("regex_vertical_tab_character_long", resourceCulture); + return ResourceManager.GetString("Regex_vertical_tab_character_long", resourceCulture); } } /// /// Looks up a localized string similar to vertical-tab character. /// - internal static string regex_vertical_tab_character_short { + internal static string Regex_vertical_tab_character_short { get { - return ResourceManager.GetString("regex_vertical_tab_character_short", resourceCulture); + return ResourceManager.GetString("Regex_vertical_tab_character_short", resourceCulture); } } @@ -2959,18 +2959,18 @@ internal class WorkspacesResources { /// ///If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]. /// - internal static string regex_white_space_character_long { + internal static string Regex_white_space_character_long { get { - return ResourceManager.GetString("regex_white_space_character_long", resourceCulture); + return ResourceManager.GetString("Regex_white_space_character_long", resourceCulture); } } /// /// Looks up a localized string similar to white-space character. /// - internal static string regex_white_space_character_short { + internal static string Regex_white_space_character_short { get { - return ResourceManager.GetString("regex_white_space_character_short", resourceCulture); + return ResourceManager.GetString("Regex_white_space_character_short", resourceCulture); } } @@ -2979,18 +2979,18 @@ internal class WorkspacesResources { /// ///The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beg [rest of string was truncated]";. /// - internal static string regex_word_boundary_long { + internal static string Regex_word_boundary_long { get { - return ResourceManager.GetString("regex_word_boundary_long", resourceCulture); + return ResourceManager.GetString("Regex_word_boundary_long", resourceCulture); } } /// /// Looks up a localized string similar to word boundary. /// - internal static string regex_word_boundary_short { + internal static string Regex_word_boundary_short { get { - return ResourceManager.GetString("regex_word_boundary_short", resourceCulture); + return ResourceManager.GetString("Regex_word_boundary_short", resourceCulture); } } @@ -3008,27 +3008,27 @@ internal class WorkspacesResources { /// ///If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]. /// - internal static string regex_word_character_long { + internal static string Regex_word_character_long { get { - return ResourceManager.GetString("regex_word_character_long", resourceCulture); + return ResourceManager.GetString("Regex_word_character_long", resourceCulture); } } /// /// Looks up a localized string similar to word character. /// - internal static string regex_word_character_short { + internal static string Regex_word_character_short { get { - return ResourceManager.GetString("regex_word_character_short", resourceCulture); + return ResourceManager.GetString("Regex_word_character_short", resourceCulture); } } /// /// Looks up a localized string similar to yes. /// - internal static string regex_yes { + internal static string Regex_yes { get { - return ResourceManager.GetString("regex_yes", resourceCulture); + return ResourceManager.GetString("Regex_yes", resourceCulture); } } @@ -3037,18 +3037,18 @@ internal class WorkspacesResources { /// ///A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but [rest of string was truncated]";. /// - internal static string regex_zero_width_negative_lookahead_assertion_long { + internal static string Regex_zero_width_negative_lookahead_assertion_long { get { - return ResourceManager.GetString("regex_zero_width_negative_lookahead_assertion_long", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_negative_lookahead_assertion_long", resourceCulture); } } /// /// Looks up a localized string similar to zero-width negative lookahead assertion. /// - internal static string regex_zero_width_negative_lookahead_assertion_short { + internal static string Regex_zero_width_negative_lookahead_assertion_short { get { - return ResourceManager.GetString("regex_zero_width_negative_lookahead_assertion_short", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_negative_lookahead_assertion_short", resourceCulture); } } @@ -3057,18 +3057,18 @@ internal class WorkspacesResources { /// ///Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or character [rest of string was truncated]";. /// - internal static string regex_zero_width_negative_lookbehind_assertion_long { + internal static string Regex_zero_width_negative_lookbehind_assertion_long { get { - return ResourceManager.GetString("regex_zero_width_negative_lookbehind_assertion_long", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_negative_lookbehind_assertion_long", resourceCulture); } } /// /// Looks up a localized string similar to zero-width negative lookbehind assertion. /// - internal static string regex_zero_width_negative_lookbehind_assertion_short { + internal static string Regex_zero_width_negative_lookbehind_assertion_short { get { - return ResourceManager.GetString("regex_zero_width_negative_lookbehind_assertion_short", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_negative_lookbehind_assertion_short", resourceCulture); } } @@ -3077,18 +3077,18 @@ internal class WorkspacesResources { /// ///Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the [rest of string was truncated]";. /// - internal static string regex_zero_width_positive_lookahead_assertion_long { + internal static string Regex_zero_width_positive_lookahead_assertion_long { get { - return ResourceManager.GetString("regex_zero_width_positive_lookahead_assertion_long", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_positive_lookahead_assertion_long", resourceCulture); } } /// /// Looks up a localized string similar to zero-width positive lookahead assertion. /// - internal static string regex_zero_width_positive_lookahead_assertion_short { + internal static string Regex_zero_width_positive_lookahead_assertion_short { get { - return ResourceManager.GetString("regex_zero_width_positive_lookahead_assertion_short", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_positive_lookahead_assertion_short", resourceCulture); } } @@ -3097,18 +3097,18 @@ internal class WorkspacesResources { /// ///Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result.. /// - internal static string regex_zero_width_positive_lookbehind_assertion_long { + internal static string Regex_zero_width_positive_lookbehind_assertion_long { get { - return ResourceManager.GetString("regex_zero_width_positive_lookbehind_assertion_long", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_positive_lookbehind_assertion_long", resourceCulture); } } /// /// Looks up a localized string similar to zero-width positive lookbehind assertion. /// - internal static string regex_zero_width_positive_lookbehind_assertion_short { + internal static string Regex_zero_width_positive_lookbehind_assertion_short { get { - return ResourceManager.GetString("regex_zero_width_positive_lookbehind_assertion_short", resourceCulture); + return ResourceManager.GetString("Regex_zero_width_positive_lookbehind_assertion_short", resourceCulture); } } diff --git a/src/Workspaces/Core/Portable/WorkspacesResources.resx b/src/Workspaces/Core/Portable/WorkspacesResources.resx index 2d62727565b..91f104eec1e 100644 --- a/src/Workspaces/Core/Portable/WorkspacesResources.resx +++ b/src/Workspaces/Core/Portable/WorkspacesResources.resx @@ -747,257 +747,257 @@ Refactoring Only - + number, decimal digit - + number, letter - + number, other - + other, control - + other, format - + other, not assigned - + other, private use - + other, surrogate - + punctuation, close - + punctuation, connector - + punctuation, dash - + punctuation, final quote - + punctuation, initial quote - + punctuation, open - + punctuation, other - + separator, line - + separator, paragraph - + separator, space - + symbol, currency - + symbol, math - + symbol, modifier - + symbol, other - + letter, lowercase - + letter, modifier - + letter, other - + letter, titlecase - + mark, enclosing - + mark, nonspacing - + mark, spacing combining - + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - + contiguous matches - + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - + end of string only - + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - + end of string or before ending newline - + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - + non-word boundary - + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + start of string only - + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - + word boundary - + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + start of string or line - + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - + end of string or line - + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - + any character - + Matches a backspace character, \u0008 - + backspace character - + Matches a bell (alarm) character, \u0007 - + bell character - + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - + carriage-return character - + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - + control character - + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - + decimal-digit character - + Matches an escape character, \u001B - + escape character - + Matches a form-feed character, \u000C - + form-feed character - + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - + hexidecimal escape - + letter, uppercase - + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - + matched subexpression - + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - + negative character group - + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - + negative character range - + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - + negative unicode category - + Matches a new-line character, \u000A - + new-line character - + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - + non-digit character - + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - + non-white-space character - + \W matches any non-word character. It matches any character except for those in the following Unicode categories: Ll Letter, Lowercase @@ -1012,49 +1012,49 @@ If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. - + non-word character - + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - + positive character group - + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - + positive character range - + subexpression - + Matches a tab character, \u0009 - + tab character - + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + unicode category - + Matches a UTF-16 code unit whose value is #### hexadecimal. - + unicode escape - + Matches a vertical-tab character, \u000B - + vertical-tab character - + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: \f The form feed character, \u000C @@ -1067,10 +1067,10 @@ If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - + white-space character - + \w matches any word character. A word character is a member of any of the following Unicode categories: Ll Letter, Lowercase @@ -1084,54 +1084,54 @@ If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - + word character - + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - + alternation - + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. 'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - + balancing group - + comment - + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. 'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - + conditional expression match - + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. 'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - + conditional group match - + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - + end-of-line comment - + expression - + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: i Use case-insensitive matching. @@ -1144,244 +1144,244 @@ The balancing group definition uses 'name2' as a stack. The beginning character x Exclude unescaped white space from the pattern, and enable comments after a number sign (#). - + group options - + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - + inline comment - + name - + name1 - + name2 - + A named or numbered backreference. 'name' is the name of a capturing group defined in the regular expression pattern. - + named backreference - + Captures a matched subexpression and lets you access it by name or by number. 'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - + named matched subexpression - + name-or-number - + no - + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - + nonbacktracking subexpression - + This construct does not capture the substring that is matched by a subexpression: The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - + noncapturing group - + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - + numbered backreference - + yes - + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - + zero-width negative lookahead assertion - + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - + zero-width negative lookbehind assertion - + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - + zero-width positive lookahead assertion - + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + zero-width positive lookbehind assertion - + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - + all control characters - + All diacritic marks. This includes the Mn, Mc, and Me categories. - + all diacritic marks - + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - + all letter characters - + All numbers. This includes the Nd, Nl, and No categories. - + all numbers - + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - + all punctuation characters - + All separator characters. This includes the Zs, Zl, and Zp categories. - + all separator characters - + All symbols. This includes the Sm, Sc, Sk, and So categories. - + all symbols - + base-group - + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. 'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - + character class subtraction - + character-group - + excluded-group - + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - + match at least 'n' times (lazy) - + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - + match at least 'n' times - + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - + match at least 'n' times (lazy) - + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - + match between 'm' and 'n' times - + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - + match exactly 'n' times (lazy) - + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - + match exactly 'n' times - + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - + match one or more times (lazy) - + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - + match one or more times - + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - + match zero or more times (lazy) - + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - + match zero or more times - + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - + match zero or one time (lazy) - + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - + match zero or one time - + Unicode General Category: {0} - + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: i Use case-insensitive matching. @@ -1394,7 +1394,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of x Exclude unescaped white space from the pattern, and enable comments after a number sign (#). - + inline options diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.cs.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.cs.xlf index d1518e4b3f4..e7b1799f286 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.cs.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.cs.xlf @@ -72,2094 +72,2094 @@ Pouze refaktoring - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - Symbol {0} nepochází ze zdroje. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - ID komentáře dokumentace musí začínat znakem E, F, M, N, P nebo T. + + all control characters + all control characters - - Cycle detected in extensions - V rozšířeních se zjistil cyklus. + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - Cílový typ musí být {0}, ale zadaný typ je {1}. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - Cílový typ musí být {0} nebo {1}, ale zadaný typ je {2}. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - Cílový typ musí být {0}, {1} nebo {2}, ale zadaný typ je {3}. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - Nenašlo se umístění, do kterého by se vygeneroval symbol. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Není zadané žádné umístění, kam by se daly přidávat příkazy. + + all numbers + all numbers - - Destination location was not in source. - Cílové umístění není ve zdroji. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - Cílové umístění pochází z jiného stromu. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Uzel je chybného typu. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - Umístění musí být null nebo ze zdroje. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - Duplicitní zdrojový soubor {0} v projektu {1} + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - Odebírání projektů se nepodporuje. + + all symbols + all symbols - - Adding projects is not supported. - Přidávání projektů se nepodporuje. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - Pracovní prostor není platný. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '{0} není součástí pracovního prostoru. + + balancing group + balancing group - - '{0}' is already part of the workspace. - '{0} je už součástí pracovního prostoru. + + base-group + base-group - - '{0}' is not referenced. - 'Na {0} se neodkazuje. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - 'Na {0} se už odkazuje. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - Přidání odkazu na projekt z {0} na {1} způsobí cyklický odkaz. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - Na metadata se neodkazuje. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Na metadata se už odkazuje. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} není k dispozici. + + character class subtraction + character class subtraction - - {0} is already present. - {0} je už k dispozici. + + character-group + character-group - - The specified document is not a version of this document. - Zadaný dokument nepředstavuje verzi tohoto dokumentu. + + comment + comment - - The language '{0}' is not supported. - Jazyk {0} se nepodporuje. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - Řešení už obsahuje zadaný projekt. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - Řešení neobsahuje zadaný projekt. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - Projekt už odkazuje na cílový projekt. + + conditional group match + conditional group match - - The project already transitively references the target project. - Projekt už tranzitivně odkazuje na cílový projekt. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - Řešení už obsahuje zadaný dokument. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - Řešení neobsahuje zadaný dokument. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - Do dočasného úložiště se nedá zapisovat víc než jednou. + + control character + control character - - '{0}' is not open. - '{0} není otevřený. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Pro tuto možnost se nesmí zadat název jazyka. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Pro tuto možnost se musí zadat název jazyka. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Došlo k externí úpravě souboru: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Nerozpoznaný název jazyka + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Nejde vyřešit odkaz na metadata: {0}. + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Nejde vyřešit odkaz na analyzátor: {0}. + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Neplatný blok projektu; za projektem se očekával znak „=“. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Neplatný blok projektu; za názvem projektu se očekával znak „,“. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Neplatný blok projektu; za cestou k projektu se očekával znak „,“. + + end of string or line + end of string or line - - Expected {0}. - Očekávalo se {0}. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - {0} musí být neprázdný řetězec, který nemá hodnotu null. + + escape character + escape character - - Expected header: "{0}". - Očekávaná hlavička: {0} + + excluded-group + excluded-group - - Expected end-of-file. - Očekával se konec souboru. + + expression + expression - - Expected {0} line. - Očekával se řádek {0}. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Toto odeslání už odkazuje na jiný projekt odeslání. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} pořád obsahuje otevřené dokumenty. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} je pořád otevřený. + + group options + group options - - An element with the same key but a different value already exists. - Element se stejným klíčem, ale odlišnou hodnotou už existuje. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Pole s víc než jedním rozměrem nejsou serializované. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Hodnota je moc velká, než aby se dala vyjádřit jako 30bitové nepodepsané celé číslo. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Zadaná cesta musí být absolutní. + + inline comment + inline comment - - Cast is redundant. - Přetypování je redundantní. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Název se dá zjednodušit. + + inline options + inline options - - Unknown identifier. - Neznámý identifikátor + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Nejde generovat kód pro nepodporovaný operátor {0}. + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Neplatný počet parametrů pro binární operátor + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Neplatný počet parametrů pro unární operátor + + letter, titlecase + letter, titlecase - - Absolute path expected. - Očekávala se absolutní cesta. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Nejde otevřít projekt {0}, protože přípona souboru {1} není přidružená k jazyku. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - Nejde otevřít projekt {0}, protože jazyk {1} se nepodporuje. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Neplatná cesta k souboru projektu: {0} + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Neplatná cesta k souboru řešení: {0} + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Nenalezený soubor projektu: {0} + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Nenalezený soubor řešení: {0} + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Nesloučené změny z projektu '{0}' + + match at least 'n' times + match at least 'n' times - - Added: - Přidáno: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Opravit vše ({0}) + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Opravit vše ({0}) v: {1} + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Opravit vše ({0}) v řešení + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Po: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Před: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Odebráno: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Neplatná hodnota CodePage: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - Přidávání dalších dokumentů se nepodporuje. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - Přidávání odkazů na analyzátory se nepodporuje. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - Přidávání dokumentů se nepodporuje. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - Přidávání odkazů na metadata se nepodporuje. + + match one or more times + match one or more times - - Adding project references is not supported. - Přidávání odkazů na projekty se nepodporuje. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - Změna dalších dokumentů se nepodporuje. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - Změna dokumentů se nepodporuje. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - Změna vlastností projektu se nepodporuje. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - Odebírání dalších dokumentů se nepodporuje. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - Odebírání odkazů na analyzátory se nepodporuje. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - Odebírání dokumentů se nepodporuje. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - Odebírání odkazů na metadata se nepodporuje. + + match zero or one time + match zero or one time - - Removing project references is not supported. - Odebírání odkazů na projekty se nepodporuje. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - Ke splnění úkolu se vyžaduje služba typu {0}, není ale z pracovního prostoru dostupná. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - Zadaná diagnostika nemůže být null. + + name + name - - At least one diagnostic must be supplied. - Musí se zadat aspoň jedna diagnostika. + + name1 + name1 - - Diagnostic must have span '{0}' - Diagnostika musí mít rozpětí {0}. + + name2 + name2 - - Cannot deserialize type '{0}'. - Typ {0} nejde deserializovat. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - Typ {0} nejde serializovat. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - Vazač serializace nerozumí typu {0}. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - Popisek uzlu {0} je neplatný. Musí být uzavřený v syntaxi [0, {1}). + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Odpovídající uzly {0} a {1} musí mít stejný popisek. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Uzel {0} se musí umístit do nového stromu. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Uzel {0} se musí umístit do starého stromu. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - Člen {0} se nedeklaruje při deklaraci symbolu. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - Pozice není v deklaraci symbolu. + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - Symbol {0} se nemůže nacházet v aktuálním řešení. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - Změna možností kompilace se nepodporuje. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - Změna možností analýzy se nepodporuje. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - Uzel není součástí stromu. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Tento pracovní prostor nepodporuje otevírání a zavírání dokumentů. + + no + no - - Usage: - Použití: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Výjimky: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0} vrací neinicializované ImmutableArray. + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Selhání + + non-white-space character + non-white-space character - - Warning - Varování + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Naplnit přepínač + + non-word boundary + non-word boundary - - Member access should be qualified. - Přístup členů by měl být kvalifikovaný. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Přidat složené závorky do příkazu {0}. + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Možnosti nepocházely z pracovního prostoru. + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Povolit + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Povolit a ignorovat budoucí chyby + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - 'U analyzátoru {0} došlo k chybě a byl zakázán. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Zobrazit trasování zásobníku + + number, letter + number, letter - - Stream is too long. - Stream je moc dlouhý. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - Čtečka deserializace pro {0} přečetla nesprávný počet hodnot. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - PascalCase + + numbered backreference + numbered backreference - - Abstract Method - Abstraktní metoda - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Asynchronní metoda - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Začíná na I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Třída - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Delegát - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Výčet - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Událost - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Rozhraní - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Členové bez pole - {locked:field} + + positive character range + positive character range + - - Private Method - Privátní metoda - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Privátní nebo interní pole - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Privátní nebo interní statické pole - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Vlastnost - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Veřejné nebo chráněné pole - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Statické pole - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Statická metoda - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Struktura - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Typy - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Metoda - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Chybějící předpona: {0} + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Chyba + + start of string only + start of string only - - None - Žádná + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Chybějící přípona: {0} + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Tato neúvodní slova musí začínat velkým písmenem: {0}. + + subexpression + subexpression - - Suggestion - Návrh + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Tato neúvodní slova musí začínat malým písmenem: {0}. + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Tato slova nemohou obsahovat malá písmena: {0}. + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Tato slova nemohou obsahovat velká písmena: {0}. + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Tato slova musí začínat velkými písmeny: {0}. + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - První slovo ({0}) musí začínat velkým písmenem. + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - První slovo ({0}) musí začínat malým písmenem. + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - Soubor {0} s velikostí {1} překračuje maximální povolenou velikost: {2}. + + unicode category + unicode category - - Changing document properties is not supported - Změna vlastností dokumentu není podporovaná. + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + Symbol {0} nepochází ze zdroje. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + ID komentáře dokumentace musí začínat znakem E, F, M, N, P nebo T. - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + V rozšířeních se zjistil cyklus. - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + Cílový typ musí být {0}, ale zadaný typ je {1}. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + Cílový typ musí být {0} nebo {1}, ale zadaný typ je {2}. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + Cílový typ musí být {0}, {1} nebo {2}, ale zadaný typ je {3}. - - base-group - base-group + + Could not find location to generation symbol into. + Nenašlo se umístění, do kterého by se vygeneroval symbol. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Není zadané žádné umístění, kam by se daly přidávat příkazy. - - bell character - bell character + + Destination location was not in source. + Cílové umístění není ve zdroji. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + Cílové umístění pochází z jiného stromu. - - carriage-return character - carriage-return character + + Node is of the wrong type. + Uzel je chybného typu. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + Umístění musí být null nebo ze zdroje. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + Duplicitní zdrojový soubor {0} v projektu {1} - - character-group - character-group + + Removing projects is not supported. + Odebírání projektů se nepodporuje. - - comment - comment + + Adding projects is not supported. + Přidávání projektů se nepodporuje. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + Pracovní prostor není platný. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '{0} není součástí pracovního prostoru. - - control character - control character + + '{0}' is already part of the workspace. + '{0} je už součástí pracovního prostoru. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + 'Na {0} se neodkazuje. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + 'Na {0} se už odkazuje. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + Přidání odkazu na projekt z {0} na {1} způsobí cyklický odkaz. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + Na metadata se neodkazuje. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Na metadata se už odkazuje. - - end of string only - end of string only + + {0} is not present. + {0} není k dispozici. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} je už k dispozici. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + Zadaný dokument nepředstavuje verzi tohoto dokumentu. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + Jazyk {0} se nepodporuje. - - end of string or line - end of string or line + + The solution already contains the specified project. + Řešení už obsahuje zadaný projekt. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + Řešení neobsahuje zadaný projekt. - - escape character - escape character + + The project already references the target project. + Projekt už odkazuje na cílový projekt. - - excluded-group - excluded-group + + The project already transitively references the target project. + Projekt už tranzitivně odkazuje na cílový projekt. - - expression - expression + + The solution already contains the specified document. + Řešení už obsahuje zadaný dokument. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + Řešení neobsahuje zadaný dokument. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + Do dočasného úložiště se nedá zapisovat víc než jednou. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '{0} není otevřený. - - group options - group options + + A language name cannot be specified for this option. + Pro tuto možnost se nesmí zadat název jazyka. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Pro tuto možnost se musí zadat název jazyka. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Došlo k externí úpravě souboru: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Nerozpoznaný název jazyka - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Nejde vyřešit odkaz na metadata: {0}. - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Nejde vyřešit odkaz na analyzátor: {0}. - - inline options - inline options + + Invalid project block, expected "=" after Project. + Neplatný blok projektu; za projektem se očekával znak „=“. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Neplatný blok projektu; za názvem projektu se očekával znak „,“. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Neplatný blok projektu; za cestou k projektu se očekával znak „,“. - - letter, other - letter, other + + Expected {0}. + Očekávalo se {0}. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + {0} musí být neprázdný řetězec, který nemá hodnotu null. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + Očekávaná hlavička: {0} - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Očekával se konec souboru. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + Očekával se řádek {0}. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Toto odeslání už odkazuje na jiný projekt odeslání. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} pořád obsahuje otevřené dokumenty. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} je pořád otevřený. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Element se stejným klíčem, ale odlišnou hodnotou už existuje. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Pole s víc než jedním rozměrem nejsou serializované. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Hodnota je moc velká, než aby se dala vyjádřit jako 30bitové nepodepsané celé číslo. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Zadaná cesta musí být absolutní. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Přetypování je redundantní. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Název se dá zjednodušit. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Neznámý identifikátor - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Nejde generovat kód pro nepodporovaný operátor {0}. - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Neplatný počet parametrů pro binární operátor - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Neplatný počet parametrů pro unární operátor - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Očekávala se absolutní cesta. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Nejde otevřít projekt {0}, protože přípona souboru {1} není přidružená k jazyku. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + Nejde otevřít projekt {0}, protože jazyk {1} se nepodporuje. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Neplatná cesta k souboru projektu: {0} - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Neplatná cesta k souboru řešení: {0} - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Nenalezený soubor projektu: {0} - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Nenalezený soubor řešení: {0} - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Nesloučené změny z projektu '{0}' - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Přidáno: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Opravit vše ({0}) - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Opravit vše ({0}) v: {1} - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Opravit vše ({0}) v řešení - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Po: - - matched subexpression - matched subexpression + + Before: + Před: - - name - name + + Removed: + Odebráno: - - name1 - name1 + + Invalid CodePage value: {0} + Neplatná hodnota CodePage: {0} - - name2 - name2 + + Adding additional documents is not supported. + Přidávání dalších dokumentů se nepodporuje. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + Přidávání odkazů na analyzátory se nepodporuje. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + Přidávání dokumentů se nepodporuje. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + Přidávání odkazů na metadata se nepodporuje. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + Přidávání odkazů na projekty se nepodporuje. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + Změna dalších dokumentů se nepodporuje. - - negative character group - negative character group + + Changing documents is not supported. + Změna dokumentů se nepodporuje. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + Změna vlastností projektu se nepodporuje. - - negative character range - negative character range + + Removing additional documents is not supported. + Odebírání dalších dokumentů se nepodporuje. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + Odebírání odkazů na analyzátory se nepodporuje. - - negative unicode category - negative unicode category + + Removing documents is not supported. + Odebírání dokumentů se nepodporuje. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + Odebírání odkazů na metadata se nepodporuje. - - new-line character - new-line character + + Removing project references is not supported. + Odebírání odkazů na projekty se nepodporuje. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + Ke splnění úkolu se vyžaduje služba typu {0}, není ale z pracovního prostoru dostupná. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + Zadaná diagnostika nemůže být null. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + Musí se zadat aspoň jedna diagnostika. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + Diagnostika musí mít rozpětí {0}. - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + Typ {0} nejde deserializovat. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + Typ {0} nejde serializovat. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + Vazač serializace nerozumí typu {0}. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + Popisek uzlu {0} je neplatný. Musí být uzavřený v syntaxi [0, {1}). + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Odpovídající uzly {0} a {1} musí mít stejný popisek. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Uzel {0} se musí umístit do nového stromu. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Uzel {0} se musí umístit do starého stromu. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + Člen {0} se nedeklaruje při deklaraci symbolu. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + Pozice není v deklaraci symbolu. - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + Symbol {0} se nemůže nacházet v aktuálním řešení. - - number, letter - number, letter + + Changing compilation options is not supported. + Změna možností kompilace se nepodporuje. - - number, other - number, other + + Changing parse options is not supported. + Změna možností analýzy se nepodporuje. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + Uzel není součástí stromu. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Tento pracovní prostor nepodporuje otevírání a zavírání dokumentů. - - other, control - other, control + + Usage: + Použití: - - other, format - other, format + + Exceptions: + Výjimky: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0} vrací neinicializované ImmutableArray. - - other, private use - other, private use + + Failure + Selhání - - other, surrogate - other, surrogate + + Warning + Varování - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Naplnit přepínač - - positive character group - positive character group + + Member access should be qualified. + Přístup členů by měl být kvalifikovaný. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Přidat složené závorky do příkazu {0}. - - positive character range - positive character range + + Options did not come from Workspace + Možnosti nepocházely z pracovního prostoru. - - punctuation, close - punctuation, close + + Enable + Povolit - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Povolit a ignorovat budoucí chyby - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + 'U analyzátoru {0} došlo k chybě a byl zakázán. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Zobrazit trasování zásobníku - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Stream je moc dlouhý. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + Čtečka deserializace pro {0} přečetla nesprávný počet hodnot. - - punctuation, other - punctuation, other + + Pascal Case + PascalCase - - separator, line - separator, line - + + Abstract Method + Abstraktní metoda + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Asynchronní metoda + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Začíná na I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Třída + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Delegát + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Výčet + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Událost + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Rozhraní + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Členové bez pole + {locked:field} - - symbol, math - symbol, math - + + Private Method + Privátní metoda + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Privátní nebo interní pole + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Privátní nebo interní statické pole + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Vlastnost + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Veřejné nebo chráněné pole + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Statické pole + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Statická metoda + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Struktura + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Typy + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Metoda + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Chybějící předpona: {0} - - vertical-tab character - vertical-tab character + + Error + Chyba - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Žádná - - white-space character - white-space character + + Missing suffix: '{0}' + Chybějící přípona: {0} - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Tato neúvodní slova musí začínat velkým písmenem: {0}. - - word boundary - word boundary + + Suggestion + Návrh - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Tato neúvodní slova musí začínat malým písmenem: {0}. - - word character - word character + + These words cannot contain lower case characters: {0} + Tato slova nemohou obsahovat malá písmena: {0}. - - yes - yes + + These words cannot contain upper case characters: {0} + Tato slova nemohou obsahovat velká písmena: {0}. - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Tato slova musí začínat velkými písmeny: {0}. - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + První slovo ({0}) musí začínat velkým písmenem. - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + První slovo ({0}) musí začínat malým písmenem. - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + Soubor {0} s velikostí {1} překračuje maximální povolenou velikost: {2}. - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + Změna vlastností dokumentu není podporovaná. - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.de.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.de.xlf index 57b801b0701..1cc93f5336d 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.de.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.de.xlf @@ -72,2094 +72,2094 @@ Nur Refactoring - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - Symbol "{0}" ist nicht aus Quelle. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - Dokumentationskommentar-ID muss mit E, F, M, N, P oder T beginnen + + all control characters + all control characters - - Cycle detected in extensions - Zyklus in Erweiterungen entdeckt + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - Zieltyp muss {0} sein. Es wurde jedoch {1} angegeben. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - Zieltyp muss {0} oder {1} sein. Es wurde jedoch {2} angegeben. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - Zieltyp muss {0}, {1} oder {2} sein. Es wurde jedoch {3} angegeben. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - Konnte keinen Ort finden, in den das Symbol generiert werden kann. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Kein Ort angegeben, zu dem Anweisungen hinzugefügt werden. + + all numbers + all numbers - - Destination location was not in source. - Zielort war nicht in Quelle. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - Zielort stammt aus anderem Baum. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Knoten hat den falschen Typ. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - Ort muss NULL oder von Quelle sein. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - Doppelte Quelldatei "{0}" in Projekt "{1}" + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - Das Entfernen von Projekten wird nicht unterstützt. + + all symbols + all symbols - - Adding projects is not supported. - Das Hinzufügen von Projekten wird nicht unterstützt. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - Arbeitsbereich ist nicht leer. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - "{0}" ist nicht Teil des Arbeitsbereichs. + + balancing group + balancing group - - '{0}' is already part of the workspace. - "{0}" ist bereits Teil des Workspace. + + base-group + base-group - - '{0}' is not referenced. - "{0}" ist nicht referenziert. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - "{0}" ist bereits referenziert. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - Das Hinzufügen der Projektreferenz "{0}" zu "{1}" wird einen Zirkelbezug verursachen. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - Metadaten sind nicht referenziert. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Metadaten sind bereits referenziert. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} ist nicht vorhanden. + + character class subtraction + character class subtraction - - {0} is already present. - {0} ist bereits vorhanden. + + character-group + character-group - - The specified document is not a version of this document. - Das angegebene Dokument ist keine Version dieses Dokuments. + + comment + comment - - The language '{0}' is not supported. - Die Sprache "{0}" wird nicht unterstützt. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - Die Lösung enthält bereits das angegebene Projekt. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - Lösung enthält nicht das angegebene Projekt. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - Das Projekt verweist bereits auf das Zielprojekt. + + conditional group match + conditional group match - - The project already transitively references the target project. - Das Projekt verweist bereits transitiv auf das Zielprojekt. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - Die Lösung enthält bereits das angegebene Dokument. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - Die Lösung enthält nicht das angegebene Dokument. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - Temporärer Speicher kann nicht mehr als einmal geschrieben werden. + + control character + control character - - '{0}' is not open. - "{0}" ist nicht geöffnet. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Für diese Option kann kein Sprachenname angegeben werden. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Für diese Option muss ein Sprachenname angegeben werden. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Datei wurde extern modifiziert: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Unerkannter Sprachenname. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Metadatenreferenz kann nicht aufgelöst werden: "{0}". + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Analysereferenz kann nicht aufgelöst werden: "{0}". + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Ungültiger Projektblock, erwartet wird "=" nach Projekt. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Ungültiger Projektblock, erwartet wird "," nach Projektname. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Ungültiger Projektblock, erwartet wird "," nach Projektpfad. + + end of string or line + end of string or line - - Expected {0}. - Erwartet wird {0}. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" muss eine Zeichenfolge sein, die nicht NULL und nicht leer ist. + + escape character + escape character - - Expected header: "{0}". - Erwartete Überschrift: "{0}". + + excluded-group + excluded-group - - Expected end-of-file. - Erwartetes Dateiende. + + expression + expression - - Expected {0} line. - Erwartete {0}-Zeile. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Diese Übermittlung verweist bereits auf ein anderes Übermittlungsprojekt. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} enthält noch offene Dokumente. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - "{0}" ist noch geöffnet. + + group options + group options - - An element with the same key but a different value already exists. - Es ist bereits ein Element mit dem gleichen Schlüssel, jedoch einem anderen Wert vorhanden. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Arrays mit mehr als einer Dimension können nicht serialisiert werden. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Der Wert ist zu groß, um als ganze 30-Bit-Zahl ohne Vorzeichen dargestellt zu werden. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Angegebener Pfad muss absolut sein. + + inline comment + inline comment - - Cast is redundant. - Umwandlung ist redundant. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Name kann vereinfacht werden. + + inline options + inline options - - Unknown identifier. - Unbekannter Bezeichner. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Kann keinen Code für nicht unterstützten Operator "{0}" generieren + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Ungültige Parameteranzahl für binären Operator. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Ungültige Parameteranzahl für unären Operator. + + letter, titlecase + letter, titlecase - - Absolute path expected. - Absoluter Pfad erwartet. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Projekt "{0}" kann nicht geöffnet werden, da die Dateierweiterung "{1}" keiner Sprache zugeordnet ist. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - Projekt "{0}" kann nicht geöffnet werden, da die Sprache "{1}" nicht unterstützt wird. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Ungültiger Projektdateipfad: "{0}" + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Ungültiger Lösungsdateipfad: "{0}" + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Projektdatei nicht gefunden: "{0}" + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Lösungsdatei nicht gefunden: "{0}" + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Nicht gemergte Änderung aus Projekt "{0}" + + match at least 'n' times + match at least 'n' times - - Added: - Hinzugefügt: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Alle "{0}" reparieren + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Alle "{0}" in "{1}" reparieren + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Alle "{0}" in Lösung reparieren + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Nach: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Vor: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Entfernt: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Ungültiger CodePage-Wert: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - Das Hinzufügen weitere Dokumente wird nicht unterstützt. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - Das Hinzufügen von Verweisen der Analyse wird nicht unterstützt. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - Das Hinzufügen von Dokumenten wird nicht unterstützt. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - Das Hinzufügen von Verweisen auf Metadaten wird nicht unterstützt. + + match one or more times + match one or more times - - Adding project references is not supported. - Das Hinzufügen von Projektverweisen wird nicht unterstützt. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - Das Ändern weiterer Dokumente wird nicht unterstützt. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - Das Ändern von Dokumenten wird nicht unterstützt. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - Das Ändern von Projekteigenschaften wird nicht unterstützt. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - Das Entfernen weiterer Dokumente wird nicht unterstützt. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - Das Entfernen von Verweisen der Analyse wird nicht unterstützt. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - Das Entfernen von Dokumenten wird nicht unterstützt. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - Das Entfernen von Verweisen auf Metadaten wird nicht unterstützt. + + match zero or one time + match zero or one time - - Removing project references is not supported. - Das Entfernen von Projektverweisen wird nicht unterstützt. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - Ein Dienst vom Typ "{0}" ist zum Ausführen der Aufgabe erforderlich, steht aber im Arbeitsbereich nicht zur Verfügung. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - Bereitgestellte Diagnose darf nicht NULL sein. + + name + name - - At least one diagnostic must be supplied. - Es muss mindestens eine Diagnose bereitgestellt sein. + + name1 + name1 - - Diagnostic must have span '{0}' - Diagnose muss den Bereich "{0}" enthalten + + name2 + name2 - - Cannot deserialize type '{0}'. - Typ "{0}" kann nicht deserialisiert werden. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - Typ "{0}" kann nicht serialisiert werden. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - Der Typ "{0}" wird vom Serialisierungsbinder nicht verstanden. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - Die Bezeichnung für Knoten "{0}" ist ungültig, sie muss innerhalb von [0, {1}) liegen. + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Die übereinstimmenden Knoten "{0}" und "{1}" müssen dieselbe Bezeichnung aufweisen. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Der Knoten "{0}" muss im neuen Baum enthalten sein. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Der Knoten "{0}" muss im alten Baum enthalten sein. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - Der Member "{0}" wird nicht innerhalb der Deklaration des Symbols deklariert. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - Die Position liegt nicht innerhalb der Deklaration des Symbols. + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - Das Symbol "{0}" kann nicht in die aktuelle Projektmappe geladen werden. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - Das Ändern von Kompilierungsoptionen wird nicht unterstützt. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - Das Ändern von Analyseoptionen wird nicht unterstützt. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - Dieser Knoten ist nicht Teil des Baums. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Das Öffnen und Schließen von Dokumenten wird in diesem Arbeitsbereich nicht unterstützt. + + no + no - - Usage: - Syntax: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Ausnahmen: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - "{0}" hat ein nicht initialisiertes "ImmutableArray" zurückgegeben. + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Fehler + + non-white-space character + non-white-space character - - Warning - Warnung + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Switch mit Daten auffüllen + + non-word boundary + non-word boundary - - Member access should be qualified. - Der Memberzugriff sollte qualifiziert sein. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Der Anweisung "{0}" geschweifte Klammern hinzufügen + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Optionen stammen nicht aus dem Arbeitsbereich. + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Aktivieren + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Aktivieren und weitere Fehler ignorieren + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - "{0}" hat einen Fehler festgestellt und wurde deaktiviert. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Stapelüberwachung anzeigen + + number, letter + number, letter - - Stream is too long. - Der Stream ist zu lang. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - Der Deserialisierungsreader für "{0}" hat eine falsche Anzahl von Werten gelesen. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - Pascal-Schreibweise + + numbered backreference + numbered backreference - - Abstract Method - Abstrakte Methode - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Asynchrone Methode - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Beginnt mit I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Klasse - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Delegat - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Enumeration - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Ereignis - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Schnittstelle - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Nicht-Feldmember - {locked:field} + + positive character range + positive character range + - - Private Method - Private Methode - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Privates oder internes Feld - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Privates oder internes statisches Feld - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Eigenschaft - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Öffentliches oder geschütztes Feld - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Statisches Feld - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Statische Methode - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Struktur - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Typen - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Methode - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Fehlendes Präfix: "{0}" + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Fehler + + start of string only + start of string only - - None - Keine + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Fehlendes Suffix: "{0}" + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Diese nicht führenden Wörter müssen mit einem Großbuchstaben beginnen: {0} + + subexpression + subexpression - - Suggestion - Vorschlag + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Diese nicht führenden Wörter müssen mit einem Kleinbuchstaben beginnen: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Diese Wörter dürfen keine Kleinbuchstaben enthalten: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Diese Wörter dürfen keine Großbuchstaben enthalten: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Diese Wörter müssen mit Großbuchstaben beginnen: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - Das erste Wort ("{0}") muss mit einem Großbuchstaben beginnen. + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - Das erste Wort ("{0}") muss mit einem Kleinbuchstaben beginnen. + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - Die Größe der Datei "{0}" beträgt {1} und überschreitet so die maximal zulässige Größe von {2}. + + unicode category + unicode category - - Changing document properties is not supported - Das Ändern der Dokumenteigenschaften wird nicht unterstützt. + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + Symbol "{0}" ist nicht aus Quelle. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + Dokumentationskommentar-ID muss mit E, F, M, N, P oder T beginnen - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + Zyklus in Erweiterungen entdeckt - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + Zieltyp muss {0} sein. Es wurde jedoch {1} angegeben. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + Zieltyp muss {0} oder {1} sein. Es wurde jedoch {2} angegeben. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + Zieltyp muss {0}, {1} oder {2} sein. Es wurde jedoch {3} angegeben. - - base-group - base-group + + Could not find location to generation symbol into. + Konnte keinen Ort finden, in den das Symbol generiert werden kann. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Kein Ort angegeben, zu dem Anweisungen hinzugefügt werden. - - bell character - bell character + + Destination location was not in source. + Zielort war nicht in Quelle. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + Zielort stammt aus anderem Baum. - - carriage-return character - carriage-return character + + Node is of the wrong type. + Knoten hat den falschen Typ. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + Ort muss NULL oder von Quelle sein. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + Doppelte Quelldatei "{0}" in Projekt "{1}" - - character-group - character-group + + Removing projects is not supported. + Das Entfernen von Projekten wird nicht unterstützt. - - comment - comment + + Adding projects is not supported. + Das Hinzufügen von Projekten wird nicht unterstützt. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + Arbeitsbereich ist nicht leer. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + "{0}" ist nicht Teil des Arbeitsbereichs. - - control character - control character + + '{0}' is already part of the workspace. + "{0}" ist bereits Teil des Workspace. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + "{0}" ist nicht referenziert. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + "{0}" ist bereits referenziert. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + Das Hinzufügen der Projektreferenz "{0}" zu "{1}" wird einen Zirkelbezug verursachen. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + Metadaten sind nicht referenziert. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Metadaten sind bereits referenziert. - - end of string only - end of string only + + {0} is not present. + {0} ist nicht vorhanden. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} ist bereits vorhanden. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + Das angegebene Dokument ist keine Version dieses Dokuments. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + Die Sprache "{0}" wird nicht unterstützt. - - end of string or line - end of string or line + + The solution already contains the specified project. + Die Lösung enthält bereits das angegebene Projekt. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + Lösung enthält nicht das angegebene Projekt. - - escape character - escape character + + The project already references the target project. + Das Projekt verweist bereits auf das Zielprojekt. - - excluded-group - excluded-group + + The project already transitively references the target project. + Das Projekt verweist bereits transitiv auf das Zielprojekt. - - expression - expression + + The solution already contains the specified document. + Die Lösung enthält bereits das angegebene Dokument. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + Die Lösung enthält nicht das angegebene Dokument. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + Temporärer Speicher kann nicht mehr als einmal geschrieben werden. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + "{0}" ist nicht geöffnet. - - group options - group options + + A language name cannot be specified for this option. + Für diese Option kann kein Sprachenname angegeben werden. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Für diese Option muss ein Sprachenname angegeben werden. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Datei wurde extern modifiziert: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Unerkannter Sprachenname. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Metadatenreferenz kann nicht aufgelöst werden: "{0}". - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Analysereferenz kann nicht aufgelöst werden: "{0}". - - inline options - inline options + + Invalid project block, expected "=" after Project. + Ungültiger Projektblock, erwartet wird "=" nach Projekt. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Ungültiger Projektblock, erwartet wird "," nach Projektname. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Ungültiger Projektblock, erwartet wird "," nach Projektpfad. - - letter, other - letter, other + + Expected {0}. + Erwartet wird {0}. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" muss eine Zeichenfolge sein, die nicht NULL und nicht leer ist. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + Erwartete Überschrift: "{0}". - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Erwartetes Dateiende. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + Erwartete {0}-Zeile. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Diese Übermittlung verweist bereits auf ein anderes Übermittlungsprojekt. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} enthält noch offene Dokumente. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + "{0}" ist noch geöffnet. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Es ist bereits ein Element mit dem gleichen Schlüssel, jedoch einem anderen Wert vorhanden. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Arrays mit mehr als einer Dimension können nicht serialisiert werden. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Der Wert ist zu groß, um als ganze 30-Bit-Zahl ohne Vorzeichen dargestellt zu werden. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Angegebener Pfad muss absolut sein. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Umwandlung ist redundant. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Name kann vereinfacht werden. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Unbekannter Bezeichner. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Kann keinen Code für nicht unterstützten Operator "{0}" generieren - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Ungültige Parameteranzahl für binären Operator. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Ungültige Parameteranzahl für unären Operator. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Absoluter Pfad erwartet. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Projekt "{0}" kann nicht geöffnet werden, da die Dateierweiterung "{1}" keiner Sprache zugeordnet ist. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + Projekt "{0}" kann nicht geöffnet werden, da die Sprache "{1}" nicht unterstützt wird. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Ungültiger Projektdateipfad: "{0}" - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Ungültiger Lösungsdateipfad: "{0}" - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Projektdatei nicht gefunden: "{0}" - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Lösungsdatei nicht gefunden: "{0}" - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Nicht gemergte Änderung aus Projekt "{0}" - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Hinzugefügt: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Alle "{0}" reparieren - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Alle "{0}" in "{1}" reparieren - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Alle "{0}" in Lösung reparieren - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Nach: - - matched subexpression - matched subexpression + + Before: + Vor: - - name - name + + Removed: + Entfernt: - - name1 - name1 + + Invalid CodePage value: {0} + Ungültiger CodePage-Wert: {0} - - name2 - name2 + + Adding additional documents is not supported. + Das Hinzufügen weitere Dokumente wird nicht unterstützt. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + Das Hinzufügen von Verweisen der Analyse wird nicht unterstützt. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + Das Hinzufügen von Dokumenten wird nicht unterstützt. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + Das Hinzufügen von Verweisen auf Metadaten wird nicht unterstützt. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + Das Hinzufügen von Projektverweisen wird nicht unterstützt. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + Das Ändern weiterer Dokumente wird nicht unterstützt. - - negative character group - negative character group + + Changing documents is not supported. + Das Ändern von Dokumenten wird nicht unterstützt. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + Das Ändern von Projekteigenschaften wird nicht unterstützt. - - negative character range - negative character range + + Removing additional documents is not supported. + Das Entfernen weiterer Dokumente wird nicht unterstützt. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + Das Entfernen von Verweisen der Analyse wird nicht unterstützt. - - negative unicode category - negative unicode category + + Removing documents is not supported. + Das Entfernen von Dokumenten wird nicht unterstützt. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + Das Entfernen von Verweisen auf Metadaten wird nicht unterstützt. - - new-line character - new-line character + + Removing project references is not supported. + Das Entfernen von Projektverweisen wird nicht unterstützt. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + Ein Dienst vom Typ "{0}" ist zum Ausführen der Aufgabe erforderlich, steht aber im Arbeitsbereich nicht zur Verfügung. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + Bereitgestellte Diagnose darf nicht NULL sein. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + Es muss mindestens eine Diagnose bereitgestellt sein. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + Diagnose muss den Bereich "{0}" enthalten - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + Typ "{0}" kann nicht deserialisiert werden. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + Typ "{0}" kann nicht serialisiert werden. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + Der Typ "{0}" wird vom Serialisierungsbinder nicht verstanden. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + Die Bezeichnung für Knoten "{0}" ist ungültig, sie muss innerhalb von [0, {1}) liegen. + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Die übereinstimmenden Knoten "{0}" und "{1}" müssen dieselbe Bezeichnung aufweisen. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Der Knoten "{0}" muss im neuen Baum enthalten sein. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Der Knoten "{0}" muss im alten Baum enthalten sein. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + Der Member "{0}" wird nicht innerhalb der Deklaration des Symbols deklariert. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + Die Position liegt nicht innerhalb der Deklaration des Symbols. - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + Das Symbol "{0}" kann nicht in die aktuelle Projektmappe geladen werden. - - number, letter - number, letter + + Changing compilation options is not supported. + Das Ändern von Kompilierungsoptionen wird nicht unterstützt. - - number, other - number, other + + Changing parse options is not supported. + Das Ändern von Analyseoptionen wird nicht unterstützt. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + Dieser Knoten ist nicht Teil des Baums. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Das Öffnen und Schließen von Dokumenten wird in diesem Arbeitsbereich nicht unterstützt. - - other, control - other, control + + Usage: + Syntax: - - other, format - other, format + + Exceptions: + Ausnahmen: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + "{0}" hat ein nicht initialisiertes "ImmutableArray" zurückgegeben. - - other, private use - other, private use + + Failure + Fehler - - other, surrogate - other, surrogate + + Warning + Warnung - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Switch mit Daten auffüllen - - positive character group - positive character group + + Member access should be qualified. + Der Memberzugriff sollte qualifiziert sein. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Der Anweisung "{0}" geschweifte Klammern hinzufügen - - positive character range - positive character range + + Options did not come from Workspace + Optionen stammen nicht aus dem Arbeitsbereich. - - punctuation, close - punctuation, close + + Enable + Aktivieren - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Aktivieren und weitere Fehler ignorieren - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + "{0}" hat einen Fehler festgestellt und wurde deaktiviert. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Stapelüberwachung anzeigen - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Der Stream ist zu lang. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + Der Deserialisierungsreader für "{0}" hat eine falsche Anzahl von Werten gelesen. - - punctuation, other - punctuation, other + + Pascal Case + Pascal-Schreibweise - - separator, line - separator, line - + + Abstract Method + Abstrakte Methode + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Asynchrone Methode + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Beginnt mit I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Klasse + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Delegat + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Enumeration + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Ereignis + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Schnittstelle + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Nicht-Feldmember + {locked:field} - - symbol, math - symbol, math - + + Private Method + Private Methode + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Privates oder internes Feld + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Privates oder internes statisches Feld + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Eigenschaft + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Öffentliches oder geschütztes Feld + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Statisches Feld + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Statische Methode + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Struktur + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Typen + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Methode + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Fehlendes Präfix: "{0}" - - vertical-tab character - vertical-tab character + + Error + Fehler - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Keine - - white-space character - white-space character + + Missing suffix: '{0}' + Fehlendes Suffix: "{0}" - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Diese nicht führenden Wörter müssen mit einem Großbuchstaben beginnen: {0} - - word boundary - word boundary + + Suggestion + Vorschlag - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Diese nicht führenden Wörter müssen mit einem Kleinbuchstaben beginnen: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Diese Wörter dürfen keine Kleinbuchstaben enthalten: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Diese Wörter dürfen keine Großbuchstaben enthalten: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Diese Wörter müssen mit Großbuchstaben beginnen: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + Das erste Wort ("{0}") muss mit einem Großbuchstaben beginnen. - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + Das erste Wort ("{0}") muss mit einem Kleinbuchstaben beginnen. - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + Die Größe der Datei "{0}" beträgt {1} und überschreitet so die maximal zulässige Größe von {2}. - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + Das Ändern der Dokumenteigenschaften wird nicht unterstützt. - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.es.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.es.xlf index 06ccf904edc..53c4f282c57 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.es.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.es.xlf @@ -72,2094 +72,2094 @@ Solo refactorización - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - El símbolo "{0}" no procede del código fuente. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - El Id. del comentario de la documentación debe comenzar por E, F, M, N, P o T + + all control characters + all control characters - - Cycle detected in extensions - Detectado ciclo en extensiones + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - El tipo de destino debe ser un {0}, pero el proporcionado es {1}. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - El tipo de destino debe ser un {0} o un {1}, pero el proporcionado es {2}. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - El tipo de destino debe ser un {0}, {1} o {2}, pero el proporcionado es {3}. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - No se pudo encontrar una ubicación en la que generar un símbolo. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - No se ha proporcionado ubicación a la que agregar instrucciones. + + all numbers + all numbers - - Destination location was not in source. - La ubicación de destino no estaba en el código fuente. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - La ubicación de destino era de otro árbol. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - El nodo es del tipo erróneo. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - La ubicación debe ser null o del código fuente. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - Archivo de código fuente "{0}" duplicado en el proyecto "{1}" + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - No se admite la eliminación de proyectos. + + all symbols + all symbols - - Adding projects is not supported. - No se admite la adición de proyectos. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - El área de trabajo no está vacía. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - "{0}" no es parte del área de trabajo. + + balancing group + balancing group - - '{0}' is already part of the workspace. - "{0}" ya es parte del área de trabajo. + + base-group + base-group - - '{0}' is not referenced. - "No hay referencia a "{0}". + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - "Ya hay una referencia a "{0}". + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - La adición de una referencia de proyecto de "{0}" a "{1}" originará una referencia circular. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - No hay referencia a los metadatos. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Ya hay una referencia a los metadatos. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} no está presente. + + character class subtraction + character class subtraction - - {0} is already present. - {0} ya está presente. + + character-group + character-group - - The specified document is not a version of this document. - El documento especificado no es una versión de este documento. + + comment + comment - - The language '{0}' is not supported. - El lenguaje "{0}" no es compatible. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - La solución ya contiene el proyecto especificado. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - La solución no contiene el proyecto especificado. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - El proyecto ya hace referencia al proyecto de destino. + + conditional group match + conditional group match - - The project already transitively references the target project. - El proyecto ya hace referencia de forma transitiva al proyecto de destino. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - La solución ya contiene el documento especificado. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - La solución no contiene el documento especificado. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - No se puede escribir más de una vez en el almacenamiento temporal. + + control character + control character - - '{0}' is not open. - "{0}" no está abierto. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - No se puede especificar un nombre de lenguaje para esta opción. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Se debe especificar un nombre de lenguaje para esta opción. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - El archivo se modificó externamente: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Nombre de lenguaje no reconocido. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - No se puede resolver la referencia de metadatos: "{0}". + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - No se puede resolver la referencia del analizador: "{0}". + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Bloque de proyecto no válido, se esperaba "=" después de Project. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Bloque de proyecto no válido, se esperaba "," después del nombre del proyecto. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Bloque de proyecto no válido, se esperaba "," después de la ruta de acceso del proyecto. + + end of string or line + end of string or line - - Expected {0}. - Se esperaba {0}. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" debe ser una cadena que no sea Null ni esté vacía. + + escape character + escape character - - Expected header: "{0}". - Se esperaba encabezado: "{0}". + + excluded-group + excluded-group - - Expected end-of-file. - Se esperaba fin de archivo. + + expression + expression - - Expected {0} line. - Se esperaba línea {0}. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Este envío ya hace referencia a otro proyecto de envío. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} aún contiene documentos abiertos. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} aún está abierto. + + group options + group options - - An element with the same key but a different value already exists. - Ya existe un elemento con la misma clave pero un valor distinto. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Las matrices con más de una dimensión no se pueden serializar. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Valor demasiado grande para representarse como entero sin signo de 30 bits. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - La ruta de acceso especificada debe ser absoluta. + + inline comment + inline comment - - Cast is redundant. - La conversión es redundante. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Se puede simplificar el nombre. + + inline options + inline options - - Unknown identifier. - Identificador desconocido. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - No se puede generar código para el operador no compatible "{0}" + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Número de parámetros no válido para el operador binario. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Número de parámetros no válido para el operador unario. + + letter, titlecase + letter, titlecase - - Absolute path expected. - Ruta de acceso absoluta esperada. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - No se puede abrir el proyecto "{0}" porque la extensión de archivo "{1}" no está asociada a un lenguaje. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - No se puede abrir el proyecto "{0}" porque el lenguaje "{1}" no es compatible. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Ruta de acceso del archivo de proyecto no válida: "{0}" + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Ruta de acceso del archivo de solución no válida: "{0}" + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Archivo de proyecto no encontrado: "{0}" + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Archivo de solución no encontrado: "{0}" + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Cambio no fusionado mediante combinación del proyecto "{0}" + + match at least 'n' times + match at least 'n' times - - Added: - Agregado: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Corregir todo "{0}" + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Corregir todo "{0}" en "{1}" + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Corregir todo "{0}" en solución + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Después: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Antes: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Quitado: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Valor de página de códigos no válido: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - No se permite agregar documentos adicionales. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - No se permite agregar referencias de analizador. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - No se permite agregar documentos. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - No se permite agregar referencias de metadatos. + + match one or more times + match one or more times - - Adding project references is not supported. - No se permite agregar referencias de proyectos. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - No se permite cambiar documentos adicionales. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - No se permite cambiar documentos. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - No se permite cambiar propiedades de proyectos. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - No se permite quitar documentos adicionales. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - No se permite quitar referencias de analizador. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - No se permite quitar documentos. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - No se permite quitar referencias de metadatos. + + match zero or one time + match zero or one time - - Removing project references is not supported. - No se permite quitar referencias de proyectos. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - El servicio de tipo "{0}" es necesario para realizar la tarea, pero no está disponibles desde el área de trabajo. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - El diagnóstico suministrado no puede ser nulo. + + name + name - - At least one diagnostic must be supplied. - Se debe suministrar al menos un diagnóstico. + + name1 + name1 - - Diagnostic must have span '{0}' - El diagnóstico debe tener el intervalo "{0}" + + name2 + name2 - - Cannot deserialize type '{0}'. - No se puede deserializar el tipo "{0}". + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - No se puede serializar el tipo "{0}". + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - El enlazador de serialización no comprende el tipo "{0}". + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - La etiqueta para el nodo "{0}" no es válida; debe estar entre [0, {1}). + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Los nodos coincidentes "{0}" y "{1}" deben tener la misma etiqueta. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - El nodo "{0}" se debe incluir en el nuevo árbol. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - El nodo "{0}" se debe incluir en el árbol antiguo. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - No se ha declarado el miembro "{0}" dentro de la declaración del símbolo. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - La posición no se encuentra dentro de la declaración del símbolo + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - El símbolo "{0}" no puede estar dentro de la solución actual. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - No se admite el cambio de las opciones de compilación. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - No se admite el cambio de las opciones de análisis. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - El nodo no forma parte del árbol. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Esta área de trabajo no admite la apertura y el cierre de documentos. + + no + no - - Usage: - Uso: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Excepciones: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - "{0}" devolvió una ImmutableArray sin inicializar + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Error + + non-white-space character + non-white-space character - - Warning - Advertencia + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Rellenar switch + + non-word boundary + non-word boundary - - Member access should be qualified. - Debe calificarse el acceso a miembros. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Agregar llaves a la instrucción "{0}". + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Las opciones no procedían del área de trabajo + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Habilitar + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Habilitar y omitir futuros errores + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - "{0}" detectó un error y se ha deshabilitado. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Mostrar seguimiento de la pila + + number, letter + number, letter - - Stream is too long. - Secuencia demasiado larga. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - El lector de deserialización de "{0}" leyó un número incorrecto de valores. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - Pascal Case + + numbered backreference + numbered backreference - - Abstract Method - Método abstracto - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Metodo asincrónico - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Empieza por I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Clase - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Delegado - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Enumeración - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Evento - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Interfaz - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Miembros que no son un campo - {locked:field} + + positive character range + positive character range + - - Private Method - Método privado - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Campo privado o interno - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Campo estático privado o interno - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Propiedad - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Campo público o protegido - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Campo estático - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Método estático - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Struct - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Tipos - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Método - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Falta el prefijo: "{0}" + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Error + + start of string only + start of string only - - None - Ninguna + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Falta el sufijo: "{0}" + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Las palabras que no están al principio deben comenzar con una letra mayúscula: {0} + + subexpression + subexpression - - Suggestion - Sugerencia + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Las palabras que no están al principio deben comenzar con una letra minúscula: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Estas palabras no pueden contener caracteres en minúscula: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Estas palabras no pueden contener caracteres en mayúscula: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Estas palabras deben comenzar por caracteres en mayúscula: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - La primera palabra, "{0}", debe comenzar con un carácter en mayúscula + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - La primera palabra, "{0}", debe comenzar con un carácter en minúscula + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - El archivo "{0}" con un tamaño de {1} supera el tamaño máximo permitido de {2} + + unicode category + unicode category - - Changing document properties is not supported - No se admite el cambio de propiedades de documentos + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + El símbolo "{0}" no procede del código fuente. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + El Id. del comentario de la documentación debe comenzar por E, F, M, N, P o T - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + Detectado ciclo en extensiones - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + El tipo de destino debe ser un {0}, pero el proporcionado es {1}. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + El tipo de destino debe ser un {0} o un {1}, pero el proporcionado es {2}. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + El tipo de destino debe ser un {0}, {1} o {2}, pero el proporcionado es {3}. - - base-group - base-group + + Could not find location to generation symbol into. + No se pudo encontrar una ubicación en la que generar un símbolo. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + No se ha proporcionado ubicación a la que agregar instrucciones. - - bell character - bell character + + Destination location was not in source. + La ubicación de destino no estaba en el código fuente. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + La ubicación de destino era de otro árbol. - - carriage-return character - carriage-return character + + Node is of the wrong type. + El nodo es del tipo erróneo. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + La ubicación debe ser null o del código fuente. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + Archivo de código fuente "{0}" duplicado en el proyecto "{1}" - - character-group - character-group + + Removing projects is not supported. + No se admite la eliminación de proyectos. - - comment - comment + + Adding projects is not supported. + No se admite la adición de proyectos. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + El área de trabajo no está vacía. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + "{0}" no es parte del área de trabajo. - - control character - control character + + '{0}' is already part of the workspace. + "{0}" ya es parte del área de trabajo. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + "No hay referencia a "{0}". - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + "Ya hay una referencia a "{0}". - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + La adición de una referencia de proyecto de "{0}" a "{1}" originará una referencia circular. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + No hay referencia a los metadatos. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Ya hay una referencia a los metadatos. - - end of string only - end of string only + + {0} is not present. + {0} no está presente. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} ya está presente. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + El documento especificado no es una versión de este documento. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + El lenguaje "{0}" no es compatible. - - end of string or line - end of string or line + + The solution already contains the specified project. + La solución ya contiene el proyecto especificado. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + La solución no contiene el proyecto especificado. - - escape character - escape character + + The project already references the target project. + El proyecto ya hace referencia al proyecto de destino. - - excluded-group - excluded-group + + The project already transitively references the target project. + El proyecto ya hace referencia de forma transitiva al proyecto de destino. - - expression - expression + + The solution already contains the specified document. + La solución ya contiene el documento especificado. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + La solución no contiene el documento especificado. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + No se puede escribir más de una vez en el almacenamiento temporal. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + "{0}" no está abierto. - - group options - group options + + A language name cannot be specified for this option. + No se puede especificar un nombre de lenguaje para esta opción. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Se debe especificar un nombre de lenguaje para esta opción. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + El archivo se modificó externamente: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Nombre de lenguaje no reconocido. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + No se puede resolver la referencia de metadatos: "{0}". - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + No se puede resolver la referencia del analizador: "{0}". - - inline options - inline options + + Invalid project block, expected "=" after Project. + Bloque de proyecto no válido, se esperaba "=" después de Project. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Bloque de proyecto no válido, se esperaba "," después del nombre del proyecto. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Bloque de proyecto no válido, se esperaba "," después de la ruta de acceso del proyecto. - - letter, other - letter, other + + Expected {0}. + Se esperaba {0}. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" debe ser una cadena que no sea Null ni esté vacía. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + Se esperaba encabezado: "{0}". - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Se esperaba fin de archivo. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + Se esperaba línea {0}. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Este envío ya hace referencia a otro proyecto de envío. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} aún contiene documentos abiertos. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} aún está abierto. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Ya existe un elemento con la misma clave pero un valor distinto. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Las matrices con más de una dimensión no se pueden serializar. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Valor demasiado grande para representarse como entero sin signo de 30 bits. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + La ruta de acceso especificada debe ser absoluta. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + La conversión es redundante. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Se puede simplificar el nombre. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Identificador desconocido. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + No se puede generar código para el operador no compatible "{0}" - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Número de parámetros no válido para el operador binario. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Número de parámetros no válido para el operador unario. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Ruta de acceso absoluta esperada. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + No se puede abrir el proyecto "{0}" porque la extensión de archivo "{1}" no está asociada a un lenguaje. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + No se puede abrir el proyecto "{0}" porque el lenguaje "{1}" no es compatible. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Ruta de acceso del archivo de proyecto no válida: "{0}" - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Ruta de acceso del archivo de solución no válida: "{0}" - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Archivo de proyecto no encontrado: "{0}" - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Archivo de solución no encontrado: "{0}" - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Cambio no fusionado mediante combinación del proyecto "{0}" - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Agregado: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Corregir todo "{0}" - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Corregir todo "{0}" en "{1}" - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Corregir todo "{0}" en solución - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Después: - - matched subexpression - matched subexpression + + Before: + Antes: - - name - name + + Removed: + Quitado: - - name1 - name1 + + Invalid CodePage value: {0} + Valor de página de códigos no válido: {0} - - name2 - name2 + + Adding additional documents is not supported. + No se permite agregar documentos adicionales. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + No se permite agregar referencias de analizador. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + No se permite agregar documentos. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + No se permite agregar referencias de metadatos. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + No se permite agregar referencias de proyectos. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + No se permite cambiar documentos adicionales. - - negative character group - negative character group + + Changing documents is not supported. + No se permite cambiar documentos. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + No se permite cambiar propiedades de proyectos. - - negative character range - negative character range + + Removing additional documents is not supported. + No se permite quitar documentos adicionales. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + No se permite quitar referencias de analizador. - - negative unicode category - negative unicode category + + Removing documents is not supported. + No se permite quitar documentos. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + No se permite quitar referencias de metadatos. - - new-line character - new-line character + + Removing project references is not supported. + No se permite quitar referencias de proyectos. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + El servicio de tipo "{0}" es necesario para realizar la tarea, pero no está disponibles desde el área de trabajo. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + El diagnóstico suministrado no puede ser nulo. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + Se debe suministrar al menos un diagnóstico. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + El diagnóstico debe tener el intervalo "{0}" - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + No se puede deserializar el tipo "{0}". - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + No se puede serializar el tipo "{0}". - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + El enlazador de serialización no comprende el tipo "{0}". - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + La etiqueta para el nodo "{0}" no es válida; debe estar entre [0, {1}). + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Los nodos coincidentes "{0}" y "{1}" deben tener la misma etiqueta. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + El nodo "{0}" se debe incluir en el nuevo árbol. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + El nodo "{0}" se debe incluir en el árbol antiguo. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + No se ha declarado el miembro "{0}" dentro de la declaración del símbolo. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + La posición no se encuentra dentro de la declaración del símbolo - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + El símbolo "{0}" no puede estar dentro de la solución actual. - - number, letter - number, letter + + Changing compilation options is not supported. + No se admite el cambio de las opciones de compilación. - - number, other - number, other + + Changing parse options is not supported. + No se admite el cambio de las opciones de análisis. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + El nodo no forma parte del árbol. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Esta área de trabajo no admite la apertura y el cierre de documentos. - - other, control - other, control + + Usage: + Uso: - - other, format - other, format + + Exceptions: + Excepciones: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + "{0}" devolvió una ImmutableArray sin inicializar - - other, private use - other, private use + + Failure + Error - - other, surrogate - other, surrogate + + Warning + Advertencia - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Rellenar switch - - positive character group - positive character group + + Member access should be qualified. + Debe calificarse el acceso a miembros. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Agregar llaves a la instrucción "{0}". - - positive character range - positive character range + + Options did not come from Workspace + Las opciones no procedían del área de trabajo - - punctuation, close - punctuation, close + + Enable + Habilitar - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Habilitar y omitir futuros errores - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + "{0}" detectó un error y se ha deshabilitado. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Mostrar seguimiento de la pila - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Secuencia demasiado larga. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + El lector de deserialización de "{0}" leyó un número incorrecto de valores. - - punctuation, other - punctuation, other + + Pascal Case + Pascal Case - - separator, line - separator, line - + + Abstract Method + Método abstracto + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Metodo asincrónico + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Empieza por I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Clase + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Delegado + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Enumeración + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Evento + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Interfaz + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Miembros que no son un campo + {locked:field} - - symbol, math - symbol, math - + + Private Method + Método privado + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Campo privado o interno + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Campo estático privado o interno + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Propiedad + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Campo público o protegido + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Campo estático + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Método estático + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Struct + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Tipos + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Método + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Falta el prefijo: "{0}" - - vertical-tab character - vertical-tab character + + Error + Error - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Ninguna - - white-space character - white-space character + + Missing suffix: '{0}' + Falta el sufijo: "{0}" - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Las palabras que no están al principio deben comenzar con una letra mayúscula: {0} - - word boundary - word boundary + + Suggestion + Sugerencia - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Las palabras que no están al principio deben comenzar con una letra minúscula: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Estas palabras no pueden contener caracteres en minúscula: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Estas palabras no pueden contener caracteres en mayúscula: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Estas palabras deben comenzar por caracteres en mayúscula: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + La primera palabra, "{0}", debe comenzar con un carácter en mayúscula - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + La primera palabra, "{0}", debe comenzar con un carácter en minúscula - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + El archivo "{0}" con un tamaño de {1} supera el tamaño máximo permitido de {2} - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + No se admite el cambio de propiedades de documentos - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.fr.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.fr.xlf index f6da9afbed9..42daa2b606f 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.fr.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.fr.xlf @@ -72,2094 +72,2094 @@ Refactorisation uniquement - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - Le symbole "{0}" ne provient pas de la source. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - L'ID du commentaire de documentation doit commencer par E, F, M, N, P ou T + + all control characters + all control characters - - Cycle detected in extensions - Cycle détecté dans les extensions + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - Le type de destination doit être un {0}, mais le type donné est {1}. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - Le type de destination doit être un {0} ou un {1}, mais le type donné est {2}. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - Le type de destination doit être un {0}, {1} ou {2}, mais le type donné est {3}. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - L'emplacement dans lequel générer le symbole est introuvable. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Aucun emplacement n'a été fourni pour l'ajout d'instructions. + + all numbers + all numbers - - Destination location was not in source. - L'emplacement de destination n'était pas dans la source. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - L'emplacement de destination provient d'une arborescence différente. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Le type de nœud est incorrect. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - L'emplacement doit être null ou dans la source. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - Dupliquer le fichier source '{0}' dans le projet '{1}' + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - La suppression de projets n'est pas prise en charge. + + all symbols + all symbols - - Adding projects is not supported. - L'ajout de projets n'est pas pris en charge. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - L'espace de travail n'est pas vide. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '{0}' ne fait pas partie de l'espace de travail. + + balancing group + balancing group - - '{0}' is already part of the workspace. - '{0}' fait déjà partie de l'espace de travail. + + base-group + base-group - - '{0}' is not referenced. - '{0}' n'est pas référencé. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '{0}' est déjà référencé. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - L'ajout d'une référence de projet de '{0}' à '{1}' provoquera une référence circulaire. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - Les métadonnées ne sont pas référencées. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Les métadonnées sont déjà référencées. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} n'est pas présent. + + character class subtraction + character class subtraction - - {0} is already present. - {0} est déjà présent. + + character-group + character-group - - The specified document is not a version of this document. - Le document spécifié n'est pas une version de ce document. + + comment + comment - - The language '{0}' is not supported. - Le langage '{0}' n'est pas pris en charge. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - La solution contient déjà le projet spécifié. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - La solution ne contient pas le projet spécifié. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - Le projet référence déjà le projet cible. + + conditional group match + conditional group match - - The project already transitively references the target project. - Le projet référence déjà transitivement le projet cible. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - La solution contient déjà le document spécifié. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - La solution ne contient pas le document spécifié. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - Il est impossible d'écrire plusieurs fois dans le stockage temporaire. + + control character + control character - - '{0}' is not open. - '{0}' n'est pas ouvert. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Impossible de spécifier un nom de langage pour cette option. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Un nom de langage doit être spécifié pour cette option. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Le fichier a été modifié en externe : {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Nom de langage non reconnu. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Impossible de résoudre la référence de métadonnées : '{0}'. + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Impossible de résoudre la référence de l'analyseur : '{0}'. + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Bloc de projet non valide, "=" attendu après Project. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Bloc de projet non valide, "," attendu après le nom du projet. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Bloc de projet non valide, "," attendu après le chemin d'accès au projet. + + end of string or line + end of string or line - - Expected {0}. - {0} attendu. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" doit être une chaîne non null et non vide. + + escape character + escape character - - Expected header: "{0}". - En-tête attendu : "{0}". + + excluded-group + excluded-group - - Expected end-of-file. - Fin de fichier attendue. + + expression + expression - - Expected {0} line. - Ligne {0} attendue. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Cette soumission référence déjà un autre projet de soumission. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} contient encore des documents ouverts. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} est toujours ouvert. + + group options + group options - - An element with the same key but a different value already exists. - Il existe déjà un élément utilisant la même clé mais une autre valeur. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Impossible de sérialiser les tableaux de plus d'une dimension. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - La valeur est trop grande pour être représentée comme un entier non signé 30 bits. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Le chemin d'accès spécifié doit être absolu. + + inline comment + inline comment - - Cast is redundant. - Cast est redondant. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Le nom peut être simplifié. + + inline options + inline options - - Unknown identifier. - Identificateur inconnu. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Impossible de générer du code pour l'opérateur non pris en charge '{0}' + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Nombre de paramètres non valide pour l'opérateur binaire. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Nombre de paramètres non valide pour l'opérateur unaire. + + letter, titlecase + letter, titlecase - - Absolute path expected. - Chemin d'accès absolu attendu. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Impossible d'ouvrir le projet '{0}', car l'extension de fichier '{1}' n'est pas associée à un langage. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - Impossible d'ouvrir le projet '{0}', car le langage '{1}' n'est pas pris en charge. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Chemin d'accès au fichier de projet non valide : '{0}' + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Chemin d'accès au fichier de solution non valide : '{0}' + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Fichier de projet introuvable : '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Fichier solution introuvable : '{0}' + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Modification non fusionnée à partir du projet '{0}' + + match at least 'n' times + match at least 'n' times - - Added: - Ajouté : + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Corriger tous les '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Pour toutes les '{0}' dans '{1}' + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Corriger tous les '{0}' dans la solution + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Après : + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Avant : + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Supprimé : + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Valeur de CodePage non valide : {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - L'ajout de documents supplémentaires n'est pas pris en charge. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - L'ajout de références de l'analyseur n'est pas pris en charge. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - L'ajout de documents n'est pas pris en charge. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - L'ajout de références de métadonnées n'est pas pris en charge. + + match one or more times + match one or more times - - Adding project references is not supported. - L'ajout de références de projet n'est pas pris en charge. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - La modification de documents supplémentaires n'est pas prise en charge. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - La modification de documents n'est pas prise en charge. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - La modification des propriétés de projet n'est pas prise en charge. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - La suppression de documents supplémentaires n'est pas prise en charge. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - La suppression de références de l'analyseur n'est pas prise en charge. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - La suppression de documents n'est pas prise en charge. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - La suppression de références de métadonnées n'est pas prise en charge. + + match zero or one time + match zero or one time - - Removing project references is not supported. - La suppression de références de projet n'est pas prise en charge. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - Le service de type '{0}' est nécessaire pour accomplir la tâche mais n'est pas disponible dans l'espace de travail. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - Le diagnostic fourni ne peut pas être null. + + name + name - - At least one diagnostic must be supplied. - Au moins un diagnostic doit être fourni. + + name1 + name1 - - Diagnostic must have span '{0}' - Le diagnostic doit avoir l'étendue '{0}' + + name2 + name2 - - Cannot deserialize type '{0}'. - Impossible de désérialiser le type '{0}'. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - Impossible de sérialiser le type '{0}'. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - Le type '{0}' n'est pas pris en charge par le binder de sérialisation. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - L’étiquette pour le nœud « {0} » n’est pas valide. Elle doit être comprise dans l’intervalle suivant [0, {1}). + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Les nœuds correspondants « {0} » et « {1} » doivent avoir la même étiquette. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Le nœud « {0} » doit figurer dans la nouvelle arborescence. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Le nœud « {0} » doit figurer dans l’ancienne arborescence. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - Le membre « {0} » n’est pas déclaré dans la déclaration du symbole. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - La position ne se trouve pas dans la déclaration du symbole + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - Le symbole « {0} » ne peut pas se trouver dans la solution actuelle. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - La modification des options de compilation n’est pas prise en charge. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - La modification des options d’analyse n’est pas prise en charge. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - Le nœud ne fait pas partie de l'arborescence. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Cet espace de travail ne prend pas en charge l'ouverture et la fermeture de documents. + + no + no - - Usage: - Utilisation : + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Exceptions : + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0}' a retourné un ImmutableArray non initialisé + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Échec + + non-white-space character + non-white-space character - - Warning - Avertissement + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Remplir une instruction switch + + non-word boundary + non-word boundary - - Member access should be qualified. - L'accès au membre doit être qualifié. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Ajouter des accolades à l'instruction '{0}'. + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Les options ne proviennent pas de l'espace de travail + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Activer + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Activer et ignorer les futures erreurs + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '{0}' a rencontré une erreur et a été désactivé. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Afficher l'arborescence des appels de procédure + + number, letter + number, letter - - Stream is too long. - Le flux est trop long. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - Le lecteur de désérialisation pour '{0}' a lu un nombre incorrect de valeurs. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - Casse Pascal + + numbered backreference + numbered backreference - - Abstract Method - Méthode abstraite - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Méthode async - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Commence par I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Classe - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Délégué - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Enum - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Événement - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Interface - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Membres autres que des champs - {locked:field} + + positive character range + positive character range + - - Private Method - Méthode privée - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Champ privé ou interne - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Champ statique privé ou interne - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Propriété - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Champ public ou protégé - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Champ statique - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Méthode statique - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Struct - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Types - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Méthode - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Préfixe manquant : '{0}' + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Erreur + + start of string only + start of string only - - None - Aucun + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Suffixe manquant : '{0}' + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Les mots suivants, non placés au début, doivent commencer par une lettre majuscule : {0} + + subexpression + subexpression - - Suggestion - Suggestion + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Les mots suivants, non placés au début, doivent commencer par une lettre minuscule : {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Les mots suivants ne peuvent pas contenir de lettres minuscules : {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Les mots suivants ne peuvent pas contenir de lettres majuscules : {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Les mots suivants doivent commencer par des lettres majuscules : {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - Le premier mot, '{0}', doit commencer par une lettre majuscule + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - Le premier mot, '{0}', doit commencer par une lettre minuscule + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - Le fichier '{0}' de {1} dépasse la taille maximale autorisée de {2} + + unicode category + unicode category - - Changing document properties is not supported - Le changement des propriétés du document n'est pas pris en charge + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + Le symbole "{0}" ne provient pas de la source. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + L'ID du commentaire de documentation doit commencer par E, F, M, N, P ou T - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + Cycle détecté dans les extensions - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + Le type de destination doit être un {0}, mais le type donné est {1}. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + Le type de destination doit être un {0} ou un {1}, mais le type donné est {2}. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + Le type de destination doit être un {0}, {1} ou {2}, mais le type donné est {3}. - - base-group - base-group + + Could not find location to generation symbol into. + L'emplacement dans lequel générer le symbole est introuvable. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Aucun emplacement n'a été fourni pour l'ajout d'instructions. - - bell character - bell character + + Destination location was not in source. + L'emplacement de destination n'était pas dans la source. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + L'emplacement de destination provient d'une arborescence différente. - - carriage-return character - carriage-return character + + Node is of the wrong type. + Le type de nœud est incorrect. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + L'emplacement doit être null ou dans la source. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + Dupliquer le fichier source '{0}' dans le projet '{1}' - - character-group - character-group + + Removing projects is not supported. + La suppression de projets n'est pas prise en charge. - - comment - comment + + Adding projects is not supported. + L'ajout de projets n'est pas pris en charge. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + L'espace de travail n'est pas vide. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '{0}' ne fait pas partie de l'espace de travail. - - control character - control character + + '{0}' is already part of the workspace. + '{0}' fait déjà partie de l'espace de travail. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '{0}' n'est pas référencé. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '{0}' est déjà référencé. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + L'ajout d'une référence de projet de '{0}' à '{1}' provoquera une référence circulaire. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + Les métadonnées ne sont pas référencées. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Les métadonnées sont déjà référencées. - - end of string only - end of string only + + {0} is not present. + {0} n'est pas présent. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} est déjà présent. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + Le document spécifié n'est pas une version de ce document. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + Le langage '{0}' n'est pas pris en charge. - - end of string or line - end of string or line + + The solution already contains the specified project. + La solution contient déjà le projet spécifié. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + La solution ne contient pas le projet spécifié. - - escape character - escape character + + The project already references the target project. + Le projet référence déjà le projet cible. - - excluded-group - excluded-group + + The project already transitively references the target project. + Le projet référence déjà transitivement le projet cible. - - expression - expression + + The solution already contains the specified document. + La solution contient déjà le document spécifié. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + La solution ne contient pas le document spécifié. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + Il est impossible d'écrire plusieurs fois dans le stockage temporaire. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '{0}' n'est pas ouvert. - - group options - group options + + A language name cannot be specified for this option. + Impossible de spécifier un nom de langage pour cette option. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Un nom de langage doit être spécifié pour cette option. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Le fichier a été modifié en externe : {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Nom de langage non reconnu. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Impossible de résoudre la référence de métadonnées : '{0}'. - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Impossible de résoudre la référence de l'analyseur : '{0}'. - - inline options - inline options + + Invalid project block, expected "=" after Project. + Bloc de projet non valide, "=" attendu après Project. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Bloc de projet non valide, "," attendu après le nom du projet. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Bloc de projet non valide, "," attendu après le chemin d'accès au projet. - - letter, other - letter, other + + Expected {0}. + {0} attendu. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" doit être une chaîne non null et non vide. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + En-tête attendu : "{0}". - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Fin de fichier attendue. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + Ligne {0} attendue. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Cette soumission référence déjà un autre projet de soumission. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} contient encore des documents ouverts. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} est toujours ouvert. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Il existe déjà un élément utilisant la même clé mais une autre valeur. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Impossible de sérialiser les tableaux de plus d'une dimension. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + La valeur est trop grande pour être représentée comme un entier non signé 30 bits. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Le chemin d'accès spécifié doit être absolu. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Cast est redondant. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Le nom peut être simplifié. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Identificateur inconnu. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Impossible de générer du code pour l'opérateur non pris en charge '{0}' - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Nombre de paramètres non valide pour l'opérateur binaire. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Nombre de paramètres non valide pour l'opérateur unaire. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Chemin d'accès absolu attendu. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Impossible d'ouvrir le projet '{0}', car l'extension de fichier '{1}' n'est pas associée à un langage. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + Impossible d'ouvrir le projet '{0}', car le langage '{1}' n'est pas pris en charge. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Chemin d'accès au fichier de projet non valide : '{0}' - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Chemin d'accès au fichier de solution non valide : '{0}' - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Fichier de projet introuvable : '{0}' - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Fichier solution introuvable : '{0}' - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Modification non fusionnée à partir du projet '{0}' - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Ajouté : - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Corriger tous les '{0}' - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Pour toutes les '{0}' dans '{1}' - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Corriger tous les '{0}' dans la solution - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Après : - - matched subexpression - matched subexpression + + Before: + Avant : - - name - name + + Removed: + Supprimé : - - name1 - name1 + + Invalid CodePage value: {0} + Valeur de CodePage non valide : {0} - - name2 - name2 + + Adding additional documents is not supported. + L'ajout de documents supplémentaires n'est pas pris en charge. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + L'ajout de références de l'analyseur n'est pas pris en charge. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + L'ajout de documents n'est pas pris en charge. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + L'ajout de références de métadonnées n'est pas pris en charge. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + L'ajout de références de projet n'est pas pris en charge. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + La modification de documents supplémentaires n'est pas prise en charge. - - negative character group - negative character group + + Changing documents is not supported. + La modification de documents n'est pas prise en charge. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + La modification des propriétés de projet n'est pas prise en charge. - - negative character range - negative character range + + Removing additional documents is not supported. + La suppression de documents supplémentaires n'est pas prise en charge. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + La suppression de références de l'analyseur n'est pas prise en charge. - - negative unicode category - negative unicode category + + Removing documents is not supported. + La suppression de documents n'est pas prise en charge. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + La suppression de références de métadonnées n'est pas prise en charge. - - new-line character - new-line character + + Removing project references is not supported. + La suppression de références de projet n'est pas prise en charge. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + Le service de type '{0}' est nécessaire pour accomplir la tâche mais n'est pas disponible dans l'espace de travail. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + Le diagnostic fourni ne peut pas être null. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + Au moins un diagnostic doit être fourni. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + Le diagnostic doit avoir l'étendue '{0}' - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + Impossible de désérialiser le type '{0}'. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + Impossible de sérialiser le type '{0}'. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + Le type '{0}' n'est pas pris en charge par le binder de sérialisation. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + L’étiquette pour le nœud « {0} » n’est pas valide. Elle doit être comprise dans l’intervalle suivant [0, {1}). + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Les nœuds correspondants « {0} » et « {1} » doivent avoir la même étiquette. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Le nœud « {0} » doit figurer dans la nouvelle arborescence. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Le nœud « {0} » doit figurer dans l’ancienne arborescence. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + Le membre « {0} » n’est pas déclaré dans la déclaration du symbole. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + La position ne se trouve pas dans la déclaration du symbole - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + Le symbole « {0} » ne peut pas se trouver dans la solution actuelle. - - number, letter - number, letter + + Changing compilation options is not supported. + La modification des options de compilation n’est pas prise en charge. - - number, other - number, other + + Changing parse options is not supported. + La modification des options d’analyse n’est pas prise en charge. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + Le nœud ne fait pas partie de l'arborescence. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Cet espace de travail ne prend pas en charge l'ouverture et la fermeture de documents. - - other, control - other, control + + Usage: + Utilisation : - - other, format - other, format + + Exceptions: + Exceptions : - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0}' a retourné un ImmutableArray non initialisé - - other, private use - other, private use + + Failure + Échec - - other, surrogate - other, surrogate + + Warning + Avertissement - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Remplir une instruction switch - - positive character group - positive character group + + Member access should be qualified. + L'accès au membre doit être qualifié. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Ajouter des accolades à l'instruction '{0}'. - - positive character range - positive character range + + Options did not come from Workspace + Les options ne proviennent pas de l'espace de travail - - punctuation, close - punctuation, close + + Enable + Activer - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Activer et ignorer les futures erreurs - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '{0}' a rencontré une erreur et a été désactivé. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Afficher l'arborescence des appels de procédure - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Le flux est trop long. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + Le lecteur de désérialisation pour '{0}' a lu un nombre incorrect de valeurs. - - punctuation, other - punctuation, other + + Pascal Case + Casse Pascal - - separator, line - separator, line - + + Abstract Method + Méthode abstraite + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Méthode async + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Commence par I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Classe + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Délégué + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Enum + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Événement + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Interface + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Membres autres que des champs + {locked:field} - - symbol, math - symbol, math - + + Private Method + Méthode privée + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Champ privé ou interne + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Champ statique privé ou interne + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Propriété + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Champ public ou protégé + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Champ statique + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Méthode statique + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Struct + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Types + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Méthode + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Préfixe manquant : '{0}' - - vertical-tab character - vertical-tab character + + Error + Erreur - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Aucun - - white-space character - white-space character + + Missing suffix: '{0}' + Suffixe manquant : '{0}' - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Les mots suivants, non placés au début, doivent commencer par une lettre majuscule : {0} - - word boundary - word boundary + + Suggestion + Suggestion - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Les mots suivants, non placés au début, doivent commencer par une lettre minuscule : {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Les mots suivants ne peuvent pas contenir de lettres minuscules : {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Les mots suivants ne peuvent pas contenir de lettres majuscules : {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Les mots suivants doivent commencer par des lettres majuscules : {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + Le premier mot, '{0}', doit commencer par une lettre majuscule - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + Le premier mot, '{0}', doit commencer par une lettre minuscule - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + Le fichier '{0}' de {1} dépasse la taille maximale autorisée de {2} - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + Le changement des propriétés du document n'est pas pris en charge - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.it.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.it.xlf index e3221d55a28..94beafae770 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.it.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.it.xlf @@ -72,2094 +72,2094 @@ Solo refactoring - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - Il simbolo "{0}" non proviene dall'origine. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - L'ID commento della documentazione deve iniziare con E, F, M, N, P o T + + all control characters + all control characters - - Cycle detected in extensions - È stato rilevato un ciclo nelle estensioni + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - Il tipo di destinazione deve essere {0}, ma quello specificato è {1}. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - Il tipo di destinazione deve essere {0} o {1}, ma quello specificato è {2}. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - Il tipo di destinazione deve essere {0}, {1} o {2}, ma quello specificato è {3}. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - Non è stata trovata la posizione in cui generare il simbolo. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Non sono state specificate posizioni in cui aggiungere istruzioni. + + all numbers + all numbers - - Destination location was not in source. - La posizione di destinazione non è inclusa nell'origine. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - La posizione di destinazione è in un albero diverso. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Il tipo del nodo è errato. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - La posizione deve essere Null o derivare dall'origine. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - File di origine '{0}' duplicato nel progetto '{1}' + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - La rimozione di progetti non è supportata. + + all symbols + all symbols - - Adding projects is not supported. - L'aggiunta di progetti non è supportata. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - L'area di lavoro non è vuota. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '{0}' non fa parte dell'area di lavoro. + + balancing group + balancing group - - '{0}' is already part of the workspace. - '{0}' fa già parte dell'area di lavoro. + + base-group + base-group - - '{0}' is not referenced. - '{0}' non viene usato come riferimento. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '{0}' è già usato come riferimento. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - L'aggiunta del riferimento al progetto da '{0}' a '{1}' provocherà un riferimento circolare. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - I metadati non vengono usati come riferimento. + + carriage-return character + carriage-return character - - Metadata is already referenced. - I metadati vengono già usati come riferimento. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} non è presente. + + character class subtraction + character class subtraction - - {0} is already present. - {0} è già presente. + + character-group + character-group - - The specified document is not a version of this document. - Il documento specificato non è una versione di questo documento. + + comment + comment - - The language '{0}' is not supported. - Il linguaggio '{0}' non è supportato. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - La soluzione contiene già il progetto specificato. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - La soluzione non contiene il progetto specificato. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - Il progetto fa già riferimento al progetto di destinazione. + + conditional group match + conditional group match - - The project already transitively references the target project. - Il progetto fa già riferimento in modo transitivo al progetto di destinazione. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - La soluzione contiene già il documento specificato. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - La soluzione non contiene il documento specificato. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - L'archivio temporaneo non può essere scritto più di una volta. + + control character + control character - - '{0}' is not open. - '{0}' non è aperto. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Non è possibile specificare un nome di linguaggio per questa opzione. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - È necessario specificare un nome di linguaggio per questa opzione. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Il file è stato modificato esternamente: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Nome di linguaggio non riconosciuto. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Non è possibile risolvere il riferimento ai metadati: '{0}'. + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Non è possibile risolvere il riferimento all'analizzatore: '{0}'. + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Il blocco di progetto non è valido. È previsto "=" dopo Project. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Il blocco di progetto non è valido. È previsto "," dopo il nome del progetto. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Il blocco di progetto non è valido. È previsto "," dopo il percorso del progetto. + + end of string or line + end of string or line - - Expected {0}. - È previsto '{0}'. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" deve essere una stringa non Null e non vuota. + + escape character + escape character - - Expected header: "{0}". - È prevista un'intestazione: "{0}". + + excluded-group + excluded-group - - Expected end-of-file. - È prevista la fine del file. + + expression + expression - - Expected {0} line. - È prevista la riga {0}. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Questo invio fa già riferimento a un altro progetto di invio. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} contiene ancora documenti aperti. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} è ancora aperto. + + group options + group options - - An element with the same key but a different value already exists. - Esiste già un elemento con la stessa chiave ma valore diverso. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Non è possibile serializzare le matrici con più di una dimensione. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Il valore è troppo grande per essere rappresentato come intero senza segno a 30 bit. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Il percorso specificato deve essere assoluto. + + inline comment + inline comment - - Cast is redundant. - Il cast è ridondante. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Il nome può essere semplificato. + + inline options + inline options - - Unknown identifier. - Identificatore sconosciuto. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Non è possibile generare il codice per l'operatore '{0}' non supportato + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Il numero di parametri per l'operatore binario non è valido. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Il numero di parametri per l'operatore unario non è valido. + + letter, titlecase + letter, titlecase - - Absolute path expected. - È previsto il percorso assoluto. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Non è possibile aprire il progetto '{0}' perché l'estensione di file '{1}' non è associata a un linguaggio. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - Non è possibile aprire il progetto '{0}' perché il linguaggio '{1}' non è supportato. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Percorso del file di progetto non valido: '{0}' + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Percorso del file di soluzione non valido: '{0}' + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Il file di progetto non è stato trovato: '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Il file di soluzione non è stato trovato: '{0}' + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Modifica senza merge dal progetto '{0}' + + match at least 'n' times + match at least 'n' times - - Added: - Aggiunto: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Correggi tutti '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Correggi tutti '{0}' in '{1}' + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Correggi tutti '{0}' nella soluzione + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Dopo: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Prima: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Elementi rimossi: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Valore di CodePage non valido: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - L'aggiunta di altri documenti non è supportata. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - L'aggiunta di riferimenti all'analizzatore non è supportata. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - L'aggiunta di documenti non è supportata. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - L'aggiunta di riferimenti ai metadati non è supportata. + + match one or more times + match one or more times - - Adding project references is not supported. - L'aggiunta di riferimenti al progetto non è supportata. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - La modifica di altri documenti non è supportata. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - La modifica di documenti non è supportata. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - La modifica delle proprietà del progetto non è supportata. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - La rimozione di altri documenti non è supportata. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - La rimozione di riferimenti all'analizzatore non è supportata. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - La rimozione di documenti non è supportata. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - La rimozione di riferimenti ai metadati non è supportata. + + match zero or one time + match zero or one time - - Removing project references is not supported. - La rimozione di riferimenti al progetto non è supportata. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - Per eseguire l'attività, è necessario il servizio di tipo '{0}', che però non è disponibile dall'area di lavoro. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - La diagnostica specificata non può essere Null. + + name + name - - At least one diagnostic must be supplied. - È necessario specificare almeno una diagnostica. + + name1 + name1 - - Diagnostic must have span '{0}' - La diagnostica deve contenere l'elemento span '{0}' + + name2 + name2 - - Cannot deserialize type '{0}'. - Non è possibile deserializzare il tipo '{0}'. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - Non è possibile serializzare il tipo '{0}'. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - Il tipo '{0}' non è riconosciuto dal binder di serializzazioni. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - L'etichetta del nodo '{0}' non è valida. Deve essere compresa tra [0, {1}). + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - I nodi corrispondenti '{0}' e '{1}' devono avere la stessa etichetta. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Il nodo '{0}' deve essere presente nel nuovo albero. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Il nodo '{0}' deve essere presente nel vecchio albero. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - Il membro '{0}' non è dichiarato all'interno della dichiarazione del simbolo. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - La posizione non è compresa nella dichiarazione del simbolo + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - Il simbolo '{0}' non è stato trovato nella soluzione corrente. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - La modifica delle opzioni di compilazione non è supportata. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - La modifica delle opzioni di analisi non è supportata. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - Il nodo non fa parte dell'albero. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Questa area di lavoro non supporta l'apertura e la chiusura di documenti. + + no + no - - Usage: - Utilizzo: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Eccezioni: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0}' ha restituito un elemento ImmutableArray non inizializzato + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Errore + + non-white-space character + non-white-space character - - Warning - Avviso + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Popola switch + + non-word boundary + non-word boundary - - Member access should be qualified. - L'accesso ai membri deve essere qualificato. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Aggiunge le parentesi graffe all'istruzione '{0}'. + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Le opzioni non provengono dall'area di lavoro + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Abilita + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Abilita e ignora gli errori futuri + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '{0}' ha rilevato un errore ed è stato disabilitato. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Mostra analisi dello stack + + number, letter + number, letter - - Stream is too long. - Il flusso è troppo lungo. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - Il numero di valori letto dal lettore di deserializzazioni per '{0}' non è corretto. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - Notazione Pascal + + numbered backreference + numbered backreference - - Abstract Method - Metodo astratto - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Metodo asincrono - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Inizia con I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Classe - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Delegato - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Enum - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Evento - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Interfaccia - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Membri non di campo - {locked:field} + + positive character range + positive character range + - - Private Method - Metodo privato - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Campo privato o interno - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Campo statico privato o interno - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Proprietà - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Campo pubblico o protetto - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Campo statico - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Metodo statico - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Struct - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Tipi - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Metodo - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Manca il prefisso: '{0}' + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Errore + + start of string only + start of string only - - None - Nessuna + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Manca il suffisso: '{0}' + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Queste parole non iniziali devono iniziare con una lettera maiuscola: {0} + + subexpression + subexpression - - Suggestion - Suggerimento + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Queste parole non iniziali devono iniziare con una lettera minuscola: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Queste parole non possono contenere caratteri minuscoli: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Queste parole non possono contenere caratteri maiuscoli: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Queste parole devono iniziare con caratteri maiuscoli: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - La prima parola, '{0}', deve iniziare con un carattere maiuscolo + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - La prima parola, '{0}', deve iniziare con un carattere minuscolo + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - Le dimensioni {1} del file '{0}' sono maggiori di quelle consentite, pari a {2} + + unicode category + unicode category - - Changing document properties is not supported - La modifica delle proprietà del documento non è supportata + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + Il simbolo "{0}" non proviene dall'origine. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + L'ID commento della documentazione deve iniziare con E, F, M, N, P o T - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + È stato rilevato un ciclo nelle estensioni - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + Il tipo di destinazione deve essere {0}, ma quello specificato è {1}. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + Il tipo di destinazione deve essere {0} o {1}, ma quello specificato è {2}. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + Il tipo di destinazione deve essere {0}, {1} o {2}, ma quello specificato è {3}. - - base-group - base-group + + Could not find location to generation symbol into. + Non è stata trovata la posizione in cui generare il simbolo. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Non sono state specificate posizioni in cui aggiungere istruzioni. - - bell character - bell character + + Destination location was not in source. + La posizione di destinazione non è inclusa nell'origine. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + La posizione di destinazione è in un albero diverso. - - carriage-return character - carriage-return character + + Node is of the wrong type. + Il tipo del nodo è errato. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + La posizione deve essere Null o derivare dall'origine. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + File di origine '{0}' duplicato nel progetto '{1}' - - character-group - character-group + + Removing projects is not supported. + La rimozione di progetti non è supportata. - - comment - comment + + Adding projects is not supported. + L'aggiunta di progetti non è supportata. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + L'area di lavoro non è vuota. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '{0}' non fa parte dell'area di lavoro. - - control character - control character + + '{0}' is already part of the workspace. + '{0}' fa già parte dell'area di lavoro. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '{0}' non viene usato come riferimento. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '{0}' è già usato come riferimento. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + L'aggiunta del riferimento al progetto da '{0}' a '{1}' provocherà un riferimento circolare. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + I metadati non vengono usati come riferimento. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + I metadati vengono già usati come riferimento. - - end of string only - end of string only + + {0} is not present. + {0} non è presente. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} è già presente. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + Il documento specificato non è una versione di questo documento. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + Il linguaggio '{0}' non è supportato. - - end of string or line - end of string or line + + The solution already contains the specified project. + La soluzione contiene già il progetto specificato. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + La soluzione non contiene il progetto specificato. - - escape character - escape character + + The project already references the target project. + Il progetto fa già riferimento al progetto di destinazione. - - excluded-group - excluded-group + + The project already transitively references the target project. + Il progetto fa già riferimento in modo transitivo al progetto di destinazione. - - expression - expression + + The solution already contains the specified document. + La soluzione contiene già il documento specificato. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + La soluzione non contiene il documento specificato. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + L'archivio temporaneo non può essere scritto più di una volta. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '{0}' non è aperto. - - group options - group options + + A language name cannot be specified for this option. + Non è possibile specificare un nome di linguaggio per questa opzione. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + È necessario specificare un nome di linguaggio per questa opzione. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Il file è stato modificato esternamente: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Nome di linguaggio non riconosciuto. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Non è possibile risolvere il riferimento ai metadati: '{0}'. - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Non è possibile risolvere il riferimento all'analizzatore: '{0}'. - - inline options - inline options + + Invalid project block, expected "=" after Project. + Il blocco di progetto non è valido. È previsto "=" dopo Project. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Il blocco di progetto non è valido. È previsto "," dopo il nome del progetto. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Il blocco di progetto non è valido. È previsto "," dopo il percorso del progetto. - - letter, other - letter, other + + Expected {0}. + È previsto '{0}'. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" deve essere una stringa non Null e non vuota. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + È prevista un'intestazione: "{0}". - - mark, enclosing - mark, enclosing + + Expected end-of-file. + È prevista la fine del file. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + È prevista la riga {0}. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Questo invio fa già riferimento a un altro progetto di invio. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} contiene ancora documenti aperti. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} è ancora aperto. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Esiste già un elemento con la stessa chiave ma valore diverso. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Non è possibile serializzare le matrici con più di una dimensione. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Il valore è troppo grande per essere rappresentato come intero senza segno a 30 bit. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Il percorso specificato deve essere assoluto. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Il cast è ridondante. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Il nome può essere semplificato. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Identificatore sconosciuto. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Non è possibile generare il codice per l'operatore '{0}' non supportato - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Il numero di parametri per l'operatore binario non è valido. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Il numero di parametri per l'operatore unario non è valido. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + È previsto il percorso assoluto. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Non è possibile aprire il progetto '{0}' perché l'estensione di file '{1}' non è associata a un linguaggio. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + Non è possibile aprire il progetto '{0}' perché il linguaggio '{1}' non è supportato. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Percorso del file di progetto non valido: '{0}' - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Percorso del file di soluzione non valido: '{0}' - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Il file di progetto non è stato trovato: '{0}' - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Il file di soluzione non è stato trovato: '{0}' - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Modifica senza merge dal progetto '{0}' - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Aggiunto: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Correggi tutti '{0}' - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Correggi tutti '{0}' in '{1}' - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Correggi tutti '{0}' nella soluzione - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Dopo: - - matched subexpression - matched subexpression + + Before: + Prima: - - name - name + + Removed: + Elementi rimossi: - - name1 - name1 + + Invalid CodePage value: {0} + Valore di CodePage non valido: {0} - - name2 - name2 + + Adding additional documents is not supported. + L'aggiunta di altri documenti non è supportata. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + L'aggiunta di riferimenti all'analizzatore non è supportata. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + L'aggiunta di documenti non è supportata. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + L'aggiunta di riferimenti ai metadati non è supportata. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + L'aggiunta di riferimenti al progetto non è supportata. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + La modifica di altri documenti non è supportata. - - negative character group - negative character group + + Changing documents is not supported. + La modifica di documenti non è supportata. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + La modifica delle proprietà del progetto non è supportata. - - negative character range - negative character range + + Removing additional documents is not supported. + La rimozione di altri documenti non è supportata. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + La rimozione di riferimenti all'analizzatore non è supportata. - - negative unicode category - negative unicode category + + Removing documents is not supported. + La rimozione di documenti non è supportata. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + La rimozione di riferimenti ai metadati non è supportata. - - new-line character - new-line character + + Removing project references is not supported. + La rimozione di riferimenti al progetto non è supportata. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + Per eseguire l'attività, è necessario il servizio di tipo '{0}', che però non è disponibile dall'area di lavoro. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + La diagnostica specificata non può essere Null. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + È necessario specificare almeno una diagnostica. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + La diagnostica deve contenere l'elemento span '{0}' - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + Non è possibile deserializzare il tipo '{0}'. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + Non è possibile serializzare il tipo '{0}'. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + Il tipo '{0}' non è riconosciuto dal binder di serializzazioni. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + L'etichetta del nodo '{0}' non è valida. Deve essere compresa tra [0, {1}). + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + I nodi corrispondenti '{0}' e '{1}' devono avere la stessa etichetta. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Il nodo '{0}' deve essere presente nel nuovo albero. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Il nodo '{0}' deve essere presente nel vecchio albero. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + Il membro '{0}' non è dichiarato all'interno della dichiarazione del simbolo. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + La posizione non è compresa nella dichiarazione del simbolo - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + Il simbolo '{0}' non è stato trovato nella soluzione corrente. - - number, letter - number, letter + + Changing compilation options is not supported. + La modifica delle opzioni di compilazione non è supportata. - - number, other - number, other + + Changing parse options is not supported. + La modifica delle opzioni di analisi non è supportata. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + Il nodo non fa parte dell'albero. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Questa area di lavoro non supporta l'apertura e la chiusura di documenti. - - other, control - other, control + + Usage: + Utilizzo: - - other, format - other, format + + Exceptions: + Eccezioni: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0}' ha restituito un elemento ImmutableArray non inizializzato - - other, private use - other, private use + + Failure + Errore - - other, surrogate - other, surrogate + + Warning + Avviso - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Popola switch - - positive character group - positive character group + + Member access should be qualified. + L'accesso ai membri deve essere qualificato. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Aggiunge le parentesi graffe all'istruzione '{0}'. - - positive character range - positive character range + + Options did not come from Workspace + Le opzioni non provengono dall'area di lavoro - - punctuation, close - punctuation, close + + Enable + Abilita - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Abilita e ignora gli errori futuri - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '{0}' ha rilevato un errore ed è stato disabilitato. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Mostra analisi dello stack - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Il flusso è troppo lungo. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + Il numero di valori letto dal lettore di deserializzazioni per '{0}' non è corretto. - - punctuation, other - punctuation, other + + Pascal Case + Notazione Pascal - - separator, line - separator, line - + + Abstract Method + Metodo astratto + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Metodo asincrono + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Inizia con I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Classe + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Delegato + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Enum + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Evento + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Interfaccia + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Membri non di campo + {locked:field} - - symbol, math - symbol, math - + + Private Method + Metodo privato + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Campo privato o interno + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Campo statico privato o interno + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Proprietà + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Campo pubblico o protetto + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Campo statico + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Metodo statico + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Struct + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Tipi + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Metodo + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Manca il prefisso: '{0}' - - vertical-tab character - vertical-tab character + + Error + Errore - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Nessuna - - white-space character - white-space character + + Missing suffix: '{0}' + Manca il suffisso: '{0}' - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Queste parole non iniziali devono iniziare con una lettera maiuscola: {0} - - word boundary - word boundary + + Suggestion + Suggerimento - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Queste parole non iniziali devono iniziare con una lettera minuscola: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Queste parole non possono contenere caratteri minuscoli: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Queste parole non possono contenere caratteri maiuscoli: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Queste parole devono iniziare con caratteri maiuscoli: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + La prima parola, '{0}', deve iniziare con un carattere maiuscolo - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + La prima parola, '{0}', deve iniziare con un carattere minuscolo - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + Le dimensioni {1} del file '{0}' sono maggiori di quelle consentite, pari a {2} - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + La modifica delle proprietà del documento non è supportata - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ja.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ja.xlf index 4565ebfddda..5b8e37f9a02 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ja.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ja.xlf @@ -72,2094 +72,2094 @@ リファクタリングのみ - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - シンボル "{0}" は、ソースからではありません。 + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - ドキュメント コメントの ID は、E、F、M、N、P、または T で始まらなければなりません + + all control characters + all control characters - - Cycle detected in extensions - 拡張機能で循環が検出されました + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - ターゲットの型は {0} である必要がありますが、{1} が指定されています。 + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - ターゲットの型は {0} または {1} である必要がありますが、{2} が指定されています。 + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - ターゲットの型は {0}、{1}、または {2} である必要がありますが、{3} が指定されています。 + + all letter characters + all letter characters - - Could not find location to generation symbol into. - シンボルの生成先が見つかりませんでした。 + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - ステートメントを追加する場所がありません。 + + all numbers + all numbers - - Destination location was not in source. - 追加先の場所は、ソース内ではありません。 + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - ターゲットの場所は、別のツリーでした。 + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Node の種類が正しくありません。 + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - 場所は Null であるか、ソースからでなければなりません。 + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - プロジェクト '{1}' でソース ファイル '{0}' が重複しています + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - プロジェクトの削除はサポートされていません。 + + all symbols + all symbols - - Adding projects is not supported. - プロジェクトの追加はサポートされていません。 + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - ワークスペースが空ではありません。 + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '{0}' はワークスペースの一部ではありません。 + + balancing group + balancing group - - '{0}' is already part of the workspace. - '{0}' は既にワークスペースの一部です。 + + base-group + base-group - - '{0}' is not referenced. - '{0}' は参照されていません。 + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '{0}' は既に参照されています。 + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - プロジェクトの参照を '{0}' から '{1}' に追加すると、循環参照が発生します。 + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - メタデータが参照されていません。 + + carriage-return character + carriage-return character - - Metadata is already referenced. - メタデータは既に参照されています。 + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} は存在しません。 + + character class subtraction + character class subtraction - - {0} is already present. - {0} は既に存在します。 + + character-group + character-group - - The specified document is not a version of this document. - 指定されたドキュメントは、このドキュメントのバージョンではありません。 + + comment + comment - - The language '{0}' is not supported. - 言語 '{0}' はサポートされていません。 + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - ソリューションには、指定されたプロジェクトが既に含まれています。 + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - ソリューションには、指定されたプロジェクトがありません。 + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - プロジェクトは、既に対象のプロジェクトを参照します。 + + conditional group match + conditional group match - - The project already transitively references the target project. - プロジェクトは、既に推移的に対象のプロジェクトを参照しています。 + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - ソリューションには、指定されたドキュメントが既に含まれています。 + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - ソリューションには、指定されたドキュメントがありません。 + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - 一時的な記憶域は、2 回以上書き込みできません。 + + control character + control character - - '{0}' is not open. - '{0}' が開いていません。 + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - 言語名は、このオプションでは指定できません。 + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - このオプションの言語名を指定する必要があります。 + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - ファイルが外部で変更されました: {0}。 + + end-of-line comment + end-of-line comment - - Unrecognized language name. - 認識できない言語の名前です。 + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - メタデータの参照を解決できません: '{0}'。 + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - アナライザーの参照を解決できません: '{0}'。 + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - プロジェクト ブロックが正しくありません。プロジェクトの後に "=" が必要です。 + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - プロジェクト ブロックが正しくありません。プロジェクト名の後に "," が必要です。 + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - プロジェクト ブロックが正しくありません。プロジェクト パスの後に "," が必要です。 + + end of string or line + end of string or line - - Expected {0}. - {0} が必要です。 + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" は、Null 以外の空でない文字列にする必要があります。 + + escape character + escape character - - Expected header: "{0}". - ヘッダーが必要です: "{0}"。 + + excluded-group + excluded-group - - Expected end-of-file. - EOF が必要です。 + + expression + expression - - Expected {0} line. - {0} 行が必要です。 + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - この送信は、既に別の送信プロジェクトを参照しています。 + + form-feed character + form-feed character - - {0} still contains open documents. - {0} には、開いているドキュメントが含まれています。 + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} が開いたままです。 + + group options + group options - - An element with the same key but a different value already exists. - キーが同じで値が異なる要素が既に存在します。 + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - 複数のディメンションを持つ配列はシリアル化できません。 + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - 値が大きすぎるため、30 ビットの符号なし整数として表すことができません。 + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - 絶対パスを指定する必要があります。 + + inline comment + inline comment - - Cast is redundant. - キャストが冗長です。 + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - 名前を簡略化できます。 + + inline options + inline options - - Unknown identifier. - 不明な識別子です。 + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - サポートされない演算子 '{0}' のコードは生成できません + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - 二項演算子のパラメーターの数が無効です。 + + letter, other + letter, other - - Invalid number of parameters for unary operator. - 単項演算子のパラメーターの数が無効です。 + + letter, titlecase + letter, titlecase - - Absolute path expected. - 絶対パスが必要です。 + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - ファイルの拡張子 '{1}' が言語に関連付けられていないため、プロジェクト '{0}' を開くことができません。 + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - 言語 '{1}' がサポートされていないため、プロジェクト '{0}' を開くことができません。 + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - 無効なプロジェクト ファイルのパス: '{0}' + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - 無効なソリューション ファイルのパス: '{0}' + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - プロジェクト ファイルが見つかりません: '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - ソリューション ファイルが見つかりません: '{0}' + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - プロジェクト '{0}' からのマージされていない変更 + + match at least 'n' times + match at least 'n' times - - Added: - 追加済み: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - すべての '{0}' を修正します + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - {1}' に含まれているすべての '{0}' を修正します + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - ソリューションに含まれているすべての '{0}' を修正します + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - 後: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - 前: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - 削除済み: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - 無効なコードページの値: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - 追加ドキュメントの追加はサポートされていません。 + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - アナライザー参照の追加はサポートされていません。 + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - ドキュメントの追加はサポートされていません。 + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - メタデータ参照の追加はサポートされていません。 + + match one or more times + match one or more times - - Adding project references is not supported. - プロジェクト参照の追加はサポートされていません。 + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - 追加ドキュメントの変更はサポートされていません。 + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - ドキュメントの変更はサポートされていません。 + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - プロジェクトのプロパティの変更はサポートされていません。 + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - 追加ドキュメントの削除はサポートされていません。 + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - アナライザー参照の削除はサポートされていません。 + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - ドキュメントの削除はサポートされていません。 + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - メタデータ参照の削除はサポートされていません。 + + match zero or one time + match zero or one time - - Removing project references is not supported. - プロジェクト参照の削除はサポートされていません。 + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - 型 '{0}' のサービスはタスクの実行に必要ですが、このワークスペースからは利用できません。 + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - 診断に null は指定できません。 + + name + name - - At least one diagnostic must be supplied. - 1 つ以上の診断を指定しなければなりません。 + + name1 + name1 - - Diagnostic must have span '{0}' - 診断の範囲は '{0}' でなければなりません + + name2 + name2 - - Cannot deserialize type '{0}'. - 型 '{0}' を逆シリアル化できません。 + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - 型 '{0}' をシリアル化できません。 + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - 型 '{0}' がシリアル化バインダーで認識されません。 + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - ノード '{0}' のラベルが無効です。[0, {1}) 内になければなりません。 + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - 一致するノード '{0}' と '{1}' には、同じラベルが含まれていなければなりません。 + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Node '{0}' が、新しいツリーに含まれている必要があります。 + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Node '{0}' が、古いツリーに含まれている必要があります。 + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - シンボルの宣言で、メンバー '{0}' が宣言されていません。 + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - シンボルの宣言内に配置されていません。 + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - シンボル '{0}' は、現在のソリューション内に配置することはできません。 + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - コンパイル オプションの変更はできません。 + + negative unicode category + negative unicode category - - Changing parse options is not supported. - 解析オプションの変更はできません。 + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - ノードはツリーの一部ではありません。 + + new-line character + new-line character - - This workspace does not support opening and closing documents. - このワークスペースではドキュメントの開閉をサポートしません。 + + no + no - - Usage: - 使い方: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - 例外: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0}' が初期化されていない ImmutableArray を返しました + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - 失敗 + + non-white-space character + non-white-space character - - Warning - 警告 + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - スイッチを設定する + + non-word boundary + non-word boundary - - Member access should be qualified. - メンバー アクセスを修飾する必要があります。 + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - {0}' ステートメントに波かっこを追加します。 + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - オプションはワークスペースに由来するものではありません + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - 有効にする + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - 有効化して今後のエラーを無視する + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '{0}' でエラーが生じ、無効になりました。 + + number, decimal digit + number, decimal digit - - Show Stack Trace - スタック トレースを表示します + + number, letter + number, letter - - Stream is too long. - ストリームが長すぎます。 + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - {0}' の逆シリアル化のリーダーが、正しくない数の値を読み取りました。 + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - パスカル ケース + + numbered backreference + numbered backreference - - Abstract Method - 抽象メソッド - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - 非同期メソッド - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - I で始まる - {locked:I} + + other, not assigned + other, not assigned + - - Class - クラス - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - デリゲート - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - 列挙型 - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - イベント - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - インターフェイス - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - フィールド以外のメンバー - {locked:field} + + positive character range + positive character range + - - Private Method - プライベート メソッド - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - プライベートまたは内部フィールド - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - プライベートまたは内部静的フィールド - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - プロパティ - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - パブリックまたは保護されたフィールド - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - 静的フィールド - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - 静的メソッド - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - 構造体 - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - 型 - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - メソッド - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - 存在しないプレフィックス: '{0}' + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - エラー + + start of string only + start of string only - - None - なし + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - 存在しないサフィックス: '{0}' + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - これらの 2 番目以降の単語は、大文字で始まらなければなりません: {0} + + subexpression + subexpression - - Suggestion - 提案事項 + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - これらの 2 番目以降の単語は、小文字で始まらなければなりません: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - これらの単語に小文字が含まれていてはなりません: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - これらの単語に大文字が含まれていてはなりません: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - これらの単語は、大文字で始まらなければなりません: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - 最初の単語 '{0}' は、大文字で始まらなければなりません + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - 最初の単語 '{0}' は、小文字で始まらなければなりません + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - ファイル '{0}' のサイズ {1} が最大許容サイズ {2} を超えています + + unicode category + unicode category - - Changing document properties is not supported - ドキュメントのプロパティの変更はサポートされていません + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + シンボル "{0}" は、ソースからではありません。 - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + ドキュメント コメントの ID は、E、F、M、N、P、または T で始まらなければなりません - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + 拡張機能で循環が検出されました - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + ターゲットの型は {0} である必要がありますが、{1} が指定されています。 - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + ターゲットの型は {0} または {1} である必要がありますが、{2} が指定されています。 - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + ターゲットの型は {0}、{1}、または {2} である必要がありますが、{3} が指定されています。 - - base-group - base-group + + Could not find location to generation symbol into. + シンボルの生成先が見つかりませんでした。 - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + ステートメントを追加する場所がありません。 - - bell character - bell character + + Destination location was not in source. + 追加先の場所は、ソース内ではありません。 - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + ターゲットの場所は、別のツリーでした。 - - carriage-return character - carriage-return character + + Node is of the wrong type. + Node の種類が正しくありません。 - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + 場所は Null であるか、ソースからでなければなりません。 - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + プロジェクト '{1}' でソース ファイル '{0}' が重複しています - - character-group - character-group + + Removing projects is not supported. + プロジェクトの削除はサポートされていません。 - - comment - comment + + Adding projects is not supported. + プロジェクトの追加はサポートされていません。 - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + ワークスペースが空ではありません。 - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '{0}' はワークスペースの一部ではありません。 - - control character - control character + + '{0}' is already part of the workspace. + '{0}' は既にワークスペースの一部です。 - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '{0}' は参照されていません。 - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '{0}' は既に参照されています。 - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + プロジェクトの参照を '{0}' から '{1}' に追加すると、循環参照が発生します。 - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + メタデータが参照されていません。 - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + メタデータは既に参照されています。 - - end of string only - end of string only + + {0} is not present. + {0} は存在しません。 - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} は既に存在します。 - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + 指定されたドキュメントは、このドキュメントのバージョンではありません。 - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + 言語 '{0}' はサポートされていません。 - - end of string or line - end of string or line + + The solution already contains the specified project. + ソリューションには、指定されたプロジェクトが既に含まれています。 - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + ソリューションには、指定されたプロジェクトがありません。 - - escape character - escape character + + The project already references the target project. + プロジェクトは、既に対象のプロジェクトを参照します。 - - excluded-group - excluded-group + + The project already transitively references the target project. + プロジェクトは、既に推移的に対象のプロジェクトを参照しています。 - - expression - expression + + The solution already contains the specified document. + ソリューションには、指定されたドキュメントが既に含まれています。 - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + ソリューションには、指定されたドキュメントがありません。 - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + 一時的な記憶域は、2 回以上書き込みできません。 - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '{0}' が開いていません。 - - group options - group options + + A language name cannot be specified for this option. + 言語名は、このオプションでは指定できません。 - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + このオプションの言語名を指定する必要があります。 - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + ファイルが外部で変更されました: {0}。 - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + 認識できない言語の名前です。 - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + メタデータの参照を解決できません: '{0}'。 - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + アナライザーの参照を解決できません: '{0}'。 - - inline options - inline options + + Invalid project block, expected "=" after Project. + プロジェクト ブロックが正しくありません。プロジェクトの後に "=" が必要です。 - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + プロジェクト ブロックが正しくありません。プロジェクト名の後に "," が必要です。 - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + プロジェクト ブロックが正しくありません。プロジェクト パスの後に "," が必要です。 - - letter, other - letter, other + + Expected {0}. + {0} が必要です。 - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" は、Null 以外の空でない文字列にする必要があります。 - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + ヘッダーが必要です: "{0}"。 - - mark, enclosing - mark, enclosing + + Expected end-of-file. + EOF が必要です。 - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + {0} 行が必要です。 - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + この送信は、既に別の送信プロジェクトを参照しています。 - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} には、開いているドキュメントが含まれています。 - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} が開いたままです。 - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + キーが同じで値が異なる要素が既に存在します。 - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + 複数のディメンションを持つ配列はシリアル化できません。 - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + 値が大きすぎるため、30 ビットの符号なし整数として表すことができません。 - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + 絶対パスを指定する必要があります。 - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + キャストが冗長です。 - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + 名前を簡略化できます。 - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + 不明な識別子です。 - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + サポートされない演算子 '{0}' のコードは生成できません - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + 二項演算子のパラメーターの数が無効です。 - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + 単項演算子のパラメーターの数が無効です。 - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + 絶対パスが必要です。 - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + ファイルの拡張子 '{1}' が言語に関連付けられていないため、プロジェクト '{0}' を開くことができません。 - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + 言語 '{1}' がサポートされていないため、プロジェクト '{0}' を開くことができません。 - - match one or more times - match one or more times + + Invalid project file path: '{0}' + 無効なプロジェクト ファイルのパス: '{0}' - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + 無効なソリューション ファイルのパス: '{0}' - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + プロジェクト ファイルが見つかりません: '{0}' - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + ソリューション ファイルが見つかりません: '{0}' - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + プロジェクト '{0}' からのマージされていない変更 - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + 追加済み: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + すべての '{0}' を修正します - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + {1}' に含まれているすべての '{0}' を修正します - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + ソリューションに含まれているすべての '{0}' を修正します - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + 後: - - matched subexpression - matched subexpression + + Before: + 前: - - name - name + + Removed: + 削除済み: - - name1 - name1 + + Invalid CodePage value: {0} + 無効なコードページの値: {0} - - name2 - name2 + + Adding additional documents is not supported. + 追加ドキュメントの追加はサポートされていません。 - - name-or-number - name-or-number + + Adding analyzer references is not supported. + アナライザー参照の追加はサポートされていません。 - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + ドキュメントの追加はサポートされていません。 - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + メタデータ参照の追加はサポートされていません。 - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + プロジェクト参照の追加はサポートされていません。 - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + 追加ドキュメントの変更はサポートされていません。 - - negative character group - negative character group + + Changing documents is not supported. + ドキュメントの変更はサポートされていません。 - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + プロジェクトのプロパティの変更はサポートされていません。 - - negative character range - negative character range + + Removing additional documents is not supported. + 追加ドキュメントの削除はサポートされていません。 - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + アナライザー参照の削除はサポートされていません。 - - negative unicode category - negative unicode category + + Removing documents is not supported. + ドキュメントの削除はサポートされていません。 - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + メタデータ参照の削除はサポートされていません。 - - new-line character - new-line character + + Removing project references is not supported. + プロジェクト参照の削除はサポートされていません。 - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + 型 '{0}' のサービスはタスクの実行に必要ですが、このワークスペースからは利用できません。 - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + 診断に null は指定できません。 - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + 1 つ以上の診断を指定しなければなりません。 - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + 診断の範囲は '{0}' でなければなりません - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + 型 '{0}' を逆シリアル化できません。 - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + 型 '{0}' をシリアル化できません。 - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + 型 '{0}' がシリアル化バインダーで認識されません。 - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + ノード '{0}' のラベルが無効です。[0, {1}) 内になければなりません。 + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + 一致するノード '{0}' と '{1}' には、同じラベルが含まれていなければなりません。 - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Node '{0}' が、新しいツリーに含まれている必要があります。 - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Node '{0}' が、古いツリーに含まれている必要があります。 - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + シンボルの宣言で、メンバー '{0}' が宣言されていません。 - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + シンボルの宣言内に配置されていません。 - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + シンボル '{0}' は、現在のソリューション内に配置することはできません。 - - number, letter - number, letter + + Changing compilation options is not supported. + コンパイル オプションの変更はできません。 - - number, other - number, other + + Changing parse options is not supported. + 解析オプションの変更はできません。 - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + ノードはツリーの一部ではありません。 - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + このワークスペースではドキュメントの開閉をサポートしません。 - - other, control - other, control + + Usage: + 使い方: - - other, format - other, format + + Exceptions: + 例外: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0}' が初期化されていない ImmutableArray を返しました - - other, private use - other, private use + + Failure + 失敗 - - other, surrogate - other, surrogate + + Warning + 警告 - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + スイッチを設定する - - positive character group - positive character group + + Member access should be qualified. + メンバー アクセスを修飾する必要があります。 - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + {0}' ステートメントに波かっこを追加します。 - - positive character range - positive character range + + Options did not come from Workspace + オプションはワークスペースに由来するものではありません - - punctuation, close - punctuation, close + + Enable + 有効にする - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + 有効化して今後のエラーを無視する - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '{0}' でエラーが生じ、無効になりました。 - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + スタック トレースを表示します - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + ストリームが長すぎます。 - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + {0}' の逆シリアル化のリーダーが、正しくない数の値を読み取りました。 - - punctuation, other - punctuation, other + + Pascal Case + パスカル ケース - - separator, line - separator, line - + + Abstract Method + 抽象メソッド + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + 非同期メソッド + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + I で始まる + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + クラス + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + デリゲート + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + 列挙型 + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + イベント + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + インターフェイス + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + フィールド以外のメンバー + {locked:field} - - symbol, math - symbol, math - + + Private Method + プライベート メソッド + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + プライベートまたは内部フィールド + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + プライベートまたは内部静的フィールド + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + プロパティ + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + パブリックまたは保護されたフィールド + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + 静的フィールド + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + 静的メソッド + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + 構造体 + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + 型 + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + メソッド + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + 存在しないプレフィックス: '{0}' - - vertical-tab character - vertical-tab character + + Error + エラー - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + なし - - white-space character - white-space character + + Missing suffix: '{0}' + 存在しないサフィックス: '{0}' - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + これらの 2 番目以降の単語は、大文字で始まらなければなりません: {0} - - word boundary - word boundary + + Suggestion + 提案事項 - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + これらの 2 番目以降の単語は、小文字で始まらなければなりません: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + これらの単語に小文字が含まれていてはなりません: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + これらの単語に大文字が含まれていてはなりません: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + これらの単語は、大文字で始まらなければなりません: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + 最初の単語 '{0}' は、大文字で始まらなければなりません - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + 最初の単語 '{0}' は、小文字で始まらなければなりません - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + ファイル '{0}' のサイズ {1} が最大許容サイズ {2} を超えています - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + ドキュメントのプロパティの変更はサポートされていません - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ko.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ko.xlf index b1387f7ec94..a5c7e89fc04 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ko.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ko.xlf @@ -72,2094 +72,2094 @@ 리팩터링만 - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - "{0}" 기호가 소스에 없습니다. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - 문서 주석 ID는 E, F, M, N, P 또는 T로 시작해야 합니다. + + all control characters + all control characters - - Cycle detected in extensions - 확장에서 순환 발견 + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - 대상 형식은 {0}이어야 하지만 지정된 형식은 {1}입니다. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - 대상 형식은 {0} 또는 {1}이어야 하지만 지정된 형식은 {2}입니다. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - 대상 형식은 {0}, {1} 또는 {2}이어야 하지만 지정된 형식은 {3}입니다. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - 기호를 생성할 위치를 찾을 수 없습니다. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - 문을 추가할 위치가 제공되지 않았습니다. + + all numbers + all numbers - - Destination location was not in source. - 대상 위치가 소스에 없습니다. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - 다른 트리에서 온 대상 위치입니다. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - 잘못된 형식의 노드입니다. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - 위치는 null이거나 소스에 있어야 합니다. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - {1}' 프로젝트에서 중복된 '{0}' 소스 파일입니다. + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - 프로젝트 제거는 지원되지 않습니다. + + all symbols + all symbols - - Adding projects is not supported. - 프로젝트 추가가 지원되지 않습니다. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - 작업 영역이 비어 있지 않습니다. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '{0}'은(는) 작업 영역의 일부가 아닙니다. + + balancing group + balancing group - - '{0}' is already part of the workspace. - '{0}'은(는) 이미 작업 영역의 일부입니다. + + base-group + base-group - - '{0}' is not referenced. - '{0}'이(가) 참조되지 않았습니다. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '{0}'은(는) 이미 참조되었습니다. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - {0}'에서 '{1}'(으)로 프로젝트 참조를 추가하면 순환 참조가 됩니다. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - 메타데이터가 참조되지 않았습니다. + + carriage-return character + carriage-return character - - Metadata is already referenced. - 메타데이터가 이미 참조되었습니다. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0}이(가) 없습니다. + + character class subtraction + character class subtraction - - {0} is already present. - {0}이(가) 이미 있습니다. + + character-group + character-group - - The specified document is not a version of this document. - 지정한 문서가 이 문서의 버전이 아닙니다. + + comment + comment - - The language '{0}' is not supported. - {0}' 언어는 지원되지 않습니다. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - 솔루션에 지정한 프로젝트가 이미 포함되어 있습니다. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - 솔루션에 지정한 프로젝트가 포함되어 있지 않습니다. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - 프로젝트가 대상 프로젝트를 이미 참조하고 있습니다. + + conditional group match + conditional group match - - The project already transitively references the target project. - 프로젝트가 대상 프로젝트를 이미 타동적으로 참조하고 있습니다. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - 솔루션에 지정한 문서가 이미 포함되어 있습니다. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - 솔루션에 지정한 문서가 포함되어 있지 않습니다. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - 임시 저장소는 두 번 쓸 수 없습니다. + + control character + control character - - '{0}' is not open. - '{0}'이(가) 열리지 않았습니다. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - 이 옵션에 대한 언어 이름을 지정할 수 없습니다. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - 이 옵션에 대한 언어 이름을 지정해야 합니다. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - 파일이 외부에서 수정되었습니다({0}). + + end-of-line comment + end-of-line comment - - Unrecognized language name. - 인식할 수 없는 언어 이름입니다. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - 메타데이터 참조를 확인할 수 없습니다('{0}'). + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - 분석기 참조를 확인할 수 없습니다('{0}'). + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - 잘못된 프로젝트 블록입니다. Project 다음에 "="가 필요합니다. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - 잘못된 프로젝트 블록입니다. 프로젝트 이름 다음에 ","가 필요합니다. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - 잘못된 프로젝트 블록입니다. 프로젝트 경로 다음에 ","가 필요합니다. + + end of string or line + end of string or line - - Expected {0}. - {0}이(가) 필요합니다. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}"은(는) null이 아니거나 비어 있지 않은 문자열이어야 합니다. + + escape character + escape character - - Expected header: "{0}". - 헤더가 필요합니다("{0}"). + + excluded-group + excluded-group - - Expected end-of-file. - 파일 끝(EOF)이 필요합니다. + + expression + expression - - Expected {0} line. - {0} 줄이 필요합니다. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - 이 전송은 이미 다른 전송 프로젝트가 참조했습니다. + + form-feed character + form-feed character - - {0} still contains open documents. - {0}에 열린 문서가 포함되어 있습니다. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0}이(가) 열려 있습니다. + + group options + group options - - An element with the same key but a different value already exists. - 키가 같지만 값이 다른 요소가 이미 있습니다. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - 차원이 두 개 이상인 배열을 직렬화할 수 없습니다. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - 값이 너무 커서 30비트 부호 없는 정수로 표시할 수 없습니다. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - 지정한 경로가 절대 경로여야 합니다. + + inline comment + inline comment - - Cast is redundant. - 캐스팅이 중복됩니다. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - 이름은 간단하게 줄일 수 있습니다. + + inline options + inline options - - Unknown identifier. - 알 수 없는 식별자입니다. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - 지원되지 않는 '{0}' 연산자에 대한 코드를 생성할 수 없습니다. + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - 이진 연산자에 대해 잘못된 매개 변수 수입니다. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - 단항 연산자에 대해 잘못된 매개 변수 수입니다. + + letter, titlecase + letter, titlecase - - Absolute path expected. - 절대 경로가 필요합니다. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - {1}' 파일 확장명이 언어에 연결되어 있지 않아 '{0}' 프로젝트를 열 수 없습니다. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - {1}' 언어를 지원하지 않아 '{0}' 프로젝트를 열 수 없습니다. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - 잘못된 프로젝트 파일 경로입니다('{0}'). + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - 잘못된 솔루션 파일 경로입니다('{0}'). + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - {0}' 프로젝트 파일을 찾을 수 없습니다. + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - {0}' 솔루션 파일을 찾을 수 없습니다. + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - {0}' 프로젝트에서 병합되지 않은 변경 내용 + + match at least 'n' times + match at least 'n' times - - Added: - 추가됨: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - 모든 '{0}' 수정 + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - {1}'의 모든 '{0}' 수정 + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - 솔루션의 모든 '{0}' 수정 + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - 이후: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - 이전: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - 제거됨: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - 잘못된 CodePage 값: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - 추가 문서 추가는 지원되지 않았습니다. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - 분석기 참조 추가는 지원되지 않습니다. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - 문서 추가는 지원되지 않습니다. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - 메타데이터 참조 추가는 지원되지 않습니다. + + match one or more times + match one or more times - - Adding project references is not supported. - 프로젝트 참조 추가는 지원되지 않습니다. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - 추가 문서 변경은 지원되지 않습니다. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - 문서 변경은 지원되지 않습니다. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - 프로젝트 속성 변경은 지원되지 않습니다. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - 추가 문서 제거는 지원되지 않습니다. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - 분석기 참조 제거는 지원되지 않습니다. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - 문서 제거는 지원되지 않습니다. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - 메타데이터 참조 제거는 지원되지 않습니다. + + match zero or one time + match zero or one time - - Removing project references is not supported. - 프로젝트 참조 제거는 지원되지 않습니다. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - {0}' 유형의 서비스가 작업을 수행하는 데 필요하지만 작업 영역에서 사용할 수 없습니다. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - 제공된 진단은 null일 수 없습니다. + + name + name - - At least one diagnostic must be supplied. - 하나 이상의 진단을 제공해야 합니다. + + name1 + name1 - - Diagnostic must have span '{0}' - 진단에는 '{0}' 범위가 있어야 합니다. + + name2 + name2 - - Cannot deserialize type '{0}'. - {0}' 형식을 역직렬화할 수 없습니다. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - {0}' 형식을 직렬화할 수 없습니다. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - 직렬화 바인더가 '{0}' 형식을 인식할 수 없습니다. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - {0}' 노드의 레이블이 잘못되었습니다. [0, {1}) 내에 있어야 합니다. + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - 일치하는 노드 '{0}' 및 '{1}'에 동일한 레이블이 있어야 합니다. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - {0}' 노드가 새 트리에 포함되어야 합니다. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - {0}' 노드가 이전 트리에 포함되어야 합니다. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - {0}' 멤버가 기호의 선언 내에서 선언되지 않았습니다. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - 위치가 기호의 선언 내에 없습니다. + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - 현재 솔루션 내에서 '{0}' 기호를 찾을 수 없습니다. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - 컴파일 옵션 변경은 지원되지 않습니다. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - 구문 분석 옵션 변경은 지원되지 않습니다. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - 노드는 트리의 일부가 아닙니다. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - 이 작업 영역에서는 문서 열기 및 닫기를 지원하지 않습니다. + + no + no - - Usage: - 사용법: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - 예외: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0}'에서 초기화되지 않은 ImmutableArray를 반환했습니다. + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - 실패 + + non-white-space character + non-white-space character - - Warning - 경고 + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - 스위치 채우기 + + non-word boundary + non-word boundary - - Member access should be qualified. - 멤버 액세스를 한정해야 합니다. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - {0}' 문에 중괄호를 추가합니다. + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - 옵션을 작업 영역에서 가져오지 않음 + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - 사용 + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - 추가 오류 무시하고 사용 + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '{0}'에 오류가 발생하여 사용할 수 없습니다. + + number, decimal digit + number, decimal digit - - Show Stack Trace - 스택 추적 표시 + + number, letter + number, letter - - Stream is too long. - 스트림이 너무 깁니다. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - {0}'에 대한 역직렬화 판독기가 잘못된 숫자 값을 읽습니다. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - 파스칼식 대/소문자 + + numbered backreference + numbered backreference - - Abstract Method - 추상 메서드 - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - 비동기 메서드 - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - I로 시작 - {locked:I} + + other, not assigned + other, not assigned + - - Class - 클래스 - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - 대리자 - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - 열거형 - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - 이벤트 - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - 인터페이스 - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - 필드가 아닌 멤버 - {locked:field} + + positive character range + positive character range + - - Private Method - 전용 메서드 - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - 전용 또는 내부 필드 - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - 전용 또는 내부 정적 필드 - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - 속성 - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - 공용 또는 보호된 필드 - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - 정적 필드 - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - 정적 메서드 - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - 구조체 - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - 형식 - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - 메서드 - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - 누락된 접두사: '{0}' + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - 오류 + + start of string only + start of string only - - None - 없음 + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - 누락된 접미사: '{0}' + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - 이러한 맨 앞에 있지 않는 단어는 대문자로 시작해야 합니다. {0} + + subexpression + subexpression - - Suggestion - 제안 + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - 이러한 맨 앞에 있지 않는 단어는 소문자로 시작해야 합니다. {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - 이러한 단어에는 소문자를 사용할 수 없습니다. {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - 이러한 단어에는 대문자를 사용할 수 없습니다. {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - 이러한 단어는 대문자로 시작해야 합니다. {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - 첫 번째 단어 '{0}'은(는) 대문자로 시작해야 합니다. + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - 첫 번째 단어 '{0}'은(는) 소문자로 시작해야 합니다. + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - 파일 '{0}'의 크기({1})가 최대 허용되는 크기({2})를 초과했습니다. + + unicode category + unicode category - - Changing document properties is not supported - 문서 속성 변경은 지원되지 않습니다. + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + "{0}" 기호가 소스에 없습니다. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + 문서 주석 ID는 E, F, M, N, P 또는 T로 시작해야 합니다. - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + 확장에서 순환 발견 - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + 대상 형식은 {0}이어야 하지만 지정된 형식은 {1}입니다. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + 대상 형식은 {0} 또는 {1}이어야 하지만 지정된 형식은 {2}입니다. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + 대상 형식은 {0}, {1} 또는 {2}이어야 하지만 지정된 형식은 {3}입니다. - - base-group - base-group + + Could not find location to generation symbol into. + 기호를 생성할 위치를 찾을 수 없습니다. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + 문을 추가할 위치가 제공되지 않았습니다. - - bell character - bell character + + Destination location was not in source. + 대상 위치가 소스에 없습니다. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + 다른 트리에서 온 대상 위치입니다. - - carriage-return character - carriage-return character + + Node is of the wrong type. + 잘못된 형식의 노드입니다. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + 위치는 null이거나 소스에 있어야 합니다. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + {1}' 프로젝트에서 중복된 '{0}' 소스 파일입니다. - - character-group - character-group + + Removing projects is not supported. + 프로젝트 제거는 지원되지 않습니다. - - comment - comment + + Adding projects is not supported. + 프로젝트 추가가 지원되지 않습니다. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + 작업 영역이 비어 있지 않습니다. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '{0}'은(는) 작업 영역의 일부가 아닙니다. - - control character - control character + + '{0}' is already part of the workspace. + '{0}'은(는) 이미 작업 영역의 일부입니다. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '{0}'이(가) 참조되지 않았습니다. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '{0}'은(는) 이미 참조되었습니다. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + {0}'에서 '{1}'(으)로 프로젝트 참조를 추가하면 순환 참조가 됩니다. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + 메타데이터가 참조되지 않았습니다. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + 메타데이터가 이미 참조되었습니다. - - end of string only - end of string only + + {0} is not present. + {0}이(가) 없습니다. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0}이(가) 이미 있습니다. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + 지정한 문서가 이 문서의 버전이 아닙니다. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + {0}' 언어는 지원되지 않습니다. - - end of string or line - end of string or line + + The solution already contains the specified project. + 솔루션에 지정한 프로젝트가 이미 포함되어 있습니다. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + 솔루션에 지정한 프로젝트가 포함되어 있지 않습니다. - - escape character - escape character + + The project already references the target project. + 프로젝트가 대상 프로젝트를 이미 참조하고 있습니다. - - excluded-group - excluded-group + + The project already transitively references the target project. + 프로젝트가 대상 프로젝트를 이미 타동적으로 참조하고 있습니다. - - expression - expression + + The solution already contains the specified document. + 솔루션에 지정한 문서가 이미 포함되어 있습니다. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + 솔루션에 지정한 문서가 포함되어 있지 않습니다. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + 임시 저장소는 두 번 쓸 수 없습니다. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '{0}'이(가) 열리지 않았습니다. - - group options - group options + + A language name cannot be specified for this option. + 이 옵션에 대한 언어 이름을 지정할 수 없습니다. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + 이 옵션에 대한 언어 이름을 지정해야 합니다. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + 파일이 외부에서 수정되었습니다({0}). - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + 인식할 수 없는 언어 이름입니다. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + 메타데이터 참조를 확인할 수 없습니다('{0}'). - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + 분석기 참조를 확인할 수 없습니다('{0}'). - - inline options - inline options + + Invalid project block, expected "=" after Project. + 잘못된 프로젝트 블록입니다. Project 다음에 "="가 필요합니다. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + 잘못된 프로젝트 블록입니다. 프로젝트 이름 다음에 ","가 필요합니다. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + 잘못된 프로젝트 블록입니다. 프로젝트 경로 다음에 ","가 필요합니다. - - letter, other - letter, other + + Expected {0}. + {0}이(가) 필요합니다. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}"은(는) null이 아니거나 비어 있지 않은 문자열이어야 합니다. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + 헤더가 필요합니다("{0}"). - - mark, enclosing - mark, enclosing + + Expected end-of-file. + 파일 끝(EOF)이 필요합니다. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + {0} 줄이 필요합니다. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + 이 전송은 이미 다른 전송 프로젝트가 참조했습니다. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0}에 열린 문서가 포함되어 있습니다. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0}이(가) 열려 있습니다. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + 키가 같지만 값이 다른 요소가 이미 있습니다. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + 차원이 두 개 이상인 배열을 직렬화할 수 없습니다. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + 값이 너무 커서 30비트 부호 없는 정수로 표시할 수 없습니다. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + 지정한 경로가 절대 경로여야 합니다. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + 캐스팅이 중복됩니다. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + 이름은 간단하게 줄일 수 있습니다. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + 알 수 없는 식별자입니다. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + 지원되지 않는 '{0}' 연산자에 대한 코드를 생성할 수 없습니다. - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + 이진 연산자에 대해 잘못된 매개 변수 수입니다. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + 단항 연산자에 대해 잘못된 매개 변수 수입니다. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + 절대 경로가 필요합니다. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + {1}' 파일 확장명이 언어에 연결되어 있지 않아 '{0}' 프로젝트를 열 수 없습니다. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + {1}' 언어를 지원하지 않아 '{0}' 프로젝트를 열 수 없습니다. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + 잘못된 프로젝트 파일 경로입니다('{0}'). - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + 잘못된 솔루션 파일 경로입니다('{0}'). - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + {0}' 프로젝트 파일을 찾을 수 없습니다. - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + {0}' 솔루션 파일을 찾을 수 없습니다. - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + {0}' 프로젝트에서 병합되지 않은 변경 내용 - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + 추가됨: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + 모든 '{0}' 수정 - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + {1}'의 모든 '{0}' 수정 - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + 솔루션의 모든 '{0}' 수정 - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + 이후: - - matched subexpression - matched subexpression + + Before: + 이전: - - name - name + + Removed: + 제거됨: - - name1 - name1 + + Invalid CodePage value: {0} + 잘못된 CodePage 값: {0} - - name2 - name2 + + Adding additional documents is not supported. + 추가 문서 추가는 지원되지 않았습니다. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + 분석기 참조 추가는 지원되지 않습니다. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + 문서 추가는 지원되지 않습니다. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + 메타데이터 참조 추가는 지원되지 않습니다. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + 프로젝트 참조 추가는 지원되지 않습니다. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + 추가 문서 변경은 지원되지 않습니다. - - negative character group - negative character group + + Changing documents is not supported. + 문서 변경은 지원되지 않습니다. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + 프로젝트 속성 변경은 지원되지 않습니다. - - negative character range - negative character range + + Removing additional documents is not supported. + 추가 문서 제거는 지원되지 않습니다. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + 분석기 참조 제거는 지원되지 않습니다. - - negative unicode category - negative unicode category + + Removing documents is not supported. + 문서 제거는 지원되지 않습니다. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + 메타데이터 참조 제거는 지원되지 않습니다. - - new-line character - new-line character + + Removing project references is not supported. + 프로젝트 참조 제거는 지원되지 않습니다. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + {0}' 유형의 서비스가 작업을 수행하는 데 필요하지만 작업 영역에서 사용할 수 없습니다. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + 제공된 진단은 null일 수 없습니다. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + 하나 이상의 진단을 제공해야 합니다. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + 진단에는 '{0}' 범위가 있어야 합니다. - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + {0}' 형식을 역직렬화할 수 없습니다. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + {0}' 형식을 직렬화할 수 없습니다. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + 직렬화 바인더가 '{0}' 형식을 인식할 수 없습니다. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + {0}' 노드의 레이블이 잘못되었습니다. [0, {1}) 내에 있어야 합니다. + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + 일치하는 노드 '{0}' 및 '{1}'에 동일한 레이블이 있어야 합니다. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + {0}' 노드가 새 트리에 포함되어야 합니다. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + {0}' 노드가 이전 트리에 포함되어야 합니다. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + {0}' 멤버가 기호의 선언 내에서 선언되지 않았습니다. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + 위치가 기호의 선언 내에 없습니다. - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + 현재 솔루션 내에서 '{0}' 기호를 찾을 수 없습니다. - - number, letter - number, letter + + Changing compilation options is not supported. + 컴파일 옵션 변경은 지원되지 않습니다. - - number, other - number, other + + Changing parse options is not supported. + 구문 분석 옵션 변경은 지원되지 않습니다. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + 노드는 트리의 일부가 아닙니다. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + 이 작업 영역에서는 문서 열기 및 닫기를 지원하지 않습니다. - - other, control - other, control + + Usage: + 사용법: - - other, format - other, format + + Exceptions: + 예외: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0}'에서 초기화되지 않은 ImmutableArray를 반환했습니다. - - other, private use - other, private use + + Failure + 실패 - - other, surrogate - other, surrogate + + Warning + 경고 - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + 스위치 채우기 - - positive character group - positive character group + + Member access should be qualified. + 멤버 액세스를 한정해야 합니다. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + {0}' 문에 중괄호를 추가합니다. - - positive character range - positive character range + + Options did not come from Workspace + 옵션을 작업 영역에서 가져오지 않음 - - punctuation, close - punctuation, close + + Enable + 사용 - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + 추가 오류 무시하고 사용 - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '{0}'에 오류가 발생하여 사용할 수 없습니다. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + 스택 추적 표시 - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + 스트림이 너무 깁니다. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + {0}'에 대한 역직렬화 판독기가 잘못된 숫자 값을 읽습니다. - - punctuation, other - punctuation, other + + Pascal Case + 파스칼식 대/소문자 - - separator, line - separator, line - + + Abstract Method + 추상 메서드 + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + 비동기 메서드 + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + I로 시작 + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + 클래스 + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + 대리자 + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + 열거형 + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + 이벤트 + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + 인터페이스 + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + 필드가 아닌 멤버 + {locked:field} - - symbol, math - symbol, math - + + Private Method + 전용 메서드 + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + 전용 또는 내부 필드 + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + 전용 또는 내부 정적 필드 + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + 속성 + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + 공용 또는 보호된 필드 + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + 정적 필드 + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + 정적 메서드 + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + 구조체 + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + 형식 + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + 메서드 + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + 누락된 접두사: '{0}' - - vertical-tab character - vertical-tab character + + Error + 오류 - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + 없음 - - white-space character - white-space character + + Missing suffix: '{0}' + 누락된 접미사: '{0}' - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + 이러한 맨 앞에 있지 않는 단어는 대문자로 시작해야 합니다. {0} - - word boundary - word boundary + + Suggestion + 제안 - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + 이러한 맨 앞에 있지 않는 단어는 소문자로 시작해야 합니다. {0} - - word character - word character + + These words cannot contain lower case characters: {0} + 이러한 단어에는 소문자를 사용할 수 없습니다. {0} - - yes - yes + + These words cannot contain upper case characters: {0} + 이러한 단어에는 대문자를 사용할 수 없습니다. {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + 이러한 단어는 대문자로 시작해야 합니다. {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + 첫 번째 단어 '{0}'은(는) 대문자로 시작해야 합니다. - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + 첫 번째 단어 '{0}'은(는) 소문자로 시작해야 합니다. - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + 파일 '{0}'의 크기({1})가 최대 허용되는 크기({2})를 초과했습니다. - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + 문서 속성 변경은 지원되지 않습니다. - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pl.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pl.xlf index d95af5f0b47..a9dce426793 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pl.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pl.xlf @@ -72,2094 +72,2094 @@ Tylko refaktoryzacja - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - Symbol „{0}” nie pochodzi ze źródła. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - Identyfikator komentarza do dokumentacji musi rozpoczynać się od litery E, F, M, N, P lub T + + all control characters + all control characters - - Cycle detected in extensions - W rozszerzeniach wykryto cykl + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - Typ docelowy musi być elementem {0}, ale podano element {1}. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - Typ docelowy musi być elementem {0} lub {1}, ale podano element {2}. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - Typ docelowy musi być elementem {0}, {1} lub {2}, ale podano element {3}. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - Nie można znaleźć lokalizacji do wygenerowania symbolu. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Nie podano lokalizacji, do których można dodać instrukcje. + + all numbers + all numbers - - Destination location was not in source. - Lokalizacja docelowa nie znajdowała się w źródle. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - Lokalizacja docelowa pochodziła z innego drzewa. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Węzeł ma nieprawidłowy typ. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - Lokalizacja musi mieć wartość null lub pochodzić ze źródła. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - Zduplikowany plik źródłowy „{0}” w projekcie „{1}” + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - Usuwanie projektów nie jest obsługiwane. + + all symbols + all symbols - - Adding projects is not supported. - Dodawanie projektów nie jest obsługiwane. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - Obszar roboczy nie jest pusty. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - 'Element „{0}” nie jest częścią obszaru roboczego. + + balancing group + balancing group - - '{0}' is already part of the workspace. - 'Element „{0}” jest już częścią obszaru roboczego. + + base-group + base-group - - '{0}' is not referenced. - 'Element „{0}” nie jest przywoływany. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - 'Element „{0}” jest już przywoływany. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - Dodanie odwołania do projektu z „{0}” do „{1}” spowoduje powstanie odwołania cyklicznego. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - Metadane nie są przywoływane. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Metadane są już przywoływane. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - Element {0} nie istnieje. + + character class subtraction + character class subtraction - - {0} is already present. - Element {0} już istnieje. + + character-group + character-group - - The specified document is not a version of this document. - Określony dokument nie jest wersją tego dokumentu. + + comment + comment - - The language '{0}' is not supported. - Język „{0}” nie jest obsługiwany. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - To rozwiązanie zawiera już określony projekt. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - Rozwiązanie nie zawiera określonego projektu. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - Projekt już przywołuje projekt docelowy. + + conditional group match + conditional group match - - The project already transitively references the target project. - Już istnieje odwołanie przechodnie projektu do projektu docelowego. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - Rozwiązanie już zawiera określony dokument. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - Rozwiązanie nie zawiera określonego dokumentu. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - W tymczasowym magazynie nie można zapisać więcej niż raz. + + control character + control character - - '{0}' is not open. - 'Element „{0}” nie jest otwarty. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Nie można określić nazwy języka dla tej opcji. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Nazwa języka musi zostać określona dla tej opcji. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Plik został zmodyfikowany na zewnątrz: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Nierozpoznana nazwa języka. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Nie można rozwiązać odwołania do metadanych: „{0}”. + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Nie można rozpoznać odwołania do analizatora: „{0}”. + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Nieprawidłowy blok projektu, oczekiwano znaku „=” po elemencie Project. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Nieprawidłowy blok projektu, oczekiwano znaku „,” (przecinek) po nazwie projektu. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Nieprawidłowy blok projektu, oczekiwano znaku „,” (przecinek) po ścieżce projektu. + + end of string or line + end of string or line - - Expected {0}. - Oczekiwano elementu {0}. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - Element „{0}” musi być ciągiem, który nie ma wartości null i nie jest pusty. + + escape character + escape character - - Expected header: "{0}". - Oczekiwano nagłówka: „{0}”. + + excluded-group + excluded-group - - Expected end-of-file. - Oczekiwano końca pliku. + + expression + expression - - Expected {0} line. - Oczekiwano wiersza {0}. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Ten przesłany element przywołuje już inny przesłany projekt. + + form-feed character + form-feed character - - {0} still contains open documents. - Element {0} nadal zawiera otwarte dokumenty. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - Element {0} jest nadal otwarty. + + group options + group options - - An element with the same key but a different value already exists. - Element z tym samym kluczem, ale inną wartością, już istnieje. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Nie można przeprowadzić serializacji tablic z więcej niż jednym wymiarem. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Wartość jest zbyt duża, dlatego nie może być reprezentowana jako 30-bitowa liczba całkowita bez znaku. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Należy określić ścieżkę bezwzględną. + + inline comment + inline comment - - Cast is redundant. - Rzutowanie jest zbędne. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Nazwa może zostać uproszczona. + + inline options + inline options - - Unknown identifier. - Nieznany identyfikator. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Nie można wygenerować kodu dla nieobsługiwanego operatora „{0}” + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Nieprawidłowa liczba parametrów operatora binarnego. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Nieprawidłowa liczba parametrów operatora jednoargumentowego. + + letter, titlecase + letter, titlecase - - Absolute path expected. - Oczekiwano ścieżki bezwzględnej. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Nie można otworzyć projektu „{0}”, ponieważ rozszerzenie pliku „{1}” nie jest skojarzone z językiem. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - Nie można otworzyć projektu „{0}”, ponieważ język „{1}” nie jest obsługiwany. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Nieprawidłowa ścieżka pliku projektu: „{0}” + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Nieprawidłowa ścieżka pliku rozwiązania: „{0}” + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Nie znaleziono pliku projektu: „{0}” + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Nie znaleziono pliku rozwiązania: „{0}” + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Niescalona zmiana z projektu „{0}” + + match at least 'n' times + match at least 'n' times - - Added: - Dodano: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Napraw wszystkie wystąpienia elementu „{0}” + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Napraw wszystkie wystąpienia elementu „{0}” w zakresie „{1}” + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Napraw wszystkie wystąpienia elementu „{0}” w rozwiązaniu + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Po: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Przed: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Usunięto: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Nieprawidłowa wartość strony kodowej: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - Dodawanie kolejnych dokumentów nie jest obsługiwane. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - Dodawanie odwołań analizatora nie jest obsługiwane. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - Dodawanie dokumentów nie jest obsługiwane. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - Dodawanie odwołań metadanych nie jest obsługiwane. + + match one or more times + match one or more times - - Adding project references is not supported. - Dodawanie odwołań projektów nie jest obsługiwane. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - Modyfikowanie dodatkowych dokumentów nie jest obsługiwane. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - Modyfikowanie dokumentów nie jest obsługiwane. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - Modyfikowanie właściwości projektów nie jest obsługiwane. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - Usuwanie dodatkowych dokumentów nie jest obsługiwane. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - Usuwanie odwołań analizatora nie jest obsługiwane. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - Usuwanie dokumentów nie jest obsługiwane. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - Usuwanie odwołań metadanych nie jest obsługiwane. + + match zero or one time + match zero or one time - - Removing project references is not supported. - Usuwanie odwołań projektów nie jest obsługiwane. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - Usługa typu „{0}” jest wymagana do wykonania zadania, lecz nie jest dostępna w obszarze roboczym. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - Podane informacje diagnostyczne nie mogą mieć wartości null. + + name + name - - At least one diagnostic must be supplied. - Należy podać co najmniej jedną informację diagnostyczną. + + name1 + name1 - - Diagnostic must have span '{0}' - Informacje diagnostyczne muszą mieć zakres „{0}” + + name2 + name2 - - Cannot deserialize type '{0}'. - Nie można deserializować typu „{0}”. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - Nie można serializować typu „{0}”. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - Typ „{0}” nie jest zrozumiały dla integratora serializacji. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - Etykieta dla węzła „{0}” jest nieprawidłowa, musi być z zakresu [0, {1}). + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Zgodne węzły „{0}” i „{1}” muszą mieć taką samą etykietę. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Węzeł „{0}” musi być zawarty w nowym drzewie. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Węzeł „{0}” musi być zawarty w starym drzewie. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - Składowa „{0}” nie została zadeklarowana w obrębie deklaracji symbolu. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - Pozycja nie znajduje się w obrębie deklaracji symbolu + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - Symbol „{0}” nie może się znajdować w obrębie bieżącego rozwiązania. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - Zmiana opcji kompilacji nie jest obsługiwana. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - Zmiana opcji analizy nie jest obsługiwana. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - Węzeł nie jest częścią drzewa. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Otwieranie i zamykanie dokumentów nie jest obsługiwane w tym obszarze roboczym. + + no + no - - Usage: - Użycie: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Wyjątki: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - 'Element „{0}” zwrócił niezainicjowany element ImmutableArray + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Błąd + + non-white-space character + non-white-space character - - Warning - Ostrzeżenie + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Wypełnij instrukcję switch + + non-word boundary + non-word boundary - - Member access should be qualified. - Dostęp do składowej powinien mieć kwalifikator. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Dodaj nawiasy klamrowe do instrukcji „{0}”. + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Opcje nie pochodziły z obszaru roboczego + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Włącz + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Włącz i ignoruj przyszłe błędy + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - 'Element „{0}” napotkał błąd i został wyłączony. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Pokaż ślad stosu + + number, letter + number, letter - - Stream is too long. - Strumień jest za długi. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - Czytnik deserializacji dla elementu „{0}” odczytuje nieprawidłową liczbę wartości. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - PascalCase + + numbered backreference + numbered backreference - - Abstract Method - Metoda abstrakcyjna - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Metoda asynchroniczna - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Rozpoczyna się znakiem I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Klasa - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Delegat - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Wyliczenie - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Zdarzenie - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Interfejs - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Składowe inne niż pola - {locked:field} + + positive character range + positive character range + - - Private Method - Metoda prywatna - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Pole prywatne lub wewnętrzne - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Prywatne lub wewnętrzne pole statyczne - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Właściwość - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Pole publiczne lub chronione - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Pole statyczne - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Metoda statyczna - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Struktura - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Typy - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Metoda - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Brakujący prefiks: „{0}” + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Błąd + + start of string only + start of string only - - None - Brak + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Brakujący sufiks: „{0}” + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Te wyrazy inne niż początkowe muszą rozpoczynać się wielką literą: {0} + + subexpression + subexpression - - Suggestion - Sugestia + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Te wyrazy inne niż początkowe muszą rozpoczynać się małą literą: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Te wyrazy nie mogą zawierać małych liter: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Te wyrazy nie mogą zawierać wielkich liter: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Te wyrazy muszą rozpoczynać się wielką literą: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - Pierwszy wyraz, „{0}”, musi rozpoczynać się wielką literą + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - Pierwszy wyraz, „{0}”, musi rozpoczynać się małą literą + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - Rozmiar pliku „{0}” wynoszący „{1}” przekracza maksymalny dozwolony rozmiar równy {2} + + unicode category + unicode category - - Changing document properties is not supported - Zmiana właściwości dokumentów nie jest obsługiwana + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + Symbol „{0}” nie pochodzi ze źródła. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + Identyfikator komentarza do dokumentacji musi rozpoczynać się od litery E, F, M, N, P lub T - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + W rozszerzeniach wykryto cykl - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + Typ docelowy musi być elementem {0}, ale podano element {1}. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + Typ docelowy musi być elementem {0} lub {1}, ale podano element {2}. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + Typ docelowy musi być elementem {0}, {1} lub {2}, ale podano element {3}. - - base-group - base-group + + Could not find location to generation symbol into. + Nie można znaleźć lokalizacji do wygenerowania symbolu. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Nie podano lokalizacji, do których można dodać instrukcje. - - bell character - bell character + + Destination location was not in source. + Lokalizacja docelowa nie znajdowała się w źródle. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + Lokalizacja docelowa pochodziła z innego drzewa. - - carriage-return character - carriage-return character + + Node is of the wrong type. + Węzeł ma nieprawidłowy typ. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + Lokalizacja musi mieć wartość null lub pochodzić ze źródła. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + Zduplikowany plik źródłowy „{0}” w projekcie „{1}” - - character-group - character-group + + Removing projects is not supported. + Usuwanie projektów nie jest obsługiwane. - - comment - comment + + Adding projects is not supported. + Dodawanie projektów nie jest obsługiwane. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + Obszar roboczy nie jest pusty. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + 'Element „{0}” nie jest częścią obszaru roboczego. - - control character - control character + + '{0}' is already part of the workspace. + 'Element „{0}” jest już częścią obszaru roboczego. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + 'Element „{0}” nie jest przywoływany. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + 'Element „{0}” jest już przywoływany. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + Dodanie odwołania do projektu z „{0}” do „{1}” spowoduje powstanie odwołania cyklicznego. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + Metadane nie są przywoływane. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Metadane są już przywoływane. - - end of string only - end of string only + + {0} is not present. + Element {0} nie istnieje. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + Element {0} już istnieje. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + Określony dokument nie jest wersją tego dokumentu. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + Język „{0}” nie jest obsługiwany. - - end of string or line - end of string or line + + The solution already contains the specified project. + To rozwiązanie zawiera już określony projekt. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + Rozwiązanie nie zawiera określonego projektu. - - escape character - escape character + + The project already references the target project. + Projekt już przywołuje projekt docelowy. - - excluded-group - excluded-group + + The project already transitively references the target project. + Już istnieje odwołanie przechodnie projektu do projektu docelowego. - - expression - expression + + The solution already contains the specified document. + Rozwiązanie już zawiera określony dokument. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + Rozwiązanie nie zawiera określonego dokumentu. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + W tymczasowym magazynie nie można zapisać więcej niż raz. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + 'Element „{0}” nie jest otwarty. - - group options - group options + + A language name cannot be specified for this option. + Nie można określić nazwy języka dla tej opcji. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Nazwa języka musi zostać określona dla tej opcji. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Plik został zmodyfikowany na zewnątrz: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Nierozpoznana nazwa języka. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Nie można rozwiązać odwołania do metadanych: „{0}”. - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Nie można rozpoznać odwołania do analizatora: „{0}”. - - inline options - inline options + + Invalid project block, expected "=" after Project. + Nieprawidłowy blok projektu, oczekiwano znaku „=” po elemencie Project. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Nieprawidłowy blok projektu, oczekiwano znaku „,” (przecinek) po nazwie projektu. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Nieprawidłowy blok projektu, oczekiwano znaku „,” (przecinek) po ścieżce projektu. - - letter, other - letter, other + + Expected {0}. + Oczekiwano elementu {0}. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + Element „{0}” musi być ciągiem, który nie ma wartości null i nie jest pusty. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + Oczekiwano nagłówka: „{0}”. - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Oczekiwano końca pliku. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + Oczekiwano wiersza {0}. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Ten przesłany element przywołuje już inny przesłany projekt. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + Element {0} nadal zawiera otwarte dokumenty. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + Element {0} jest nadal otwarty. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Element z tym samym kluczem, ale inną wartością, już istnieje. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Nie można przeprowadzić serializacji tablic z więcej niż jednym wymiarem. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Wartość jest zbyt duża, dlatego nie może być reprezentowana jako 30-bitowa liczba całkowita bez znaku. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Należy określić ścieżkę bezwzględną. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Rzutowanie jest zbędne. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Nazwa może zostać uproszczona. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Nieznany identyfikator. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Nie można wygenerować kodu dla nieobsługiwanego operatora „{0}” - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Nieprawidłowa liczba parametrów operatora binarnego. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Nieprawidłowa liczba parametrów operatora jednoargumentowego. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Oczekiwano ścieżki bezwzględnej. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Nie można otworzyć projektu „{0}”, ponieważ rozszerzenie pliku „{1}” nie jest skojarzone z językiem. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + Nie można otworzyć projektu „{0}”, ponieważ język „{1}” nie jest obsługiwany. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Nieprawidłowa ścieżka pliku projektu: „{0}” - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Nieprawidłowa ścieżka pliku rozwiązania: „{0}” - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Nie znaleziono pliku projektu: „{0}” - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Nie znaleziono pliku rozwiązania: „{0}” - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Niescalona zmiana z projektu „{0}” - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Dodano: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Napraw wszystkie wystąpienia elementu „{0}” - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Napraw wszystkie wystąpienia elementu „{0}” w zakresie „{1}” - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Napraw wszystkie wystąpienia elementu „{0}” w rozwiązaniu - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Po: - - matched subexpression - matched subexpression + + Before: + Przed: - - name - name + + Removed: + Usunięto: - - name1 - name1 + + Invalid CodePage value: {0} + Nieprawidłowa wartość strony kodowej: {0} - - name2 - name2 + + Adding additional documents is not supported. + Dodawanie kolejnych dokumentów nie jest obsługiwane. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + Dodawanie odwołań analizatora nie jest obsługiwane. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + Dodawanie dokumentów nie jest obsługiwane. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + Dodawanie odwołań metadanych nie jest obsługiwane. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + Dodawanie odwołań projektów nie jest obsługiwane. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + Modyfikowanie dodatkowych dokumentów nie jest obsługiwane. - - negative character group - negative character group + + Changing documents is not supported. + Modyfikowanie dokumentów nie jest obsługiwane. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + Modyfikowanie właściwości projektów nie jest obsługiwane. - - negative character range - negative character range + + Removing additional documents is not supported. + Usuwanie dodatkowych dokumentów nie jest obsługiwane. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + Usuwanie odwołań analizatora nie jest obsługiwane. - - negative unicode category - negative unicode category + + Removing documents is not supported. + Usuwanie dokumentów nie jest obsługiwane. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + Usuwanie odwołań metadanych nie jest obsługiwane. - - new-line character - new-line character + + Removing project references is not supported. + Usuwanie odwołań projektów nie jest obsługiwane. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + Usługa typu „{0}” jest wymagana do wykonania zadania, lecz nie jest dostępna w obszarze roboczym. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + Podane informacje diagnostyczne nie mogą mieć wartości null. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + Należy podać co najmniej jedną informację diagnostyczną. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + Informacje diagnostyczne muszą mieć zakres „{0}” - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + Nie można deserializować typu „{0}”. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + Nie można serializować typu „{0}”. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + Typ „{0}” nie jest zrozumiały dla integratora serializacji. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + Etykieta dla węzła „{0}” jest nieprawidłowa, musi być z zakresu [0, {1}). + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Zgodne węzły „{0}” i „{1}” muszą mieć taką samą etykietę. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Węzeł „{0}” musi być zawarty w nowym drzewie. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Węzeł „{0}” musi być zawarty w starym drzewie. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + Składowa „{0}” nie została zadeklarowana w obrębie deklaracji symbolu. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + Pozycja nie znajduje się w obrębie deklaracji symbolu - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + Symbol „{0}” nie może się znajdować w obrębie bieżącego rozwiązania. - - number, letter - number, letter + + Changing compilation options is not supported. + Zmiana opcji kompilacji nie jest obsługiwana. - - number, other - number, other + + Changing parse options is not supported. + Zmiana opcji analizy nie jest obsługiwana. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + Węzeł nie jest częścią drzewa. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Otwieranie i zamykanie dokumentów nie jest obsługiwane w tym obszarze roboczym. - - other, control - other, control + + Usage: + Użycie: - - other, format - other, format + + Exceptions: + Wyjątki: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + 'Element „{0}” zwrócił niezainicjowany element ImmutableArray - - other, private use - other, private use + + Failure + Błąd - - other, surrogate - other, surrogate + + Warning + Ostrzeżenie - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Wypełnij instrukcję switch - - positive character group - positive character group + + Member access should be qualified. + Dostęp do składowej powinien mieć kwalifikator. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Dodaj nawiasy klamrowe do instrukcji „{0}”. - - positive character range - positive character range + + Options did not come from Workspace + Opcje nie pochodziły z obszaru roboczego - - punctuation, close - punctuation, close + + Enable + Włącz - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Włącz i ignoruj przyszłe błędy - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + 'Element „{0}” napotkał błąd i został wyłączony. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Pokaż ślad stosu - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Strumień jest za długi. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + Czytnik deserializacji dla elementu „{0}” odczytuje nieprawidłową liczbę wartości. - - punctuation, other - punctuation, other + + Pascal Case + PascalCase - - separator, line - separator, line - + + Abstract Method + Metoda abstrakcyjna + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Metoda asynchroniczna + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Rozpoczyna się znakiem I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Klasa + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Delegat + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Wyliczenie + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Zdarzenie + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Interfejs + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Składowe inne niż pola + {locked:field} - - symbol, math - symbol, math - + + Private Method + Metoda prywatna + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Pole prywatne lub wewnętrzne + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Prywatne lub wewnętrzne pole statyczne + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Właściwość + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Pole publiczne lub chronione + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Pole statyczne + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Metoda statyczna + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Struktura + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Typy + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Metoda + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Brakujący prefiks: „{0}” - - vertical-tab character - vertical-tab character + + Error + Błąd - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Brak - - white-space character - white-space character + + Missing suffix: '{0}' + Brakujący sufiks: „{0}” - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Te wyrazy inne niż początkowe muszą rozpoczynać się wielką literą: {0} - - word boundary - word boundary + + Suggestion + Sugestia - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Te wyrazy inne niż początkowe muszą rozpoczynać się małą literą: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Te wyrazy nie mogą zawierać małych liter: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Te wyrazy nie mogą zawierać wielkich liter: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Te wyrazy muszą rozpoczynać się wielką literą: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + Pierwszy wyraz, „{0}”, musi rozpoczynać się wielką literą - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + Pierwszy wyraz, „{0}”, musi rozpoczynać się małą literą - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + Rozmiar pliku „{0}” wynoszący „{1}” przekracza maksymalny dozwolony rozmiar równy {2} - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + Zmiana właściwości dokumentów nie jest obsługiwana - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pt-BR.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pt-BR.xlf index 0ff7854ba2d..e5ee7c5d25d 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pt-BR.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.pt-BR.xlf @@ -72,2094 +72,2094 @@ Somente Refatoração - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - Símbolo "{0}" não é da fonte. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - Identificação do comentário de documentação deve começar com E, F, M, N, P ou T + + all control characters + all control characters - - Cycle detected in extensions - Ciclo detectado em extensões + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - O tipo de destino deve ser um {0}, mas o tipo fornecido é {1}. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - O tipo de destino deve ser um {0} ou um {1}, mas o tipo fornecido é {2}. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - O tipo de destino deve ser um {0}, {1} ou {2}, mas o tipo fornecido é {3}. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - Não foi possível encontrar o local para o símbolo de geração. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Nenhum local fornecido para o qual adicionar instruções. + + all numbers + all numbers - - Destination location was not in source. - Local de destino não estava na origem. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - Local de destino era de uma árvore diferente. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - O nó é do tipo errado. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - Local deve ser nulo ou da fonte. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - Arquivo de origem duplicado "{0}" no projeto "{1}" + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - Não há suporte para remover projetos. + + all symbols + all symbols - - Adding projects is not supported. - Não há suporte para adicionar projetos. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - Workspace não está vazio. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '"{0}" não é parte do workspace. + + balancing group + balancing group - - '{0}' is already part of the workspace. - '"{0}" já é parte do workspace. + + base-group + base-group - - '{0}' is not referenced. - '"{0}" não é referenciado. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '"{0}" já está referenciado. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - Adicionar referência de projeto de "{0}" para "{1}" causará uma referência circular. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - Metadados não estão referenciados. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Metadados já estão referenciados. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} não está presente. + + character class subtraction + character class subtraction - - {0} is already present. - {0} já está presente. + + character-group + character-group - - The specified document is not a version of this document. - O documento especificado não é uma versão deste documento. + + comment + comment - - The language '{0}' is not supported. - O idioma "{0}" não é suportado. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - A solução já contém o projeto especificado. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - A solução não contém o projeto especificado. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - O projeto já referencia o projeto de destino. + + conditional group match + conditional group match - - The project already transitively references the target project. - O projeto já referencia transitivamente o projeto de destino. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - A solução já contém o documento especificado. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - A solução não contém o documento especificado. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - Armazenamento temporário não pode ser gravado mais de uma vez. + + control character + control character - - '{0}' is not open. - '"{0}" não está aberto. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Um nome de idioma não pode ser especificado para essa opção. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Um nome de idioma deve ser especificado para esta opção. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Arquivo foi modificado externamente: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Nome de idioma não reconhecido. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Não é possível resolver a referência de metadados: "{0}". + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Não é possível resolver a referência do analisador: "{0}". + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Bloco de projetos inválido, esperado "=" após Projeto. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Bloco de projetos inválido, esperado "," após nome do projeto. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Bloco de projetos inválido, esperado "," após caminho do projeto. + + end of string or line + end of string or line - - Expected {0}. - Esperado {0}. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" deve ser uma cadeia de caracteres não nula e não vazia. + + escape character + escape character - - Expected header: "{0}". - Cabeçalho esperado: "{0}". + + excluded-group + excluded-group - - Expected end-of-file. - Fim de arquivo esperado. + + expression + expression - - Expected {0} line. - Linha {0} esperada. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Este envio já faz referência a outro projeto de envio. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} ainda contém documentos abertos. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} ainda está aberto. + + group options + group options - - An element with the same key but a different value already exists. - Um elemento com a mesma chave, mas um valor diferente já existe. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - As matrizes com mais de uma dimensão não podem ser serializadas. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Valor muito grande para ser representado como um inteiro não assinado de 30 bits. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Caminho especificado deve ser absoluto. + + inline comment + inline comment - - Cast is redundant. - Conversão é redundante. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Nome pode ser simplificado. + + inline options + inline options - - Unknown identifier. - Identificador desconhecido. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Não é possível gerar código para operador não suportado "{0}" + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Número inválido de parâmetros para o operador binário. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Número inválido de parâmetros para o operador unário. + + letter, titlecase + letter, titlecase - - Absolute path expected. - Caminho absoluto esperado. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Não é possível abrir o projeto "{0}" porque a extensão de arquivo "{1}" não está associada a um idioma. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - Não é possível abrir o projeto "{0}" porque o idioma "{1}" não é suportado. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Caminho do arquivo de projeto inválido: "{0}" + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Caminho do arquivo de solução inválido: "{0}" + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Arquivo de projeto não encontrado: "{0}" + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Arquivo de solução não encontrado: "{0}" + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Alteração não mesclada do projeto '{0}' + + match at least 'n' times + match at least 'n' times - - Added: - Adicionado: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Corrigir todos os '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Corrigir todos os '{0}' em '{1}' + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Corrigir todos os '{0}' na Solução + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Após: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Antes: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Removido: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Valor CodePage inválido: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - Não há suporte para a adição de documentos adicionais. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - Não há suporte para a adição de referências do analisador. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - Não há suporte para a adição de documentos. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - Não há suporte para a adição de referências de metadados. + + match one or more times + match one or more times - - Adding project references is not supported. - Não há suporte para a adição de referências de projeto. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - Não há suporte para a alteração de documentos adicionais. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - Não há suporte para a alteração de documentos. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - Não há suporte para a alteração de propriedades do projeto. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - Não há suporte para a remoção de documentos adicionais. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - Não há suporte para a remoção de referências do analisador. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - Não há suporte para a remoção de documentos. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - Não há suporte para a remoção de referências de metadado. + + match zero or one time + match zero or one time - - Removing project references is not supported. - Não há suporte para a remoção de referências do projeto. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - O serviço do tipo '{0}' é necessário para realizar a tarefa, mas não está disponível no workspace. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - O diagnóstico fornecido não pode ser nulo. + + name + name - - At least one diagnostic must be supplied. - No mínimo um diagnóstico deve ser fornecido. + + name1 + name1 - - Diagnostic must have span '{0}' - O diagnóstico deve ter a extensão '{0}' + + name2 + name2 - - Cannot deserialize type '{0}'. - Não é possível desserializar o tipo '{0}'. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - Não é possível serializar o tipo '{0}'. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - O tipo '{0}' não é compreendido pelo associador de serialização. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - O rótulo do nó '{0}' é inválido, ele deve estar contido em [0, {1}). + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Os nós correspondentes '{0}' e '{1}' devem ter o mesmo rótulo. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - O nó '{0}' deve estar contido na nova árvore. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - O nó '{0}' deve estar contido na árvore antiga. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - O membro '{0}' não está declarado da declaração do símbolo. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - A posição não está na declaração do símbolo + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - O símbolo '{0}' não pode ser localizado na solução atual. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - Não há suporte para a alteração de opções de compilação. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - Não há suporte para a alteração de opções de análise. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - O nó não faz parte da árvore. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Este workspace não dá suporte para abrir e fechar documentos. + + no + no - - Usage: - Uso: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Exceções: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0}' retornou uma instância não inicializada de ImmutableArray + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Falha + + non-white-space character + non-white-space character - - Warning - Aviso + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Popular comutador + + non-word boundary + non-word boundary - - Member access should be qualified. - O acesso de membro deve ser qualificado. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Adicionar chaves à instrução '{0}'. + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - As opções não vieram do Workspace + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Habilitar + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Habilitar e ignorar erros futuros + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '{0}' encontrou um erro e foi desabilitado. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Mostrar o Rastreamento de Pilha + + number, letter + number, letter - - Stream is too long. - O fluxo é muito longo. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - O leitor de desserialização para '{0}' lê o número incorreto de valores. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - Pascal Case + + numbered backreference + numbered backreference - - Abstract Method - Método Abstract - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Método Assíncrono - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Começa com I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Classe - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Delegado - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Enumeração - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Evento - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Interface - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Membros Sem Campo - {locked:field} + + positive character range + positive character range + - - Private Method - Método Privado - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Campo Privado ou Interno - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Campo Privado ou Estático Interno - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Propriedade - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Campo Protegido ou Público - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Campo Estático - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Método Estático - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Struct - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Tipos - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Método - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Prefixo ausente: '{0}' + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Erro + + start of string only + start of string only - - None - Nenhum + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Sufixo ausente: '{0}' + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Essas palavras não iniciais devem começar com uma letra maiúscula: {0} + + subexpression + subexpression - - Suggestion - Sugestão + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Essas palavras não iniciais devem começar com uma letra minúscula: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Essas palavras não podem conter caracteres minúsculos: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Essas palavras não podem conter caracteres maiúsculos: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Essas palavras devem começar com caracteres maiúsculos: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - A primeira palavra, '{0}', deve começar com um caractere maiúsculo + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - A primeira palavra, '{0}', deve começar com um caractere minúsculo + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - O tamanho de arquivo '{0}' de {1} excede o tamanho máximo permitido de {2} + + unicode category + unicode category - - Changing document properties is not supported - Não há suporte para alterar as propriedades do documento + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + Símbolo "{0}" não é da fonte. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + Identificação do comentário de documentação deve começar com E, F, M, N, P ou T - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + Ciclo detectado em extensões - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + O tipo de destino deve ser um {0}, mas o tipo fornecido é {1}. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + O tipo de destino deve ser um {0} ou um {1}, mas o tipo fornecido é {2}. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + O tipo de destino deve ser um {0}, {1} ou {2}, mas o tipo fornecido é {3}. - - base-group - base-group + + Could not find location to generation symbol into. + Não foi possível encontrar o local para o símbolo de geração. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Nenhum local fornecido para o qual adicionar instruções. - - bell character - bell character + + Destination location was not in source. + Local de destino não estava na origem. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + Local de destino era de uma árvore diferente. - - carriage-return character - carriage-return character + + Node is of the wrong type. + O nó é do tipo errado. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + Local deve ser nulo ou da fonte. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + Arquivo de origem duplicado "{0}" no projeto "{1}" - - character-group - character-group + + Removing projects is not supported. + Não há suporte para remover projetos. - - comment - comment + + Adding projects is not supported. + Não há suporte para adicionar projetos. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + Workspace não está vazio. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '"{0}" não é parte do workspace. - - control character - control character + + '{0}' is already part of the workspace. + '"{0}" já é parte do workspace. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '"{0}" não é referenciado. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '"{0}" já está referenciado. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + Adicionar referência de projeto de "{0}" para "{1}" causará uma referência circular. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + Metadados não estão referenciados. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Metadados já estão referenciados. - - end of string only - end of string only + + {0} is not present. + {0} não está presente. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} já está presente. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + O documento especificado não é uma versão deste documento. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + O idioma "{0}" não é suportado. - - end of string or line - end of string or line + + The solution already contains the specified project. + A solução já contém o projeto especificado. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + A solução não contém o projeto especificado. - - escape character - escape character + + The project already references the target project. + O projeto já referencia o projeto de destino. - - excluded-group - excluded-group + + The project already transitively references the target project. + O projeto já referencia transitivamente o projeto de destino. - - expression - expression + + The solution already contains the specified document. + A solução já contém o documento especificado. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + A solução não contém o documento especificado. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + Armazenamento temporário não pode ser gravado mais de uma vez. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '"{0}" não está aberto. - - group options - group options + + A language name cannot be specified for this option. + Um nome de idioma não pode ser especificado para essa opção. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Um nome de idioma deve ser especificado para esta opção. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Arquivo foi modificado externamente: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Nome de idioma não reconhecido. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Não é possível resolver a referência de metadados: "{0}". - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Não é possível resolver a referência do analisador: "{0}". - - inline options - inline options + + Invalid project block, expected "=" after Project. + Bloco de projetos inválido, esperado "=" após Projeto. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Bloco de projetos inválido, esperado "," após nome do projeto. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Bloco de projetos inválido, esperado "," após caminho do projeto. - - letter, other - letter, other + + Expected {0}. + Esperado {0}. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" deve ser uma cadeia de caracteres não nula e não vazia. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + Cabeçalho esperado: "{0}". - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Fim de arquivo esperado. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + Linha {0} esperada. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Este envio já faz referência a outro projeto de envio. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} ainda contém documentos abertos. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} ainda está aberto. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Um elemento com a mesma chave, mas um valor diferente já existe. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + As matrizes com mais de uma dimensão não podem ser serializadas. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Valor muito grande para ser representado como um inteiro não assinado de 30 bits. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Caminho especificado deve ser absoluto. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Conversão é redundante. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Nome pode ser simplificado. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Identificador desconhecido. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Não é possível gerar código para operador não suportado "{0}" - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Número inválido de parâmetros para o operador binário. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Número inválido de parâmetros para o operador unário. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Caminho absoluto esperado. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Não é possível abrir o projeto "{0}" porque a extensão de arquivo "{1}" não está associada a um idioma. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + Não é possível abrir o projeto "{0}" porque o idioma "{1}" não é suportado. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Caminho do arquivo de projeto inválido: "{0}" - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Caminho do arquivo de solução inválido: "{0}" - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Arquivo de projeto não encontrado: "{0}" - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Arquivo de solução não encontrado: "{0}" - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Alteração não mesclada do projeto '{0}' - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Adicionado: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Corrigir todos os '{0}' - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Corrigir todos os '{0}' em '{1}' - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Corrigir todos os '{0}' na Solução - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Após: - - matched subexpression - matched subexpression + + Before: + Antes: - - name - name + + Removed: + Removido: - - name1 - name1 + + Invalid CodePage value: {0} + Valor CodePage inválido: {0} - - name2 - name2 + + Adding additional documents is not supported. + Não há suporte para a adição de documentos adicionais. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + Não há suporte para a adição de referências do analisador. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + Não há suporte para a adição de documentos. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + Não há suporte para a adição de referências de metadados. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + Não há suporte para a adição de referências de projeto. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + Não há suporte para a alteração de documentos adicionais. - - negative character group - negative character group + + Changing documents is not supported. + Não há suporte para a alteração de documentos. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + Não há suporte para a alteração de propriedades do projeto. - - negative character range - negative character range + + Removing additional documents is not supported. + Não há suporte para a remoção de documentos adicionais. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + Não há suporte para a remoção de referências do analisador. - - negative unicode category - negative unicode category + + Removing documents is not supported. + Não há suporte para a remoção de documentos. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + Não há suporte para a remoção de referências de metadado. - - new-line character - new-line character + + Removing project references is not supported. + Não há suporte para a remoção de referências do projeto. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + O serviço do tipo '{0}' é necessário para realizar a tarefa, mas não está disponível no workspace. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + O diagnóstico fornecido não pode ser nulo. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + No mínimo um diagnóstico deve ser fornecido. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + O diagnóstico deve ter a extensão '{0}' - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + Não é possível desserializar o tipo '{0}'. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + Não é possível serializar o tipo '{0}'. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + O tipo '{0}' não é compreendido pelo associador de serialização. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + O rótulo do nó '{0}' é inválido, ele deve estar contido em [0, {1}). + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Os nós correspondentes '{0}' e '{1}' devem ter o mesmo rótulo. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + O nó '{0}' deve estar contido na nova árvore. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + O nó '{0}' deve estar contido na árvore antiga. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + O membro '{0}' não está declarado da declaração do símbolo. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + A posição não está na declaração do símbolo - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + O símbolo '{0}' não pode ser localizado na solução atual. - - number, letter - number, letter + + Changing compilation options is not supported. + Não há suporte para a alteração de opções de compilação. - - number, other - number, other + + Changing parse options is not supported. + Não há suporte para a alteração de opções de análise. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + O nó não faz parte da árvore. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Este workspace não dá suporte para abrir e fechar documentos. - - other, control - other, control + + Usage: + Uso: - - other, format - other, format + + Exceptions: + Exceções: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0}' retornou uma instância não inicializada de ImmutableArray - - other, private use - other, private use + + Failure + Falha - - other, surrogate - other, surrogate + + Warning + Aviso - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Popular comutador - - positive character group - positive character group + + Member access should be qualified. + O acesso de membro deve ser qualificado. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Adicionar chaves à instrução '{0}'. - - positive character range - positive character range + + Options did not come from Workspace + As opções não vieram do Workspace - - punctuation, close - punctuation, close + + Enable + Habilitar - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Habilitar e ignorar erros futuros - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '{0}' encontrou um erro e foi desabilitado. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Mostrar o Rastreamento de Pilha - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + O fluxo é muito longo. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + O leitor de desserialização para '{0}' lê o número incorreto de valores. - - punctuation, other - punctuation, other + + Pascal Case + Pascal Case - - separator, line - separator, line - + + Abstract Method + Método Abstract + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Método Assíncrono + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Começa com I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Classe + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Delegado + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Enumeração + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Evento + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Interface + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Membros Sem Campo + {locked:field} - - symbol, math - symbol, math - + + Private Method + Método Privado + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Campo Privado ou Interno + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Campo Privado ou Estático Interno + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Propriedade + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Campo Protegido ou Público + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Campo Estático + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Método Estático + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Struct + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Tipos + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Método + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Prefixo ausente: '{0}' - - vertical-tab character - vertical-tab character + + Error + Erro - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Nenhum - - white-space character - white-space character + + Missing suffix: '{0}' + Sufixo ausente: '{0}' - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Essas palavras não iniciais devem começar com uma letra maiúscula: {0} - - word boundary - word boundary + + Suggestion + Sugestão - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Essas palavras não iniciais devem começar com uma letra minúscula: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Essas palavras não podem conter caracteres minúsculos: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Essas palavras não podem conter caracteres maiúsculos: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Essas palavras devem começar com caracteres maiúsculos: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + A primeira palavra, '{0}', deve começar com um caractere maiúsculo - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + A primeira palavra, '{0}', deve começar com um caractere minúsculo - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + O tamanho de arquivo '{0}' de {1} excede o tamanho máximo permitido de {2} - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + Não há suporte para alterar as propriedades do documento - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ru.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ru.xlf index b213fbf0ef9..56a6a2a4ffa 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ru.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.ru.xlf @@ -72,2094 +72,2094 @@ Только рефакторинг - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - Символ "{0}" не из источника. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - Идентификатор комментария документа должен начинаться с E, F, M, N, P или T + + all control characters + all control characters - - Cycle detected in extensions - В выражениях обнаружен цикл + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - Конечный тип должен быть {0}, но указан {1}. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - Конечный тип должен быть {0} или {1}, но указан {2}. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - Конечный тип должен быть {0}, {1} или {2}, но указан {3}. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - Не удалось найти расположение для создания символа. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Для добавления операторов не было указано расположение. + + all numbers + all numbers - - Destination location was not in source. - Целевое расположение не найдено в источнике. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - Целевое расположение находилось в другом дереве. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Узел имеет неверный тип. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - Расположение должно иметь значение Null или источника. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - Дублирование исходного файла "{0}" в проекте "{1}" + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - Удаление проектов не поддерживается. + + all symbols + all symbols - - Adding projects is not supported. - Добавление проектов не поддерживается. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - Рабочая область не пуста. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '"{0}" не является частью рабочей области. + + balancing group + balancing group - - '{0}' is already part of the workspace. - '"{0}" уже является частью рабочей области. + + base-group + base-group - - '{0}' is not referenced. - '"{0}" не объявлен. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '"{0}" уже объявлен. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - Добавление ссылки на проект с "{0}" в "{1}" может создать циклическую зависимость. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - Метаданные не указаны. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Метаданные уже указаны. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} отсутствует. + + character class subtraction + character class subtraction - - {0} is already present. - {0} уже присутствует. + + character-group + character-group - - The specified document is not a version of this document. - Указанный документ не является версией этого документа. + + comment + comment - - The language '{0}' is not supported. - Язык "{0}" не поддерживается. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - Указанный проект уже находится в решении. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - Указанный проект отсутствует в решении. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - Проект уже ссылается на целевой проект. + + conditional group match + conditional group match - - The project already transitively references the target project. - Проект уже транзитивно ссылается на целевой проект. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - Указанный документ уже находится в решении. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - Указанный документ отсутствует в решении. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - Невозможно записать более одного раза во временное хранилище. + + control character + control character - - '{0}' is not open. - '"{0}" не открыт. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Для данного параметра невозможно указать имя языка. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Для данного параметра необходимо указать имя языка. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Файл был изменен извне: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Нераспознанное имя языка. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Не удается разрешить ссылку на метаданные: "{0}". + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Не удается разрешить ссылку анализатора: "{0}". + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Недопустимый блок проекта, ожидается "=" после указания проекта. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Недопустимый блок проекта, ожидается "," после указания имени проекта. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Недопустимый блок проекта, ожидается "," после указания пути к проекту. + + end of string or line + end of string or line - - Expected {0}. - Требуется {0}. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" не должен равняться Null и пустой строке. + + escape character + escape character - - Expected header: "{0}". - Требуется заголовок: "{0}". + + excluded-group + excluded-group - - Expected end-of-file. - Требуется признак конца файла + + expression + expression - - Expected {0} line. - Требуется {0} строка. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Отправка уже ссылается на другой проект отправки. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} еще содержит открытые документы. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} все еще открыт. + + group options + group options - - An element with the same key but a different value already exists. - Элемент с таким ключом, но другим значением уже существует. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Массивы с несколькими измерениями нельзя сериализовать. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Слишком большое значение для представления в виде 30-разрядного целого числа без знака. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Указанный путь должен быть абсолютным. + + inline comment + inline comment - - Cast is redundant. - Приведение избыточно. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Имя может быть упрощено. + + inline options + inline options - - Unknown identifier. - Неизвестный идентификатор. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Невозможно сформировать код для неподдерживаемого оператора "{0}" + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - Недопустимое число параметров для бинарного оператора. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Недопустимое число параметров для унарного оператора. + + letter, titlecase + letter, titlecase - - Absolute path expected. - Ожидался абсолютный путь. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Не удается открыть проект "{0}", так как расширение файла "{1}" не связано с языком. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - Не удается открыть проект "{0}", так как не поддерживается язык "{1}". + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Недействительный путь файла проекта: "{0}" + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Недействительный путь файла решения: '{0}' + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Не удалось найти файл проекта: "{0}" + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Не удалось найти файл решения: "{0}" + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - Необъединенное слияние из проекта "{0}" + + match at least 'n' times + match at least 'n' times - - Added: - Добавлены: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Исправить все "{0}" + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - Исправить все "{0}" в "{1}" + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Исправить все "{0}" в решении + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - После: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - До: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Удалено: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Недопустимое значение CodePage: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - Добавление дополнительных документов не поддерживается. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - Добавление ссылок на анализаторы не поддерживается. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - Добавление документов не поддерживается. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - Добавление ссылок на метаданные не поддерживается. + + match one or more times + match one or more times - - Adding project references is not supported. - Добавление ссылок на проекты не поддерживается. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - Изменение дополнительных документов не поддерживается. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - Изменение документов не поддерживается. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - Изменение свойств проекта не поддерживается. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - Удаление дополнительных документов не поддерживается. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - Удаление ссылок на анализаторы не поддерживается. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - Удаление документов не поддерживается. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - Удаление ссылок на метаданные не поддерживается. + + match zero or one time + match zero or one time - - Removing project references is not supported. - Удаление ссылок на проекты не поддерживается. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - Служба типа "{0}" необходима для выполнения задачи, но она недоступна из рабочей области. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - Указанная диагностика не может быть NULL. + + name + name - - At least one diagnostic must be supplied. - Необходимо указать по крайней мере одну диагностику. + + name1 + name1 - - Diagnostic must have span '{0}' - Диагностика должна находиться в диапазоне "{0}" + + name2 + name2 - - Cannot deserialize type '{0}'. - Невозможно десериализовать тип "{0}". + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - Невозможно сериализовать тип "{0}". + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - Тип "{0}" не распознан модулем привязки сериализации. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - Метка для узла "{0}" недопустима; она должна находиться в диапазоне [0, {1}). + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Совпадающие узлы "{0}" и "{1}" должны иметь одну метку. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Узел "{0}" должен быть включен в новое дерево. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Узел "{0}" должен быть включен в старое дерево. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - Член "{0}" не объявляется в рамках объявления символа. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - Позиция находится за пределами объявления символа + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - Невозможно найти символ "{0}" в существующем решении. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - Изменение параметров компиляции не поддерживается. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - Изменение параметров анализатора не поддерживается. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - Этот узел не является частью дерева. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Эта рабочая область не поддерживает открытие и закрытие документов. + + no + no - - Usage: - Использование: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Исключения: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '"{0}" возвратил неинициализированный ImmutableArray + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Сбой + + non-white-space character + non-white-space character - - Warning - Предупреждение + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - Заполнить оператор switch + + non-word boundary + non-word boundary - - Member access should be qualified. - Доступ к члену должен быть квалифицирован. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - Добавить фигурные скобки в оператор "{0}". + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Параметры получены не из рабочей области + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Включить + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Включить и пропускать будущие ошибки + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - 'Произошла ошибка, и анализатор "{0}" отключен. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Показать трассировку стека + + number, letter + number, letter - - Stream is too long. - Слишком длинный поток. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - Считыватель десериализации для "{0}" считал неверное количество значений. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - ВсеЧастиСПрописнойБуквы + + numbered backreference + numbered backreference - - Abstract Method - Абстрактный метод - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Асинхронный метод - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - Начинается с I - {locked:I} + + other, not assigned + other, not assigned + - - Class - Класс - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Делегат - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Перечисление - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Событие - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Интерфейс - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Не являющиеся полем члены - {locked:field} + + positive character range + positive character range + - - Private Method - Частный метод - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Частное или внутреннее поле - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Частное или внутреннее статическое поле - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Свойство - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Открытое или защищенное поле - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Статическое поле - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Статический метод - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Структура - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Типы - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Метод - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Отсутствует префикс: "{0}" + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Ошибка + + start of string only + start of string only - - None - Нет + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Отсутствует суффикс: "{0}" + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Эти неначальные слова должны начинаться с прописных символов: {0} + + subexpression + subexpression - - Suggestion - Рекомендация + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Эти неначальные слова должны начинаться со строчных символов: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Эти слова не могут содержать строчные символы: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Эти слова не могут содержать прописные символы: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Эти слова должны начинаться с прописных символов: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - Первое слово ("{0}") должно начинаться с прописного символа + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - Первое слово ("{0}") должно начинаться со строчного символа + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - Файл "{0}" размером {1} больше предела в {2}. + + unicode category + unicode category - - Changing document properties is not supported - Изменение свойств документа не поддерживается + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + Символ "{0}" не из источника. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + Идентификатор комментария документа должен начинаться с E, F, M, N, P или T - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + В выражениях обнаружен цикл - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + Конечный тип должен быть {0}, но указан {1}. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + Конечный тип должен быть {0} или {1}, но указан {2}. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + Конечный тип должен быть {0}, {1} или {2}, но указан {3}. - - base-group - base-group + + Could not find location to generation symbol into. + Не удалось найти расположение для создания символа. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Для добавления операторов не было указано расположение. - - bell character - bell character + + Destination location was not in source. + Целевое расположение не найдено в источнике. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + Целевое расположение находилось в другом дереве. - - carriage-return character - carriage-return character + + Node is of the wrong type. + Узел имеет неверный тип. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + Расположение должно иметь значение Null или источника. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + Дублирование исходного файла "{0}" в проекте "{1}" - - character-group - character-group + + Removing projects is not supported. + Удаление проектов не поддерживается. - - comment - comment + + Adding projects is not supported. + Добавление проектов не поддерживается. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + Рабочая область не пуста. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '"{0}" не является частью рабочей области. - - control character - control character + + '{0}' is already part of the workspace. + '"{0}" уже является частью рабочей области. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '"{0}" не объявлен. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '"{0}" уже объявлен. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + Добавление ссылки на проект с "{0}" в "{1}" может создать циклическую зависимость. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + Метаданные не указаны. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Метаданные уже указаны. - - end of string only - end of string only + + {0} is not present. + {0} отсутствует. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} уже присутствует. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + Указанный документ не является версией этого документа. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + Язык "{0}" не поддерживается. - - end of string or line - end of string or line + + The solution already contains the specified project. + Указанный проект уже находится в решении. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + Указанный проект отсутствует в решении. - - escape character - escape character + + The project already references the target project. + Проект уже ссылается на целевой проект. - - excluded-group - excluded-group + + The project already transitively references the target project. + Проект уже транзитивно ссылается на целевой проект. - - expression - expression + + The solution already contains the specified document. + Указанный документ уже находится в решении. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + Указанный документ отсутствует в решении. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + Невозможно записать более одного раза во временное хранилище. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '"{0}" не открыт. - - group options - group options + + A language name cannot be specified for this option. + Для данного параметра невозможно указать имя языка. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Для данного параметра необходимо указать имя языка. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Файл был изменен извне: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Нераспознанное имя языка. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Не удается разрешить ссылку на метаданные: "{0}". - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Не удается разрешить ссылку анализатора: "{0}". - - inline options - inline options + + Invalid project block, expected "=" after Project. + Недопустимый блок проекта, ожидается "=" после указания проекта. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Недопустимый блок проекта, ожидается "," после указания имени проекта. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Недопустимый блок проекта, ожидается "," после указания пути к проекту. - - letter, other - letter, other + + Expected {0}. + Требуется {0}. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" не должен равняться Null и пустой строке. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + Требуется заголовок: "{0}". - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Требуется признак конца файла - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + Требуется {0} строка. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Отправка уже ссылается на другой проект отправки. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} еще содержит открытые документы. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} все еще открыт. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Элемент с таким ключом, но другим значением уже существует. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Массивы с несколькими измерениями нельзя сериализовать. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Слишком большое значение для представления в виде 30-разрядного целого числа без знака. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Указанный путь должен быть абсолютным. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Приведение избыточно. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Имя может быть упрощено. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Неизвестный идентификатор. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Невозможно сформировать код для неподдерживаемого оператора "{0}" - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + Недопустимое число параметров для бинарного оператора. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Недопустимое число параметров для унарного оператора. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Ожидался абсолютный путь. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Не удается открыть проект "{0}", так как расширение файла "{1}" не связано с языком. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + Не удается открыть проект "{0}", так как не поддерживается язык "{1}". - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Недействительный путь файла проекта: "{0}" - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Недействительный путь файла решения: '{0}' - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Не удалось найти файл проекта: "{0}" - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Не удалось найти файл решения: "{0}" - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + Необъединенное слияние из проекта "{0}" - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Добавлены: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Исправить все "{0}" - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + Исправить все "{0}" в "{1}" - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Исправить все "{0}" в решении - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + После: - - matched subexpression - matched subexpression + + Before: + До: - - name - name + + Removed: + Удалено: - - name1 - name1 + + Invalid CodePage value: {0} + Недопустимое значение CodePage: {0} - - name2 - name2 + + Adding additional documents is not supported. + Добавление дополнительных документов не поддерживается. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + Добавление ссылок на анализаторы не поддерживается. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + Добавление документов не поддерживается. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + Добавление ссылок на метаданные не поддерживается. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + Добавление ссылок на проекты не поддерживается. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + Изменение дополнительных документов не поддерживается. - - negative character group - negative character group + + Changing documents is not supported. + Изменение документов не поддерживается. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + Изменение свойств проекта не поддерживается. - - negative character range - negative character range + + Removing additional documents is not supported. + Удаление дополнительных документов не поддерживается. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + Удаление ссылок на анализаторы не поддерживается. - - negative unicode category - negative unicode category + + Removing documents is not supported. + Удаление документов не поддерживается. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + Удаление ссылок на метаданные не поддерживается. - - new-line character - new-line character + + Removing project references is not supported. + Удаление ссылок на проекты не поддерживается. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + Служба типа "{0}" необходима для выполнения задачи, но она недоступна из рабочей области. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + Указанная диагностика не может быть NULL. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + Необходимо указать по крайней мере одну диагностику. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + Диагностика должна находиться в диапазоне "{0}" - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + Невозможно десериализовать тип "{0}". - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + Невозможно сериализовать тип "{0}". - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + Тип "{0}" не распознан модулем привязки сериализации. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + Метка для узла "{0}" недопустима; она должна находиться в диапазоне [0, {1}). + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Совпадающие узлы "{0}" и "{1}" должны иметь одну метку. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Узел "{0}" должен быть включен в новое дерево. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Узел "{0}" должен быть включен в старое дерево. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + Член "{0}" не объявляется в рамках объявления символа. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + Позиция находится за пределами объявления символа - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + Невозможно найти символ "{0}" в существующем решении. - - number, letter - number, letter + + Changing compilation options is not supported. + Изменение параметров компиляции не поддерживается. - - number, other - number, other + + Changing parse options is not supported. + Изменение параметров анализатора не поддерживается. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + Этот узел не является частью дерева. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Эта рабочая область не поддерживает открытие и закрытие документов. - - other, control - other, control + + Usage: + Использование: - - other, format - other, format + + Exceptions: + Исключения: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '"{0}" возвратил неинициализированный ImmutableArray - - other, private use - other, private use + + Failure + Сбой - - other, surrogate - other, surrogate + + Warning + Предупреждение - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + Заполнить оператор switch - - positive character group - positive character group + + Member access should be qualified. + Доступ к члену должен быть квалифицирован. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + Добавить фигурные скобки в оператор "{0}". - - positive character range - positive character range + + Options did not come from Workspace + Параметры получены не из рабочей области - - punctuation, close - punctuation, close + + Enable + Включить - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Включить и пропускать будущие ошибки - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + 'Произошла ошибка, и анализатор "{0}" отключен. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Показать трассировку стека - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Слишком длинный поток. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + Считыватель десериализации для "{0}" считал неверное количество значений. - - punctuation, other - punctuation, other + + Pascal Case + ВсеЧастиСПрописнойБуквы - - separator, line - separator, line - + + Abstract Method + Абстрактный метод + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Асинхронный метод + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + Начинается с I + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Класс + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Делегат + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Перечисление + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Событие + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Интерфейс + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Не являющиеся полем члены + {locked:field} - - symbol, math - symbol, math - + + Private Method + Частный метод + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Частное или внутреннее поле + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Частное или внутреннее статическое поле + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Свойство + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Открытое или защищенное поле + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Статическое поле + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Статический метод + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Структура + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Типы + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Метод + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Отсутствует префикс: "{0}" - - vertical-tab character - vertical-tab character + + Error + Ошибка - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Нет - - white-space character - white-space character + + Missing suffix: '{0}' + Отсутствует суффикс: "{0}" - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Эти неначальные слова должны начинаться с прописных символов: {0} - - word boundary - word boundary + + Suggestion + Рекомендация - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Эти неначальные слова должны начинаться со строчных символов: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Эти слова не могут содержать строчные символы: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Эти слова не могут содержать прописные символы: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Эти слова должны начинаться с прописных символов: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + Первое слово ("{0}") должно начинаться с прописного символа - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + Первое слово ("{0}") должно начинаться со строчного символа - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + Файл "{0}" размером {1} больше предела в {2}. - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + Изменение свойств документа не поддерживается - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.tr.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.tr.xlf index 89168959d86..bb70134caeb 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.tr.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.tr.xlf @@ -72,2094 +72,2094 @@ Sadece Yeniden Düzenlenme - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - "{0}" sembolü kaynağa ait değil. + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - Belge açıklaması kimliği E, F, M, N, P veya T ile başlamalıdır + + all control characters + all control characters - - Cycle detected in extensions - Uzantılarda döngü algılandı + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - Hedef tür bir {0} olmalı, ancak {1} belirtildi. + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - Hedef tür bir {0} veya {1} olmalı, ancak {2} belirtildi. + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - Hedef tür bir {0}, {1} veya {2} olmalı, ancak {3} belirtildi. + + all letter characters + all letter characters - - Could not find location to generation symbol into. - Sembolün üretileceği konum bulunamadı. + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - Deyimlerin ekleneceği konum sağlanmadı. + + all numbers + all numbers - - Destination location was not in source. - Hedef konum kaynakta değildi. + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - Hedef konum farklı bir ağaçtandı. + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - Düğüm yanlış türde. + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - Konum boş veya kaynağa ait olmalıdır. + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - {1}' projesinde yinelenen kaynak dosyası '{0}' + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - Projelerin kaldırılması desteklenmiyor. + + all symbols + all symbols - - Adding projects is not supported. - Projelerin eklenmesi desteklenmiyor. + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - Çalışma alanı boş değil. + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '{0}' çalışma alanının parçası değildir. + + balancing group + balancing group - - '{0}' is already part of the workspace. - '{0}' zaten çalışma alanının parçasıdır. + + base-group + base-group - - '{0}' is not referenced. - '{0}' öğesine başvurulmadı. + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '{0}' öğesine zaten başvuruldu. + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - Proje başvurusunu '{0}' üzerinden '{1}' üzerine eklemek döngüsel başvuruya neden olur. + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - Meta verilere başvurulmadı. + + carriage-return character + carriage-return character - - Metadata is already referenced. - Meta verilere zaten başvuruldu. + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} yok. + + character class subtraction + character class subtraction - - {0} is already present. - {0} zaten var. + + character-group + character-group - - The specified document is not a version of this document. - Belirtilen belge bu belgenin bir sürümü değil. + + comment + comment - - The language '{0}' is not supported. - {0}' dili desteklenmiyor. + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - Çözüm belirtilen projeyi zaten içeriyor. + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - Çözüm belirtilen projeyi içermiyor. + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - Proje zaten hedef projeye başvuruyor. + + conditional group match + conditional group match - - The project already transitively references the target project. - Proje zaten hedef projeye geçişli olarak başvuruyor. + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - Çözüm belirtilen belgeyi zaten içeriyor. + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - Çözüm belirtilen belgeyi içermiyor. + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - Geçici depolamaya birden fazla kez yazılamaz. + + control character + control character - - '{0}' is not open. - '{0}' açık değil. + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - Bu seçenek için bir dil adı belirtilemiyor. + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - Bu seçenek için bir dil adı belirtilmelidir. + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - Dosya dışarıdan değiştirildi: {0}. + + end-of-line comment + end-of-line comment - - Unrecognized language name. - Tanınmayan dil adı. + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - Meta veri başvurusu çözümlenemiyor: '{0}'. + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - Çözümleyici başvurusu çözümlenemiyor: '{0}'. + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - Proje bloğu geçersiz, Proje'den sonra "=" bekleniyor. + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - Proje bloğu geçersiz, proje adından sonra "," bekleniyor. + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - Proje bloğu geçersiz, proje yolundan sonra "," bekleniyor. + + end of string or line + end of string or line - - Expected {0}. - {0} bekleniyor. + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" null olmayan ve boş olmayan bir dize olmalıdır. + + escape character + escape character - - Expected header: "{0}". - Üst bilgi bekleniyor: "{0}". + + excluded-group + excluded-group - - Expected end-of-file. - Dosya sonu bekleniyor. + + expression + expression - - Expected {0} line. - {0} satırı bekleniyor. + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - Bu gönderim zaten farklı bir gönderim projesine başvuruyor. + + form-feed character + form-feed character - - {0} still contains open documents. - {0} hala açık belgeler içeriyor. + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} hala açık. + + group options + group options - - An element with the same key but a different value already exists. - Aynı anahtara, ancak farklı bir değere sahip olan bir öğe zaten var. + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - Birden çok boyutlu diziler seri hale getirilemez. + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - Değer, 30 bit işaretsiz tamsayı olarak temsil edilemeyecek kadar büyük. + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - Belirtilen yol mutlak olmalıdır. + + inline comment + inline comment - - Cast is redundant. - Atama gereksizdir. + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - Ad basitleştirilebilir. + + inline options + inline options - - Unknown identifier. - Bilinmeyen tanıtıcı. + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - Desteklenmeyen operatör '{0}' için kod üretilemiyor + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - İkili operatör için parametre sayısı geçersiz. + + letter, other + letter, other - - Invalid number of parameters for unary operator. - Birli operatör için parametre sayısı geçersiz. + + letter, titlecase + letter, titlecase - - Absolute path expected. - Mutlak yok bekleniyor. + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - Dosya uzantısı '{1}' bir dil ile ilişkili olmadığı için '{0}' projesi açılamıyor. + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - {1}' dili desteklenmediği için '{0}' projesi açılamıyor. + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - Geçersiz proje dosyası yolu: '{0}' + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - Geçersiz çözüm dosyası yolu: '{0}' + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - Proje dosyası bulunamadı: '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - Çözüm dosyası bulunamadı: '{0}' + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - {0}' projesinden birleştirilmemiş değişiklik + + match at least 'n' times + match at least 'n' times - - Added: - Eklendi: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - Geçtiği her yerde '{0}' ifadesini düzelt + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - {1}' içinde geçtiği her yerde '{0}' ifadesini düzelt + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - Çözüm'de geçtiği her yerde '{0}' ifadesini düzelt + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - Önce: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - Sonra: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - Kaldırıldı: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - Geçersiz CodePage değeri: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - Ek belgelerin eklenmesi desteklenmiyor. + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - Çözümleyici başvurularının eklenmesi desteklenmiyor. + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - Belgelerin eklenmesi desteklenmiyor. + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - Meta veri başvurularının eklenmesi desteklenmiyor. + + match one or more times + match one or more times - - Adding project references is not supported. - Proje başvurularının eklenmesi desteklenmiyor. + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - Ek belgelerin değiştirilmesi desteklenmiyor. + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - Belgelerin değiştirilmesi desteklenmiyor. + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - Proje özelliklerinin değiştirilmesi desteklenmiyor. + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - Ek belgelerin kaldırılması desteklenmiyor. + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - Çözümleyici başvurularının kaldırılması desteklenmiyor. + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - Belgelerin kaldırılması desteklenmiyor. + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - Meta veri başvurularının kaldırılması desteklenmiyor. + + match zero or one time + match zero or one time - - Removing project references is not supported. - Proje başvurularının kaldırılması desteklenmiyor. + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - Görevi gerçekleştirmek için '{0}' türünde hizmet gerekli, ancak bu hizmet çalışma alanında yok. + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - Sağlanan tanı null olamaz. + + name + name - - At least one diagnostic must be supplied. - En az bir tanı sağlanmalıdır. + + name1 + name1 - - Diagnostic must have span '{0}' - Tanı, '{0}' yayılmasına sahip olmalıdır + + name2 + name2 - - Cannot deserialize type '{0}'. - {0}' türü seri durumdan çıkarılamıyor. + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - {0}' türü seri hale getirilemiyor. + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - {0}' türü, serileştirme bağlayıcısı tarafından anlaşılamıyor. + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - {0}' düğümünün etiketi geçersiz, etiket [0, {1}) içerisinde olmalıdır. + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - Eşleşen '{0}' ve '{1}' düğümlerinin etiketi aynı olmalıdır. + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - Yeni ağaçta '{0}' düğümü bulunmalıdır. + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - Eski ağaçta '{0}' düğümü bulunmalıdır. + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - {0}' üyesi, sembolün bildirimi içerisinde bildirilmedi. + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - Konum, sembolün bildirimi içinde bildirilmedi + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - {0}' sembolü geçerli çözümde bulunamaz. + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - Derleme seçeneklerini değiştirme desteklenmiyor. + + negative unicode category + negative unicode category - - Changing parse options is not supported. - Ayrıştırma seçeneklerini değiştirme desteklenmiyor. + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - Düğüm, ağacın bir parçası değil. + + new-line character + new-line character - - This workspace does not support opening and closing documents. - Bu çalışma alanı, belgeleri açıp kapatmayı desteklemiyor. + + no + no - - Usage: - Kullanım: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - Özel Durumlar: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0}' başlatılmamış bir ImmutableArray döndürdü + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - Hata + + non-white-space character + non-white-space character - - Warning - Uyarı + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - PopulateSwitch + + non-word boundary + non-word boundary - - Member access should be qualified. - Üye erişimi nitelenmiş olmalıdır. + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - {0}' deyimine küme ayracı ekleyin. + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - Seçenekler Çalışma alanından gelmedi + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - Etkinleştir + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - Etkinleştir ve gelecekteki hataları yoksay + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '{0}' bir hatayla karşılaştı ve devre dışı bırakıldı. + + number, decimal digit + number, decimal digit - - Show Stack Trace - Yığın İzlemesini Göster + + number, letter + number, letter - - Stream is too long. - Akış çok uzun. + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - {0}' türünün seri durumdan çıkarma okuyucusu, yanlış sayıda değer okudu. + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - Baş Harfleri Büyük Olmak Üzere Bitişik + + numbered backreference + numbered backreference - - Abstract Method - Soyut Metot - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - Zaman Uyumsuz Metot - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - I ile başlar - {locked:I} + + other, not assigned + other, not assigned + - - Class - Sınıf - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - Temsilci - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - Sabit listesi - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - Olay - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - Arabirim - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - Alan Olmayan Üyeler - {locked:field} + + positive character range + positive character range + - - Private Method - Özel Metot - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - Özel veya İç Alan - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - Özel veya İç Statik Alan - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - Özellik - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - Genel veya Korunan Alan - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - Statik Alan - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - Statik Metot - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - Yapı - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - Türler - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - Metot - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - Eksik ön ek: '{0}' + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - Hata + + start of string only + start of string only - - None - Hiçbiri + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - Eksik son ek: '{0}' + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - Başta olmayan bu sözcükler büyük harf karakterle başlamalıdır: {0} + + subexpression + subexpression - - Suggestion - Öneri + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - Başta olmayan bu sözcükler küçük harf karakterle başlamalıdır: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - Bu sözcükler küçük harf karakter içeremez: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - Bu sözcükler büyük harf karakter içeremez: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - Bu sözcükler büyük harf karakterle başlamalıdır: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - İlk sözcük ('{0}') büyük harf karakterle başlamalıdır + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - İlk sözcük ('{0}') küçük harf karakterle başlamalıdır + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - {0}' adlı dosyanın boyutu ({1}), izin verilen üst sınırı ({2}) aşıyor + + unicode category + unicode category - - Changing document properties is not supported - Belge özelliklerinin değiştirilmesi desteklenmiyor + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + "{0}" sembolü kaynağa ait değil. - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + Belge açıklaması kimliği E, F, M, N, P veya T ile başlamalıdır - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + Uzantılarda döngü algılandı - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + Hedef tür bir {0} olmalı, ancak {1} belirtildi. - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + Hedef tür bir {0} veya {1} olmalı, ancak {2} belirtildi. - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + Hedef tür bir {0}, {1} veya {2} olmalı, ancak {3} belirtildi. - - base-group - base-group + + Could not find location to generation symbol into. + Sembolün üretileceği konum bulunamadı. - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + Deyimlerin ekleneceği konum sağlanmadı. - - bell character - bell character + + Destination location was not in source. + Hedef konum kaynakta değildi. - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + Hedef konum farklı bir ağaçtandı. - - carriage-return character - carriage-return character + + Node is of the wrong type. + Düğüm yanlış türde. - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + Konum boş veya kaynağa ait olmalıdır. - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + {1}' projesinde yinelenen kaynak dosyası '{0}' - - character-group - character-group + + Removing projects is not supported. + Projelerin kaldırılması desteklenmiyor. - - comment - comment + + Adding projects is not supported. + Projelerin eklenmesi desteklenmiyor. - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + Çalışma alanı boş değil. - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '{0}' çalışma alanının parçası değildir. - - control character - control character + + '{0}' is already part of the workspace. + '{0}' zaten çalışma alanının parçasıdır. - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '{0}' öğesine başvurulmadı. - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '{0}' öğesine zaten başvuruldu. - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + Proje başvurusunu '{0}' üzerinden '{1}' üzerine eklemek döngüsel başvuruya neden olur. - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + Meta verilere başvurulmadı. - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + Meta verilere zaten başvuruldu. - - end of string only - end of string only + + {0} is not present. + {0} yok. - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} zaten var. - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + Belirtilen belge bu belgenin bir sürümü değil. - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + {0}' dili desteklenmiyor. - - end of string or line - end of string or line + + The solution already contains the specified project. + Çözüm belirtilen projeyi zaten içeriyor. - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + Çözüm belirtilen projeyi içermiyor. - - escape character - escape character + + The project already references the target project. + Proje zaten hedef projeye başvuruyor. - - excluded-group - excluded-group + + The project already transitively references the target project. + Proje zaten hedef projeye geçişli olarak başvuruyor. - - expression - expression + + The solution already contains the specified document. + Çözüm belirtilen belgeyi zaten içeriyor. - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + Çözüm belirtilen belgeyi içermiyor. - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + Geçici depolamaya birden fazla kez yazılamaz. - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '{0}' açık değil. - - group options - group options + + A language name cannot be specified for this option. + Bu seçenek için bir dil adı belirtilemiyor. - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + Bu seçenek için bir dil adı belirtilmelidir. - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + Dosya dışarıdan değiştirildi: {0}. - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + Tanınmayan dil adı. - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + Meta veri başvurusu çözümlenemiyor: '{0}'. - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + Çözümleyici başvurusu çözümlenemiyor: '{0}'. - - inline options - inline options + + Invalid project block, expected "=" after Project. + Proje bloğu geçersiz, Proje'den sonra "=" bekleniyor. - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + Proje bloğu geçersiz, proje adından sonra "," bekleniyor. - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + Proje bloğu geçersiz, proje yolundan sonra "," bekleniyor. - - letter, other - letter, other + + Expected {0}. + {0} bekleniyor. - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" null olmayan ve boş olmayan bir dize olmalıdır. - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + Üst bilgi bekleniyor: "{0}". - - mark, enclosing - mark, enclosing + + Expected end-of-file. + Dosya sonu bekleniyor. - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + {0} satırı bekleniyor. - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + Bu gönderim zaten farklı bir gönderim projesine başvuruyor. - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} hala açık belgeler içeriyor. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} hala açık. - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + Aynı anahtara, ancak farklı bir değere sahip olan bir öğe zaten var. - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + Birden çok boyutlu diziler seri hale getirilemez. - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + Değer, 30 bit işaretsiz tamsayı olarak temsil edilemeyecek kadar büyük. - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + Belirtilen yol mutlak olmalıdır. - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + Atama gereksizdir. - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + Ad basitleştirilebilir. - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + Bilinmeyen tanıtıcı. - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + Desteklenmeyen operatör '{0}' için kod üretilemiyor - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + İkili operatör için parametre sayısı geçersiz. - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + Birli operatör için parametre sayısı geçersiz. - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + Mutlak yok bekleniyor. - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + Dosya uzantısı '{1}' bir dil ile ilişkili olmadığı için '{0}' projesi açılamıyor. - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + {1}' dili desteklenmediği için '{0}' projesi açılamıyor. - - match one or more times - match one or more times + + Invalid project file path: '{0}' + Geçersiz proje dosyası yolu: '{0}' - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + Geçersiz çözüm dosyası yolu: '{0}' - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + Proje dosyası bulunamadı: '{0}' - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + Çözüm dosyası bulunamadı: '{0}' - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + {0}' projesinden birleştirilmemiş değişiklik - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + Eklendi: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + Geçtiği her yerde '{0}' ifadesini düzelt - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + {1}' içinde geçtiği her yerde '{0}' ifadesini düzelt - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + Çözüm'de geçtiği her yerde '{0}' ifadesini düzelt - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + Önce: - - matched subexpression - matched subexpression + + Before: + Sonra: - - name - name + + Removed: + Kaldırıldı: - - name1 - name1 + + Invalid CodePage value: {0} + Geçersiz CodePage değeri: {0} - - name2 - name2 + + Adding additional documents is not supported. + Ek belgelerin eklenmesi desteklenmiyor. - - name-or-number - name-or-number + + Adding analyzer references is not supported. + Çözümleyici başvurularının eklenmesi desteklenmiyor. - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + Belgelerin eklenmesi desteklenmiyor. - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + Meta veri başvurularının eklenmesi desteklenmiyor. - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + Proje başvurularının eklenmesi desteklenmiyor. - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + Ek belgelerin değiştirilmesi desteklenmiyor. - - negative character group - negative character group + + Changing documents is not supported. + Belgelerin değiştirilmesi desteklenmiyor. - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + Proje özelliklerinin değiştirilmesi desteklenmiyor. - - negative character range - negative character range + + Removing additional documents is not supported. + Ek belgelerin kaldırılması desteklenmiyor. - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + Çözümleyici başvurularının kaldırılması desteklenmiyor. - - negative unicode category - negative unicode category + + Removing documents is not supported. + Belgelerin kaldırılması desteklenmiyor. - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + Meta veri başvurularının kaldırılması desteklenmiyor. - - new-line character - new-line character + + Removing project references is not supported. + Proje başvurularının kaldırılması desteklenmiyor. - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + Görevi gerçekleştirmek için '{0}' türünde hizmet gerekli, ancak bu hizmet çalışma alanında yok. - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + Sağlanan tanı null olamaz. - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + En az bir tanı sağlanmalıdır. - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + Tanı, '{0}' yayılmasına sahip olmalıdır - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + {0}' türü seri durumdan çıkarılamıyor. - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + {0}' türü seri hale getirilemiyor. - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + {0}' türü, serileştirme bağlayıcısı tarafından anlaşılamıyor. - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + {0}' düğümünün etiketi geçersiz, etiket [0, {1}) içerisinde olmalıdır. + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + Eşleşen '{0}' ve '{1}' düğümlerinin etiketi aynı olmalıdır. - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + Yeni ağaçta '{0}' düğümü bulunmalıdır. - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + Eski ağaçta '{0}' düğümü bulunmalıdır. - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + {0}' üyesi, sembolün bildirimi içerisinde bildirilmedi. - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + Konum, sembolün bildirimi içinde bildirilmedi - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + {0}' sembolü geçerli çözümde bulunamaz. - - number, letter - number, letter + + Changing compilation options is not supported. + Derleme seçeneklerini değiştirme desteklenmiyor. - - number, other - number, other + + Changing parse options is not supported. + Ayrıştırma seçeneklerini değiştirme desteklenmiyor. - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + Düğüm, ağacın bir parçası değil. - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + Bu çalışma alanı, belgeleri açıp kapatmayı desteklemiyor. - - other, control - other, control + + Usage: + Kullanım: - - other, format - other, format + + Exceptions: + Özel Durumlar: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0}' başlatılmamış bir ImmutableArray döndürdü - - other, private use - other, private use + + Failure + Hata - - other, surrogate - other, surrogate + + Warning + Uyarı - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + PopulateSwitch - - positive character group - positive character group + + Member access should be qualified. + Üye erişimi nitelenmiş olmalıdır. - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + {0}' deyimine küme ayracı ekleyin. - - positive character range - positive character range + + Options did not come from Workspace + Seçenekler Çalışma alanından gelmedi - - punctuation, close - punctuation, close + + Enable + Etkinleştir - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + Etkinleştir ve gelecekteki hataları yoksay - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '{0}' bir hatayla karşılaştı ve devre dışı bırakıldı. - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + Yığın İzlemesini Göster - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + Akış çok uzun. - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + {0}' türünün seri durumdan çıkarma okuyucusu, yanlış sayıda değer okudu. - - punctuation, other - punctuation, other + + Pascal Case + Baş Harfleri Büyük Olmak Üzere Bitişik - - separator, line - separator, line - + + Abstract Method + Soyut Metot + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + Zaman Uyumsuz Metot + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + I ile başlar + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + Sınıf + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + Temsilci + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + Sabit listesi + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + Olay + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + Arabirim + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + Alan Olmayan Üyeler + {locked:field} - - symbol, math - symbol, math - + + Private Method + Özel Metot + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + Özel veya İç Alan + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + Özel veya İç Statik Alan + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + Özellik + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + Genel veya Korunan Alan + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + Statik Alan + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + Statik Metot + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + Yapı + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + Türler + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + Metot + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + Eksik ön ek: '{0}' - - vertical-tab character - vertical-tab character + + Error + Hata - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + Hiçbiri - - white-space character - white-space character + + Missing suffix: '{0}' + Eksik son ek: '{0}' - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + Başta olmayan bu sözcükler büyük harf karakterle başlamalıdır: {0} - - word boundary - word boundary + + Suggestion + Öneri - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + Başta olmayan bu sözcükler küçük harf karakterle başlamalıdır: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + Bu sözcükler küçük harf karakter içeremez: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + Bu sözcükler büyük harf karakter içeremez: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + Bu sözcükler büyük harf karakterle başlamalıdır: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + İlk sözcük ('{0}') büyük harf karakterle başlamalıdır - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + İlk sözcük ('{0}') küçük harf karakterle başlamalıdır - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + {0}' adlı dosyanın boyutu ({1}), izin verilen üst sınırı ({2}) aşıyor - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + Belge özelliklerinin değiştirilmesi desteklenmiyor - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hans.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hans.xlf index fd305192edd..c9d99d817f6 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hans.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hans.xlf @@ -72,2094 +72,2094 @@ 仅重构 - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - 符号“{0}”不是来自源。 + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - 文档注释 ID 必须以 E、F、M、N、P 或 T 开头 + + all control characters + all control characters - - Cycle detected in extensions - 在扩展中检测到循环 + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - 目标类型必须是 {0}，但给定类型是 {1}。 + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - 目标类型必须是 {0} 或 {1}，但给定类型是 {2}。 + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - 目标类型必须是 {0}、{1} 或 {2}，但给定类型是 {3}。 + + all letter characters + all letter characters - - Could not find location to generation symbol into. - 找不到符号生成到的位置。 + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - 未提供语句要添加到的位置。 + + all numbers + all numbers - - Destination location was not in source. - 目标位置不在源中。 + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - 目标位置来自不同的树。 + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - 节点类型不正确。 + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - 位置必须为 null 或来自源。 + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - 项目“{1}”中源文件“{0}”重复 + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - 不支持删除项目。 + + all symbols + all symbols - - Adding projects is not supported. - 不支持添加项目。 + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - 工作区不为空。 + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '“{0}”不是工作区的一部分。 + + balancing group + balancing group - - '{0}' is already part of the workspace. - '“{0}”已经是工作区的一部分。 + + base-group + base-group - - '{0}' is not referenced. - '未引用“{0}”。 + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '已引用“{0}”。 + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - 将项目引用从“{0}”添加到“{1}”导致循环引用。 + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - 未引用元数据。 + + carriage-return character + carriage-return character - - Metadata is already referenced. - 已引用元数据。 + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} 不存在。 + + character class subtraction + character class subtraction - - {0} is already present. - {0} 已存在。 + + character-group + character-group - - The specified document is not a version of this document. - 指定的文档不是此文档的某个版本。 + + comment + comment - - The language '{0}' is not supported. - 语言“{0}”不受支持。 + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - 解决方案已包含指定的项目。 + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - 解决方案不包含指定的项目。 + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - 项目已引用目标项目。 + + conditional group match + conditional group match - - The project already transitively references the target project. - 项目已通过可传递的方式引用目标项目。 + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - 解决方案已包含指定的文档。 + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - 解决方案不包含指定的文档。 + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - 不能多次写入临时存储。 + + control character + control character - - '{0}' is not open. - '未打开“{0}”。 + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - 无法为此选项指定语言名称。 + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - 必须为此选项指定语言名称。 + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - 已从外部修改文件: {0}。 + + end-of-line comment + end-of-line comment - - Unrecognized language name. - 无法识别的语言名称。 + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - 无法解析元数据引用:“{0}”。 + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - 无法解析分析器引用:“{0}”。 + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - 无效的项目块，项目之后应为“=”。 + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - 无效的项目块，项目名之后应为“,”。 + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - 无效的项目块，项目路径之后应为“,”。 + + end of string or line + end of string or line - - Expected {0}. - 应为 {0}。 + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - “{0}”必须是一个非 null 和非空的字符串。 + + escape character + escape character - - Expected header: "{0}". - 应为标头:“{0}”。 + + excluded-group + excluded-group - - Expected end-of-file. - 应为文件结尾。 + + expression + expression - - Expected {0} line. - 应为 {0} 行。 + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - 此提交已引用另一个提交项目。 + + form-feed character + form-feed character - - {0} still contains open documents. - {0} 仍包含打开的文档。 + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0}仍处于打开状态。 + + group options + group options - - An element with the same key but a different value already exists. - 已存在键相同但值不同的元素。 + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - 不能序列化具有多个维度的数组。 + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - 值太大，无法表示为 30 位无符号整数。 + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - 指定的路径必须是绝对路径。 + + inline comment + inline comment - - Cast is redundant. - 转换是多余的。 + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - 可以简化名称。 + + inline options + inline options - - Unknown identifier. - 未知的标识符。 + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - 无法为不受支持的运算符“{0}”生成代码。 + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - 参数数目对二元运算符无效。 + + letter, other + letter, other - - Invalid number of parameters for unary operator. - 参数数目对一元运算符无效。 + + letter, titlecase + letter, titlecase - - Absolute path expected. - 预期的绝对路径。 + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - 无法打开项目“{0}”， 因为文件扩展名“{1}”没有与某种语言关联。 + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - 无法打开项目“{0}”，因为语言“{1}”不受支持。 + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - 无效的项目文件路径:“{0}” + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - 无效的解决方案文件路径:“{0}” + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - 找不到项目文件:“{0}” + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - 找不到解决方案文件:“{0}” + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - 项目“{0}”的未合并的更改 + + match at least 'n' times + match at least 'n' times - - Added: - 添加项: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - 修复所有“{0}” + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - 修复“{1}”中的所有“{0}” + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - 修复解决方案中的所有“{0}” + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - 在此之后: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - 在此之前: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - 已移除: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - 无效的 CodePage 值: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - 不支持添加其他文档。 + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - 不支持添加分析器引用。 + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - 不支持添加文档。 + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - 不支持添加元数据引用。 + + match one or more times + match one or more times - - Adding project references is not supported. - 不支持添加项目引用。 + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - 不支持更改其他文档。 + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - 不支持更改文档。 + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - 不支持更改项目属性。 + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - 不支持删除其他文档。 + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - 不支持移除分析器引用。 + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - 不支持删除文档。 + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - 不支持删除元数据引用。 + + match zero or one time + match zero or one time - - Removing project references is not supported. - 不支持删除项目引用。 + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - 完成任务需要“{0}”类型的服务，但无法从工作区中使用这样的服务。 + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - 提供的诊断不能为 null。 + + name + name - - At least one diagnostic must be supplied. - 必须提供至少一个诊断。 + + name1 + name1 - - Diagnostic must have span '{0}' - 诊断必须有跨区“{0}” + + name2 + name2 - - Cannot deserialize type '{0}'. - 无法反序列化类型“{0}”。 + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - 无法序列化类型“{0}”。 + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - 序列化绑定器不理解“{0}”类型。 + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - 节点“{0}”的标签无效， 它必须在 [0, {1}) 的范围内。 + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - 匹配节点“{0}”和“{1}”必须拥有相同的标签。 + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - 节点“{0}”必须包含在新树中。 + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - 节点“{0}”必须包含在旧树中。 + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - 成员“{0}”未在该符号的声明内声明。 + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - 该位置不在此符号的声明内 + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - 在当前解决方案内找不到符号“{0}”。 + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - 不支持更改编译选项。 + + negative unicode category + negative unicode category - - Changing parse options is not supported. - 不支持更改分析选项。 + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - 节点不是树的一部分。 + + new-line character + new-line character - - This workspace does not support opening and closing documents. - 此工作区不支持打开和关闭文档。 + + no + no - - Usage: - 用法: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - 异常: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '“{0}”返回一个未初始化的 ImmutableArray + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - 失败 + + non-white-space character + non-white-space character - - Warning - 警告 + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - 填充开关 + + non-word boundary + non-word boundary - - Member access should be qualified. - 应限定成员访问。 + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - 向“{0}”报表添加大括号。 + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - 选项不是来自工作区 + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - 启用 + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - 启用并忽略将来发生的错误 + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '“{0}”遇到了错误，且已被禁用。 + + number, decimal digit + number, decimal digit - - Show Stack Trace - 显示“堆栈跟踪” + + number, letter + number, letter - - Stream is too long. - “流”过长。 + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - “{0}”的反序列化读取器读取到错误数量的值。 + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - 帕斯卡拼写法 + + numbered backreference + numbered backreference - - Abstract Method - 抽象方法 - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - 异步方法 - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - 以 I 开始 - {locked:I} + + other, not assigned + other, not assigned + - - Class - 类 - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - 委托 - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - 枚举 - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - 事件 - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - 接口 - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - 非字段成员 - {locked:field} + + positive character range + positive character range + - - Private Method - 私有方法 - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - 私有或内部字段 - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - 私有或内部静态字段 - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - 属性 - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - 公共或受保护的字段 - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - 静态字段 - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - 静态方法 - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - 结构 - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - 类型 - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - 方法 - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - 缺少前缀: {0} + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - 错误 + + start of string only + start of string only - - None - 无 + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - 缺少后缀: {0} + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - 这些非前导字必须以大写字母开头: {0} + + subexpression + subexpression - - Suggestion - 建议 + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - 这些非前导字必须以小写字母开头: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - 这些字不能包含小写字符: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - 这些字不能包含大写字符: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - 这些字必须以大写字符开头: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - 第一个字(“{0}”)必须以大写字符开头 + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - 第一个字(“{0}”)必须以小写字符开头 + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - 文件“{0}”的大小“{1}”超出允许的最大大小 {2} + + unicode category + unicode category - - Changing document properties is not supported - 不支持更改文档属性 + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + 符号“{0}”不是来自源。 - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + 文档注释 ID 必须以 E、F、M、N、P 或 T 开头 - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + 在扩展中检测到循环 - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + 目标类型必须是 {0}，但给定类型是 {1}。 - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + 目标类型必须是 {0} 或 {1}，但给定类型是 {2}。 - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + 目标类型必须是 {0}、{1} 或 {2}，但给定类型是 {3}。 - - base-group - base-group + + Could not find location to generation symbol into. + 找不到符号生成到的位置。 - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + 未提供语句要添加到的位置。 - - bell character - bell character + + Destination location was not in source. + 目标位置不在源中。 - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + 目标位置来自不同的树。 - - carriage-return character - carriage-return character + + Node is of the wrong type. + 节点类型不正确。 - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + 位置必须为 null 或来自源。 - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + 项目“{1}”中源文件“{0}”重复 - - character-group - character-group + + Removing projects is not supported. + 不支持删除项目。 - - comment - comment + + Adding projects is not supported. + 不支持添加项目。 - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + 工作区不为空。 - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '“{0}”不是工作区的一部分。 - - control character - control character + + '{0}' is already part of the workspace. + '“{0}”已经是工作区的一部分。 - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '未引用“{0}”。 - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '已引用“{0}”。 - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + 将项目引用从“{0}”添加到“{1}”导致循环引用。 - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + 未引用元数据。 - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + 已引用元数据。 - - end of string only - end of string only + + {0} is not present. + {0} 不存在。 - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} 已存在。 - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + 指定的文档不是此文档的某个版本。 - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + 语言“{0}”不受支持。 - - end of string or line - end of string or line + + The solution already contains the specified project. + 解决方案已包含指定的项目。 - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + 解决方案不包含指定的项目。 - - escape character - escape character + + The project already references the target project. + 项目已引用目标项目。 - - excluded-group - excluded-group + + The project already transitively references the target project. + 项目已通过可传递的方式引用目标项目。 - - expression - expression + + The solution already contains the specified document. + 解决方案已包含指定的文档。 - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + 解决方案不包含指定的文档。 - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + 不能多次写入临时存储。 - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '未打开“{0}”。 - - group options - group options + + A language name cannot be specified for this option. + 无法为此选项指定语言名称。 - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + 必须为此选项指定语言名称。 - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + 已从外部修改文件: {0}。 - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + 无法识别的语言名称。 - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + 无法解析元数据引用:“{0}”。 - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + 无法解析分析器引用:“{0}”。 - - inline options - inline options + + Invalid project block, expected "=" after Project. + 无效的项目块，项目之后应为“=”。 - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + 无效的项目块，项目名之后应为“,”。 - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + 无效的项目块，项目路径之后应为“,”。 - - letter, other - letter, other + + Expected {0}. + 应为 {0}。 - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + “{0}”必须是一个非 null 和非空的字符串。 - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + 应为标头:“{0}”。 - - mark, enclosing - mark, enclosing + + Expected end-of-file. + 应为文件结尾。 - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + 应为 {0} 行。 - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + 此提交已引用另一个提交项目。 - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} 仍包含打开的文档。 - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0}仍处于打开状态。 - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + 已存在键相同但值不同的元素。 - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + 不能序列化具有多个维度的数组。 - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + 值太大，无法表示为 30 位无符号整数。 - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + 指定的路径必须是绝对路径。 - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + 转换是多余的。 - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + 可以简化名称。 - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + 未知的标识符。 - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + 无法为不受支持的运算符“{0}”生成代码。 - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + 参数数目对二元运算符无效。 - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + 参数数目对一元运算符无效。 - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + 预期的绝对路径。 - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + 无法打开项目“{0}”， 因为文件扩展名“{1}”没有与某种语言关联。 - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + 无法打开项目“{0}”，因为语言“{1}”不受支持。 - - match one or more times - match one or more times + + Invalid project file path: '{0}' + 无效的项目文件路径:“{0}” - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + 无效的解决方案文件路径:“{0}” - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + 找不到项目文件:“{0}” - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + 找不到解决方案文件:“{0}” - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + 项目“{0}”的未合并的更改 - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + 添加项: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + 修复所有“{0}” - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + 修复“{1}”中的所有“{0}” - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + 修复解决方案中的所有“{0}” - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + 在此之后: - - matched subexpression - matched subexpression + + Before: + 在此之前: - - name - name + + Removed: + 已移除: - - name1 - name1 + + Invalid CodePage value: {0} + 无效的 CodePage 值: {0} - - name2 - name2 + + Adding additional documents is not supported. + 不支持添加其他文档。 - - name-or-number - name-or-number + + Adding analyzer references is not supported. + 不支持添加分析器引用。 - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + 不支持添加文档。 - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + 不支持添加元数据引用。 - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + 不支持添加项目引用。 - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + 不支持更改其他文档。 - - negative character group - negative character group + + Changing documents is not supported. + 不支持更改文档。 - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + 不支持更改项目属性。 - - negative character range - negative character range + + Removing additional documents is not supported. + 不支持删除其他文档。 - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + 不支持移除分析器引用。 - - negative unicode category - negative unicode category + + Removing documents is not supported. + 不支持删除文档。 - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + 不支持删除元数据引用。 - - new-line character - new-line character + + Removing project references is not supported. + 不支持删除项目引用。 - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + 完成任务需要“{0}”类型的服务，但无法从工作区中使用这样的服务。 - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + 提供的诊断不能为 null。 - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + 必须提供至少一个诊断。 - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + 诊断必须有跨区“{0}” - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + 无法反序列化类型“{0}”。 - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + 无法序列化类型“{0}”。 - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + 序列化绑定器不理解“{0}”类型。 - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + 节点“{0}”的标签无效， 它必须在 [0, {1}) 的范围内。 + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + 匹配节点“{0}”和“{1}”必须拥有相同的标签。 - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + 节点“{0}”必须包含在新树中。 - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + 节点“{0}”必须包含在旧树中。 - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + 成员“{0}”未在该符号的声明内声明。 - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + 该位置不在此符号的声明内 - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + 在当前解决方案内找不到符号“{0}”。 - - number, letter - number, letter + + Changing compilation options is not supported. + 不支持更改编译选项。 - - number, other - number, other + + Changing parse options is not supported. + 不支持更改分析选项。 - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + 节点不是树的一部分。 - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + 此工作区不支持打开和关闭文档。 - - other, control - other, control + + Usage: + 用法: - - other, format - other, format + + Exceptions: + 异常: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '“{0}”返回一个未初始化的 ImmutableArray - - other, private use - other, private use + + Failure + 失败 - - other, surrogate - other, surrogate + + Warning + 警告 - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + 填充开关 - - positive character group - positive character group + + Member access should be qualified. + 应限定成员访问。 - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + 向“{0}”报表添加大括号。 - - positive character range - positive character range + + Options did not come from Workspace + 选项不是来自工作区 - - punctuation, close - punctuation, close + + Enable + 启用 - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + 启用并忽略将来发生的错误 - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '“{0}”遇到了错误，且已被禁用。 - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + 显示“堆栈跟踪” - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + “流”过长。 - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + “{0}”的反序列化读取器读取到错误数量的值。 - - punctuation, other - punctuation, other + + Pascal Case + 帕斯卡拼写法 - - separator, line - separator, line - + + Abstract Method + 抽象方法 + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + 异步方法 + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + 以 I 开始 + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + 类 + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + 委托 + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + 枚举 + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + 事件 + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + 接口 + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + 非字段成员 + {locked:field} - - symbol, math - symbol, math - + + Private Method + 私有方法 + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + 私有或内部字段 + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + 私有或内部静态字段 + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + 属性 + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + 公共或受保护的字段 + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + 静态字段 + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + 静态方法 + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + 结构 + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + 类型 + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + 方法 + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + 缺少前缀: {0} - - vertical-tab character - vertical-tab character + + Error + 错误 - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + 无 - - white-space character - white-space character + + Missing suffix: '{0}' + 缺少后缀: {0} - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + 这些非前导字必须以大写字母开头: {0} - - word boundary - word boundary + + Suggestion + 建议 - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + 这些非前导字必须以小写字母开头: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + 这些字不能包含小写字符: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + 这些字不能包含大写字符: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + 这些字必须以大写字符开头: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + 第一个字(“{0}”)必须以大写字符开头 - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + 第一个字(“{0}”)必须以小写字符开头 - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + 文件“{0}”的大小“{1}”超出允许的最大大小 {2} - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + 不支持更改文档属性 - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions diff --git a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hant.xlf b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hant.xlf index 3e2c9966435..4f955079461 100644 --- a/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hant.xlf +++ b/src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hant.xlf @@ -72,2094 +72,2094 @@ 僅重構 - - Remove the line below if you want to inherit .editorconfig settings from higher directories - Remove the line below if you want to inherit .editorconfig settings from higher directories - - - - Symbol "{0}" is not from source. - 符號 "{0}" 非來自來源。 + + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - - Documentation comment id must start with E, F, M, N, P or T - 文件註解 ID 必須以 E、F、M、N、P 或 T 開頭 + + all control characters + all control characters - - Cycle detected in extensions - 在擴充功能中偵測到循環 + + All diacritic marks. This includes the Mn, Mc, and Me categories. + All diacritic marks. This includes the Mn, Mc, and Me categories. - - Destination type must be a {0}, but given one is {1}. - 目的地類型必須是 {0}，但提供的是 {1}。 + + all diacritic marks + all diacritic marks - - Destination type must be a {0} or a {1}, but given one is {2}. - 目的地類型必須是 {0} 或 {1}，但提供的是 {2}。 + + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - - Destination type must be a {0}, {1} or {2}, but given one is {3}. - 目的地類型必須是 {0}、{1} 或 {2}，但提供的是 {3}。 + + all letter characters + all letter characters - - Could not find location to generation symbol into. - 找不到產生符號目的地位置。 + + All numbers. This includes the Nd, Nl, and No categories. + All numbers. This includes the Nd, Nl, and No categories. - - No location provided to add statements to. - 未提供加入陳述式的位置。 + + all numbers + all numbers - - Destination location was not in source. - 目的地位置不在來源中。 + + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - - Destination location was from a different tree. - 目的地位置來自不同的樹狀目錄。 + + all punctuation characters + all punctuation characters - - Node is of the wrong type. - 節點類型不正確。 + + All separator characters. This includes the Zs, Zl, and Zp categories. + All separator characters. This includes the Zs, Zl, and Zp categories. - - Location must be null or from source. - 位置必須是 null 或源自來源。 + + all separator characters + all separator characters - - Duplicate source file '{0}' in project '{1}' - 複製專案 '{1}' 中的原始程式檔 '{0}' + + All symbols. This includes the Sm, Sc, Sk, and So categories. + All symbols. This includes the Sm, Sc, Sk, and So categories. - - Removing projects is not supported. - 不支援移除專案。 + + all symbols + all symbols - - Adding projects is not supported. - 不支援新增專案。 + + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - - Visual Basic files - Visual Basic files + + alternation + alternation - - NameOnly - NameOnly + + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - - Read - Read + + any character + any character - - Reference - Reference + + Matches a backspace character, \u0008 + Matches a backspace character, \u0008 - - Write - Write + + backspace character + backspace character - - Workspace is not empty. - 工作區不是空的。 + + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. + +'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. + +The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - - '{0}' is not part of the workspace. - '{0}' 不是工作區的一部分。 + + balancing group + balancing group - - '{0}' is already part of the workspace. - '{0}' 已經是工作區的一部分。 + + base-group + base-group - - '{0}' is not referenced. - '未參考 '{0}'。 + + Matches a bell (alarm) character, \u0007 + Matches a bell (alarm) character, \u0007 - - '{0}' is already referenced. - '已經參考 '{0}'。 + + bell character + bell character - - Adding project reference from '{0}' to '{1}' will cause a circular reference. - 將專案參考從 '{0}' 加入 '{1}' 會造成循環參考。 + + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - - Metadata is not referenced. - 未參考中繼資料。 + + carriage-return character + carriage-return character - - Metadata is already referenced. - 已參考中繼資料。 + + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. + +'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - - {0} is not present. - {0} 不存在。 + + character class subtraction + character class subtraction - - {0} is already present. - {0} 已經存在。 + + character-group + character-group - - The specified document is not a version of this document. - 指定的文件不是此文件的版本。 + + comment + comment - - The language '{0}' is not supported. - 不支援語言 '{0}'。 + + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + This language element attempts to match one of two patterns depending on whether it can match an initial pattern. + +'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - - The solution already contains the specified project. - 此方案已經含有指定的專案。 + + conditional expression match + conditional expression match - - The solution does not contain the specified project. - 此方案不包含指定的專案。 + + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. + +'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - - The project already references the target project. - 此專案已經參考目標專案。 + + conditional group match + conditional group match - - The project already transitively references the target project. - 此專案已經以可轉移方式參考目標專案。 + + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - - The solution already contains the specified document. - 此方案已含有指定的文件。 + + contiguous matches + contiguous matches - - The solution does not contain the specified document. - 此方案不包含指定的文件。 + + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - - Temporary storage cannot be written more than once. - 無法多次寫入暫時儲存區。 + + control character + control character - - '{0}' is not open. - '{0}' 未開啟。 + + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. + +If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - - A language name cannot be specified for this option. - 無法指定此選項的語言名稱。 + + decimal-digit character + decimal-digit character - - A language name must be specified for this option. - 必須指定此選項的語言名稱。 + + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - - File was externally modified: {0}. - 已在外部修改檔案: {0}。 + + end-of-line comment + end-of-line comment - - Unrecognized language name. - 無法辨認的語言名稱。 + + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - - Can't resolve metadata reference: '{0}'. - 無法解析中繼資料參考: '{0}'。 + + end of string only + end of string only - - Can't resolve analyzer reference: '{0}'. - 無法解析分析器參考: '{0}'。 + + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. + +The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - - Invalid project block, expected "=" after Project. - 專案區塊無效，專案之後必須是 "="。 + + end of string or before ending newline + end of string or before ending newline - - Invalid project block, expected "," after project name. - 專案區塊無效，專案名稱之後必須是 ","。 + + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. + +The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - - Invalid project block, expected "," after project path. - 專案區塊無效，專案路徑之後必須是 ","。 + + end of string or line + end of string or line - - Expected {0}. - 必須是 {0}。 + + Matches an escape character, \u001B + Matches an escape character, \u001B - - "{0}" must be a non-null and non-empty string. - "{0}" 必須是非 null 和非空白的字串。 + + escape character + escape character - - Expected header: "{0}". - 預期的標頭: "{0}"。 + + excluded-group + excluded-group - - Expected end-of-file. - 預期的檔案結尾。 + + expression + expression - - Expected {0} line. - 必須要有 {0} 行。 + + Matches a form-feed character, \u000C + Matches a form-feed character, \u000C - - This submission already references another submission project. - 此提交作業已參考其他提交專案。 + + form-feed character + form-feed character - - {0} still contains open documents. - {0} 仍包含開啟中的文件。 + + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly + named or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - {0} is still open. - {0} 仍在開啟中。 + + group options + group options - - An element with the same key but a different value already exists. - 已經有相同索引鍵但不同值的項目。 + + Matches an ASCII character, where ## is a two-digit hexadecimal character code. + Matches an ASCII character, where ## is a two-digit hexadecimal character code. - - Arrays with more than one dimension cannot be serialized. - 無法序列化包含多個維度的陣列。 + + hexidecimal escape + hexidecimal escape - - Value too large to be represented as a 30 bit unsigned integer. - 值太大，無法呈現為 30 位元不帶正負號的整數。 + + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - - Specified path must be absolute. - 指定的路徑必須是絕對路徑。 + + inline comment + inline comment - - Cast is redundant. - 多餘的 Cast。 + + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). + Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: + + i Use case-insensitive matching. + m Use multiline mode, where ^ and $ match the beginning and end of each line + (instead of the beginning and end of the input string). + s Use single-line mode, where the period (.) matches every character + (instead of every character except \n). + n Do not capture unnamed groups. The only valid captures are explicitly named + or numbered groups of the form (?<name> subexpression). + x Exclude unescaped white space from the pattern, and enable comments + after a number sign (#). - - Name can be simplified. - 可以簡化名稱。 + + inline options + inline options - - Unknown identifier. - 未知的識別項。 + + letter, lowercase + letter, lowercase - - Cannot generate code for unsupported operator '{0}' - 無法產生不受支援之運算子 '{0}' 的程式碼 + + letter, modifier + letter, modifier - - Invalid number of parameters for binary operator. - 二元運算子的參數數目無效。 + + letter, other + letter, other - - Invalid number of parameters for unary operator. - 一元運算子的參數數目無效。 + + letter, titlecase + letter, titlecase - - Absolute path expected. - 必須是絕對路徑。 + + letter, uppercase + letter, uppercase - - Cannot open project '{0}' because the file extension '{1}' is not associated with a language. - 無法開啟專案 '{0}'，因為副檔名 '{1}' 未與語言相關聯。 + + mark, enclosing + mark, enclosing - - Cannot open project '{0}' because the language '{1}' is not supported. - 無法開啟專案 '{0}'，因為不支援語言 '{1}'。 + + mark, nonspacing + mark, nonspacing - - Invalid project file path: '{0}' - 專案檔路徑無效: '{0}' + + mark, spacing combining + mark, spacing combining - - Invalid solution file path: '{0}' - 方案檔路徑無效: '{0}' + + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - - Project file not found: '{0}' - 找不到專案檔: '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Solution file not found: '{0}' - 找不到方案檔: '{0}' + + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - - Unmerged change from project '{0}' - 取消合併專案 '{0}' 的變更 + + match at least 'n' times + match at least 'n' times - - Added: - 已加入: + + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - - Fix all '{0}' - 修正所有 '{0}' + + match at least 'n' times (lazy) + match at least 'n' times (lazy) - - Fix all '{0}' in '{1}' - 修正 '{1}' 中的所有 '{0}' + + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - - Fix all '{0}' in Solution - 修正方案中的所有 '{0}' + + match between 'm' and 'n' times + match between 'm' and 'n' times - - After: - 之後: + + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - - Before: - 之前: + + match exactly 'n' times (lazy) + match exactly 'n' times (lazy) - - Removed: - 已移除: + + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - - Invalid CodePage value: {0} - 無效的字碼頁值: {0} + + match exactly 'n' times + match exactly 'n' times - - Adding additional documents is not supported. - 不支援新增其他文件。 + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - - Adding analyzer references is not supported. - 不支援新增分析器參考。 + + match one or more times (lazy) + match one or more times (lazy) - - Adding documents is not supported. - 不支援新增文件。 + + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - - Adding metadata references is not supported. - 不支援新增中繼資料參考。 + + match one or more times + match one or more times - - Adding project references is not supported. - 不支援新增專案參考。 + + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - - Changing additional documents is not supported. - 不支援變更其他文件。 + + match zero or more times (lazy) + match zero or more times (lazy) - - Changing documents is not supported. - 不支援變更文件。 + + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - - Changing project properties is not supported. - 不支援變更專案屬性。 + + match zero or more times + match zero or more times - - Removing additional documents is not supported. - 不支援移除其他文件。 + + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - - Removing analyzer references is not supported. - 不支援移除分析器參考。 + + match zero or one time (lazy) + match zero or one time (lazy) - - Removing documents is not supported. - 不支援移除文件。 + + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - - Removing metadata references is not supported. - 不支援移除中繼資料參考。 + + match zero or one time + match zero or one time - - Removing project references is not supported. - 不支援移除專案參考。 + + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - - Service of type '{0}' is required to accomplish the task but is not available from the workspace. - 完成工作需要 '{0}' 類型的服務，但是無法從工作區取得。 + + matched subexpression + matched subexpression - - Supplied diagnostic cannot be null. - 提供的診斷不可為 null。 + + name + name - - At least one diagnostic must be supplied. - 至少必須提供一項診斷。 + + name1 + name1 - - Diagnostic must have span '{0}' - 診斷範圍必須涵蓋 '{0}' + + name2 + name2 - - Cannot deserialize type '{0}'. - 無法將類型 '{0}' 還原序列化。 + + name-or-number + name-or-number - - Cannot serialize type '{0}'. - 無法將類型 '{0}' 序列化。 + + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. + A named or numbered backreference. + +'name' is the name of a capturing group defined in the regular expression pattern. - - The type '{0}' is not understood by the serialization binder. - 序列化繫結器無法辨識類型 '{0}'。 + + named backreference + named backreference - - Label for node '{0}' is invalid, it must be within [0, {1}). - 節點 '{0}' 的標籤無效，它必須位於 [0, {1}) 內。 + + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + Captures a matched subexpression and lets you access it by name or by number. + +'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. + +If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - - Matching nodes '{0}' and '{1}' must have the same label. - 相符節點 '{0}' 與 '{1}' 必須具有相同標籤。 + + named matched subexpression + named matched subexpression - - Node '{0}' must be contained in the new tree. - 新的樹狀結構中必須包含節點 '{0}'。 + + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - Node '{0}' must be contained in the old tree. - 舊的樹狀結構中必須包含節點 '{0}'。 + + negative character group + negative character group - - The member '{0}' is not declared within the declaration of the symbol. - 符號的宣告中並未宣告成員 '{0}'。 + + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. + +Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - - The position is not within the symbol's declaration - 位置不在符號的宣告中。 + + negative character range + negative character range - - The symbol '{0}' cannot be located within the current solution. - 在目前的方案中找不到符號 '{0}'。 + + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - - Changing compilation options is not supported. - 不支援變更編譯選項。 + + negative unicode category + negative unicode category - - Changing parse options is not supported. - 不支援變更剖析選項。 + + Matches a new-line character, \u000A + Matches a new-line character, \u000A - - The node is not part of the tree. - 這個節點不屬於樹狀結構的一部分。 + + new-line character + new-line character - - This workspace does not support opening and closing documents. - 這個工作區不支援開啟及關閉文件。 + + no + no - - Usage: - 使用方式: + + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. + +If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - - Exceptions: - 例外狀況: + + non-digit character + non-digit character - - '{0}' returned an uninitialized ImmutableArray - '{0}' 傳回未初始化的 ImmutableArray + + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. + +If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - - Failure - 失敗 + + non-white-space character + non-white-space character - - Warning - 警告 + + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - - Populate switch - 填入切換 + + non-word boundary + non-word boundary - - Member access should be qualified. - 必須限定成員存取。 + + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + \W matches any non-word character. It matches any character except for those in the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] + Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + + non-word character + non-word character - - Add braces to '{0}' statement. - 為 '{0}' 陳述式加入大括號。 + + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) + +This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - - Options did not come from Workspace - 選項並非來自工作工作區 + + nonbacktracking subexpression + nonbacktracking subexpression - - Enable - 啟用 + + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + This construct does not capture the substring that is matched by a subexpression: + +The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. + +If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - - Enable and ignore future errors - 啟用並忽略未來的錯誤 + + noncapturing group + noncapturing group - - '{0}' encountered an error and has been disabled. - '{0}' 發生錯誤並已停用。 + + number, decimal digit + number, decimal digit - - Show Stack Trace - 顯示堆疊追蹤 + + number, letter + number, letter - - Stream is too long. - 資料流過長。 + + number, other + number, other - - Deserialization reader for '{0}' read incorrect number of values. - {0}' 的還原序列化讀取器所讀取的值數目不正確。 + + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. + +There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - - Pascal Case - Pascal 命名法的大小寫 + + numbered backreference + numbered backreference - - Abstract Method - 抽象方法 - {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, control + other, control + - - Async Method - 非同步方法 - {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + other, format + other, format + - - Begins with I - 以 I 開頭 - {locked:I} + + other, not assigned + other, not assigned + - - Class - 類別 - {locked} unless the capitalization should be handled differently + + other, private use + other, private use + - - Delegate - 委派 - {locked} unless the capitalization should be handled differently + + other, surrogate + other, surrogate + - - Enum - 列舉 - {locked} unless the capitalization should be handled differently + + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + - - Event - 事件 - {locked} unless the capitalization should be handled differently + + positive character group + positive character group + - - Interface - 介面 - {locked} unless the capitalization should be handled differently + + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + - - Non-Field Members - 非欄位成員 - {locked:field} + + positive character range + positive character range + - - Private Method - 私人方法 - {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, close + punctuation, close + - - Private or Internal Field - 私人或內部欄位 - {locked: private}{locked: internal}{locked:field} + + punctuation, connector + punctuation, connector + - - Private or Internal Static Field - 私人或內部靜態欄位 - {locked: private}{locked: internal}{locked:static}{locked:field} + + punctuation, dash + punctuation, dash + - - Property - 屬性 - {locked} unless the capitalization should be handled differently + + punctuation, final quote + punctuation, final quote + - - Public or Protected Field - 公用或受保護欄位 - {locked: public}{locked: protected}{locked:field} + + punctuation, initial quote + punctuation, initial quote + - - Static Field - 靜態欄位 - {locked:static}{locked:field} (unless the capitalization should be handled differently) + + punctuation, open + punctuation, open + - - Static Method - 靜態方法 - {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) + + punctuation, other + punctuation, other + - - Struct - 結構 - {locked} unless the capitalization should be handled differently + + separator, line + separator, line + - - Types - 類型 - {locked:types} unless the capitalization should be handled differently + + separator, paragraph + separator, paragraph + - - Method - 方法 - {locked:method} unless the capitalization should be handled differently + + separator, space + separator, space + - - Missing prefix: '{0}' - 遺漏前置詞: '{0}' + + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. + The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - - Error - 錯誤 + + start of string only + start of string only - - None - 無 + + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. + The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - - Missing suffix: '{0}' - 遺漏尾碼: '{0}' + + start of string or line + start of string or line - - These non-leading words must begin with an upper case letter: {0} - 非前置字組必須以大寫字母開頭: {0} + + subexpression + subexpression - - Suggestion - 建議 + + symbol, currency + symbol, currency - - These non-leading words must begin with a lowercase letter: {0} - 非前置字組必須以小寫字母開頭: {0} + + symbol, math + symbol, math - - These words cannot contain lower case characters: {0} - 這些字組不可包含小寫字母: {0} + + symbol, modifier + symbol, modifier - - These words cannot contain upper case characters: {0} - 這些字組不可包含大寫字母: {0} + + symbol, other + symbol, other - - These words must begin with upper case characters: {0} - 這些字組必須包含大寫字母: {0} + + Matches a tab character, \u0009 + Matches a tab character, \u0009 - - The first word, '{0}', must begin with an upper case character - 第一個字組 '{0}' 必須以大寫字母開頭 + + tab character + tab character - - The first word, '{0}', must begin with a lower case character - 第一個字組 '{0}' 必須以小寫字母開頭 + + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. + The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - - File '{0}' size of {1} exceeds maximum allowed size of {2} - 檔案 '{0}' 的大小 {1} 超過允許的大小上限 {2} + + unicode category + unicode category - - Changing document properties is not supported - 不支援變更文件屬性 + + Matches a UTF-16 code unit whose value is #### hexadecimal. + Matches a UTF-16 code unit whose value is #### hexadecimal. - - Alternation conditions cannot be comments - Alternation conditions cannot be comments - This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) + + unicode escape + unicode escape + - - Alternation conditions do not capture and cannot be named - Alternation conditions do not capture and cannot be named - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) + + Unicode General Category: {0} + Unicode General Category: {0} + - - A subtraction must be the last element in a character class - A subtraction must be the last element in a character class - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + Matches a vertical-tab character, \u000B + Matches a vertical-tab character, \u000B + - - Cannot include class \{0} in character range - Cannot include class \{0} in character range - This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) - - - Capture group numbers must be less than or equal to Int32.MaxValue - Capture group numbers must be less than or equal to Int32.MaxValue - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} - - - Capture number cannot be zero - Capture number cannot be zero - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) - - - Illegal \ at end of pattern - Illegal \ at end of pattern - This is an error message shown to the user when they write an invalid Regular Expression. Example: \ - - - Illegal {x,y} with x > y - Illegal {x,y} with x > y - This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} - - - Incomplete \p{X} character escape - Incomplete \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } - - - Insufficient hexadecimal digits - Insufficient hexadecimal digits - This is an error message shown to the user when they write an invalid Regular Expression. Example: \x - - - Invalid group name: Group names must begin with a word character - Invalid group name: Group names must begin with a word character - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) - - - malformed - malformed - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 - - - Malformed \p{X} character escape - Malformed \p{X} character escape - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} - - - Malformed \k<...> named back reference - Malformed \k<...> named back reference - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' - - - Missing control character - Missing control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: \c - - - Nested quantifier {0} - Nested quantifier {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. - - - Not enough )'s - Not enough )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: (a - - - Quantifier {x,y} following nothing - Quantifier {x,y} following nothing - This is an error message shown to the user when they write an invalid Regular Expression. Example: * - - - reference to undefined group - reference to undefined group - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) - - - Reference to undefined group name {0} - Reference to undefined group name {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') - - - Reference to undefined group number {0} - Reference to undefined group number {0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') - - - Too many | in (?()|) - Too many | in (?()|) - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) - - - Too many )'s - Too many )'s - This is an error message shown to the user when they write an invalid Regular Expression. Example: ) - - - Unknown property - Unknown property - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} - - - Unknown property '{0}' - Unknown property '{0}' - This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') - - - Unrecognized control character - Unrecognized control character - This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] - - - Unrecognized escape sequence \{0} - Unrecognized escape sequence \{0} - This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') - - - Unrecognized grouping construct - Unrecognized grouping construct - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< - - - Unterminated [] set - Unterminated [] set - This is an error message shown to the user when they write an invalid Regular Expression. Example: [ - - - Unterminated (?#...) comment - Unterminated (?#...) comment - This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# - - - .NET Coding Conventions - .NET Coding Conventions + + vertical-tab character + vertical-tab character - - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. - All control characters. This includes the Cc, Cf, Cs, Co, and Cn categories. + + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: + + \f The form feed character, \u000C + \n The newline character, \u000A + \r The carriage return character, \u000D + \t The tab character, \u0009 + \v The vertical tab character, \u000B + \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 + \p{Z} Matches any separator character + +If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - - all control characters - all control characters + + white-space character + white-space character - - All diacritic marks. This includes the Mn, Mc, and Me categories. - All diacritic marks. This includes the Mn, Mc, and Me categories. + + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. + +The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - - all diacritic marks - all diacritic marks + + word boundary + word boundary - - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. - All letter characters. This includes the Lu, Ll, Lt, Lm, and Lo characters. + + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + \w matches any word character. A word character is a member of any of the following Unicode categories: + + Ll Letter, Lowercase + Lu Letter, Uppercase + Lt Letter, Titlecase + Lo Letter, Other + Lm Letter, Modifier + Mn Mark, Nonspacing + Nd Number, Decimal Digit + Pc Punctuation, Connector + +If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - - all letter characters - all letter characters + + word character + word character - - All numbers. This includes the Nd, Nl, and No categories. - All numbers. This includes the Nd, Nl, and No categories. + + yes + yes - - all numbers - all numbers + + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. + +A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. - All punctuation characters. This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories. + + zero-width negative lookahead assertion + zero-width negative lookahead assertion - - all punctuation characters - all punctuation characters + + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. + +Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - - All separator characters. This includes the Zs, Zl, and Zp categories. - All separator characters. This includes the Zs, Zl, and Zp categories. + + zero-width negative lookbehind assertion + zero-width negative lookbehind assertion - - all separator characters - all separator characters + + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. + +Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - - All symbols. This includes the Sm, Sc, Sk, and So categories. - All symbols. This includes the Sm, Sc, Sk, and So categories. + + zero-width positive lookahead assertion + zero-width positive lookahead assertion - - all symbols - all symbols + + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. + A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. + +Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. - You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern. + + zero-width positive lookbehind assertion + zero-width positive lookbehind assertion - - alternation - alternation + + Remove the line below if you want to inherit .editorconfig settings from higher directories + Remove the line below if you want to inherit .editorconfig settings from higher directories - - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. - The period character (.) matches any character except \n (the newline character, \u000A). If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the 's' option, . matches any character. + + Symbol "{0}" is not from source. + 符號 "{0}" 非來自來源。 - - any character - any character + + Documentation comment id must start with E, F, M, N, P or T + 文件註解 ID 必須以 E、F、M、N、P 或 T 開頭 - - Matches a backspace character, \u0008 - Matches a backspace character, \u0008 + + Cycle detected in extensions + 在擴充功能中偵測到循環 - - backspace character - backspace character + + Destination type must be a {0}, but given one is {1}. + 目的地類型必須是 {0}，但提供的是 {1}。 - - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. - A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. - -'name1' is the current group (optional), 'name2' is a previously defined group, and 'subexpression' is any valid regular expression pattern. The balancing group definition deletes the definition of name2 and stores the interval between name2 and name1 in name1. If no name2 group is defined, the match backtracks. Because deleting the last definition of name2 reveals the previous definition of name2, this construct lets you use the stack of captures for group name2 as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets. - -The balancing group definition uses 'name2' as a stack. The beginning character of each nested construct is placed in the group and in its Group.Captures collection. When the closing character is matched, its corresponding opening character is removed from the group, and the Captures collection is decreased by one. After the opening and closing characters of all nested constructs have been matched, 'name1' is empty. + + Destination type must be a {0} or a {1}, but given one is {2}. + 目的地類型必須是 {0} 或 {1}，但提供的是 {2}。 - - balancing group - balancing group + + Destination type must be a {0}, {1} or {2}, but given one is {3}. + 目的地類型必須是 {0}、{1} 或 {2}，但提供的是 {3}。 - - base-group - base-group + + Could not find location to generation symbol into. + 找不到產生符號目的地位置。 - - Matches a bell (alarm) character, \u0007 - Matches a bell (alarm) character, \u0007 + + No location provided to add statements to. + 未提供加入陳述式的位置。 - - bell character - bell character + + Destination location was not in source. + 目的地位置不在來源中。 - - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. - Matches a carriage-return character, \u000D. Note that \r is not equivalent to the newline character, \n. + + Destination location was from a different tree. + 目的地位置來自不同的樹狀目錄。 - - carriage-return character - carriage-return character + + Node is of the wrong type. + 節點類型不正確。 - - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). - Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class. - -'base_group' is a positive or negative character group or range. The 'excluded_group' component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions). + + Location must be null or from source. + 位置必須是 null 或源自來源。 - - character class subtraction - character class subtraction + + Duplicate source file '{0}' in project '{1}' + 複製專案 '{1}' 中的原始程式檔 '{0}' - - character-group - character-group + + Removing projects is not supported. + 不支援移除專案。 - - comment - comment + + Adding projects is not supported. + 不支援新增專案。 - - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. - This language element attempts to match one of two patterns depending on whether it can match an initial pattern. - -'expression' is the initial pattern to match, 'yes' is the pattern to match if expression is matched, and 'no' is the optional pattern to match if expression is not matched. + + Visual Basic files + Visual Basic files - - conditional expression match - conditional expression match + + NameOnly + NameOnly - - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. - This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. - -'name' is the name (or number) of a capturing group, 'yes' is the expression to match if 'name' (or 'number') has a match, and 'no' is the optional expression to match if it does not. + + Read + Read - - conditional group match - conditional group match + + Reference + Reference - - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. - The \G anchor specifies that a match must occur at the point where the previous match ended. When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous. + + Write + Write - - contiguous matches - contiguous matches + + Workspace is not empty. + 工作區不是空的。 - - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. - Matches an ASCII control character, where X is the letter of the control character. For example, \cC is CTRL-C. + + '{0}' is not part of the workspace. + '{0}' 不是工作區的一部分。 - - control character - control character + + '{0}' is already part of the workspace. + '{0}' 已經是工作區的一部分。 - - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] - \d matches any decimal digit. It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets. - -If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9] + + '{0}' is not referenced. + '未參考 '{0}'。 - - decimal-digit character - decimal-digit character + + '{0}' is already referenced. + '已經參考 '{0}'。 - - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. - A number sign (#) marks an x-mode comment, which starts at the unescaped # character at the end of the regular expression pattern and continues until the end of the line. To use this construct, you must either enable the x option (through inline options) or supply the RegexOptions.IgnorePatternWhitespace value to the option parameter when instantiating the Regex object or calling a static Regex method. + + Adding project reference from '{0}' to '{1}' will cause a circular reference. + 將專案參考從 '{0}' 加入 '{1}' 會造成循環參考。 - - end-of-line comment - end-of-line comment + + Metadata is not referenced. + 未參考中繼資料。 - - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. - The \z anchor specifies that a match must occur at the end of the input string. Like the $ language element, \z ignores the RegexOptions.Multiline option. Unlike the \Z language element, \z does not match a \n character at the end of a string. Therefore, it can only match the last line of the input string. + + Metadata is already referenced. + 已參考中繼資料。 - - end of string only - end of string only + + {0} is not present. + {0} 不存在。 - - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. - The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n. - -The \Z anchor matches \n but does not match \r\n (the CR/LF character combination). To match CR/LF, include \r?\Z in the regular expression pattern. + + {0} is already present. + {0} 已經存在。 - - end of string or before ending newline - end of string or before ending newline + + The specified document is not a version of this document. + 指定的文件不是此文件的版本。 - - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. - The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string. If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. - -The $ anchor matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). To match the CR/LF character combination, include \r?$ in the regular expression pattern. + + The language '{0}' is not supported. + 不支援語言 '{0}'。 - - end of string or line - end of string or line + + The solution already contains the specified project. + 此方案已經含有指定的專案。 - - Matches an escape character, \u001B - Matches an escape character, \u001B + + The solution does not contain the specified project. + 此方案不包含指定的專案。 - - escape character - escape character + + The project already references the target project. + 此專案已經參考目標專案。 - - excluded-group - excluded-group + + The project already transitively references the target project. + 此專案已經以可轉移方式參考目標專案。 - - expression - expression + + The solution already contains the specified document. + 此方案已含有指定的文件。 - - Matches a form-feed character, \u000C - Matches a form-feed character, \u000C + + The solution does not contain the specified document. + 此方案不包含指定的文件。 - - form-feed character - form-feed character + + Temporary storage cannot be written more than once. + 無法多次寫入暫時儲存區。 - - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - This grouping construct applies or disables the specified options within a subexpression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly - named or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + '{0}' is not open. + '{0}' 未開啟。 - - group options - group options + + A language name cannot be specified for this option. + 無法指定此選項的語言名稱。 - - Matches an ASCII character, where ## is a two-digit hexadecimal character code. - Matches an ASCII character, where ## is a two-digit hexadecimal character code. + + A language name must be specified for this option. + 必須指定此選項的語言名稱。 - - hexidecimal escape - hexidecimal escape + + File was externally modified: {0}. + 已在外部修改檔案: {0}。 - - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. - The (?# comment) construct lets you include an inline comment in a regular expression. The regular expression engine does not use any part of the comment in pattern matching, although the comment is included in the string that is returned by the Regex.ToString method. The comment ends at the first closing parenthesis. + + Unrecognized language name. + 無法辨認的語言名稱。 - - inline comment - inline comment + + Can't resolve metadata reference: '{0}'. + 無法解析中繼資料參考: '{0}'。 - - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). - Enables or disables specific pattern matching options for the remainder of a regular expression. The options to enable are specified after the question mark, and the options to disable after the minus sign. The allowed options are: - - i Use case-insensitive matching. - m Use multiline mode, where ^ and $ match the beginning and end of each line - (instead of the beginning and end of the input string). - s Use single-line mode, where the period (.) matches every character - (instead of every character except \n). - n Do not capture unnamed groups. The only valid captures are explicitly named - or numbered groups of the form (?<name> subexpression). - x Exclude unescaped white space from the pattern, and enable comments - after a number sign (#). + + Can't resolve analyzer reference: '{0}'. + 無法解析分析器參考: '{0}'。 - - inline options - inline options + + Invalid project block, expected "=" after Project. + 專案區塊無效，專案之後必須是 "="。 - - letter, lowercase - letter, lowercase + + Invalid project block, expected "," after project name. + 專案區塊無效，專案名稱之後必須是 ","。 - - letter, modifier - letter, modifier + + Invalid project block, expected "," after project path. + 專案區塊無效，專案路徑之後必須是 ","。 - - letter, other - letter, other + + Expected {0}. + 必須是 {0}。 - - letter, titlecase - letter, titlecase + + "{0}" must be a non-null and non-empty string. + "{0}" 必須是非 null 和非空白的字串。 - - letter, uppercase - letter, uppercase + + Expected header: "{0}". + 預期的標頭: "{0}"。 - - mark, enclosing - mark, enclosing + + Expected end-of-file. + 預期的檔案結尾。 - - mark, nonspacing - mark, nonspacing + + Expected {0} line. + 必須要有 {0} 行。 - - mark, spacing combining - mark, spacing combining + + This submission already references another submission project. + 此提交作業已參考其他提交專案。 - - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} - The {n,}? quantifier matches the preceding element at least n times, where n is any integer, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,} + + {0} still contains open documents. + {0} 仍包含開啟中的文件。 - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + {0} is still open. + {0} 仍在開啟中。 - - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? - The {n,} quantifier matches the preceding element at least n times, where n is any integer. {n,} is a greedy quantifier whose lazy equivalent is {n,}? + + An element with the same key but a different value already exists. + 已經有相同索引鍵但不同值的項目。 - - match at least 'n' times - match at least 'n' times + + Arrays with more than one dimension cannot be serialized. + 無法序列化包含多個維度的陣列。 - - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} - The {n,m}? quantifier matches the preceding element between n and m times, where n and m are integers, but as few times as possible. It is the lazy counterpart of the greedy quantifier {n,m} + + Value too large to be represented as a 30 bit unsigned integer. + 值太大，無法呈現為 30 位元不帶正負號的整數。 - - match at least 'n' times (lazy) - match at least 'n' times (lazy) + + Specified path must be absolute. + 指定的路徑必須是絕對路徑。 - - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? - The {n,m} quantifier matches the preceding element at least n times, but no more than m times, where n and m are integers. {n,m} is a greedy quantifier whose lazy equivalent is {n,m}? + + Cast is redundant. + 多餘的 Cast。 - - match between 'm' and 'n' times - match between 'm' and 'n' times + + Name can be simplified. + 可以簡化名稱。 - - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ - The {n}? quantifier matches the preceding element exactly n times, where n is any integer. It is the lazy counterpart of the greedy quantifier {n}+ + + Unknown identifier. + 未知的識別項。 - - match exactly 'n' times (lazy) - match exactly 'n' times (lazy) + + Cannot generate code for unsupported operator '{0}' + 無法產生不受支援之運算子 '{0}' 的程式碼 - - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? - The {n} quantifier matches the preceding element exactly n times, where n is any integer. {n} is a greedy quantifier whose lazy equivalent is {n}? + + Invalid number of parameters for binary operator. + 二元運算子的參數數目無效。 - - match exactly 'n' times - match exactly 'n' times + + Invalid number of parameters for unary operator. + 一元運算子的參數數目無效。 - - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + - The +? quantifier matches the preceding element one or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier + + + Absolute path expected. + 必須是絕對路徑。 - - match one or more times (lazy) - match one or more times (lazy) + + Cannot open project '{0}' because the file extension '{1}' is not associated with a language. + 無法開啟專案 '{0}'，因為副檔名 '{1}' 未與語言相關聯。 - - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. - The + quantifier matches the preceding element one or more times. It is equivalent to the {1,} quantifier. + is a greedy quantifier whose lazy equivalent is +?. + + Cannot open project '{0}' because the language '{1}' is not supported. + 無法開啟專案 '{0}'，因為不支援語言 '{1}'。 - - match one or more times - match one or more times + + Invalid project file path: '{0}' + 專案檔路徑無效: '{0}' - - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * - The *? quantifier matches the preceding element zero or more times, but as few times as possible. It is the lazy counterpart of the greedy quantifier * + + Invalid solution file path: '{0}' + 方案檔路徑無效: '{0}' - - match zero or more times (lazy) - match zero or more times (lazy) + + Project file not found: '{0}' + 找不到專案檔: '{0}' - - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. - The * quantifier matches the preceding element zero or more times. It is equivalent to the {0,} quantifier. * is a greedy quantifier whose lazy equivalent is *?. + + Solution file not found: '{0}' + 找不到方案檔: '{0}' - - match zero or more times - match zero or more times + + Unmerged change from project '{0}' + 取消合併專案 '{0}' 的變更 - - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? - The ?? quantifier matches the preceding element zero or one time, but as few times as possible. It is the lazy counterpart of the greedy quantifier ? + + Added: + 已加入: - - match zero or one time (lazy) - match zero or one time (lazy) + + Fix all '{0}' + 修正所有 '{0}' - - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. - The ? quantifier matches the preceding element zero or one time. It is equivalent to the {0,1} quantifier. ? is a greedy quantifier whose lazy equivalent is ??. + + Fix all '{0}' in '{1}' + 修正 '{1}' 中的所有 '{0}' - - match zero or one time - match zero or one time + + Fix all '{0}' in Solution + 修正方案中的所有 '{0}' - - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. - This grouping construct captures a matched 'subexpression', where 'subexpression' is any valid regular expression pattern. Captures that use parentheses are numbered automatically from left to right based on the order of the opening parentheses in the regular expression, starting from one. The capture that is numbered zero is the text matched by the entire regular expression pattern. + + After: + 之後: - - matched subexpression - matched subexpression + + Before: + 之前: - - name - name + + Removed: + 已移除: - - name1 - name1 + + Invalid CodePage value: {0} + 無效的字碼頁值: {0} - - name2 - name2 + + Adding additional documents is not supported. + 不支援新增其他文件。 - - name-or-number - name-or-number + + Adding analyzer references is not supported. + 不支援新增分析器參考。 - - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - A named or numbered backreference. - -'name' is the name of a capturing group defined in the regular expression pattern. - - - - named backreference - named backreference + + Adding documents is not supported. + 不支援新增文件。 - - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. - Captures a matched subexpression and lets you access it by name or by number. - -'name' is a valid group name, and 'subexpression' is any valid regular expression pattern. 'name' must not contain any punctuation characters and cannot begin with a number. - -If the RegexOptions parameter of a regular expression pattern matching method includes the RegexOptions.ExplicitCapture flag, or if the n option is applied to this subexpression, the only way to capture a subexpression is to explicitly name capturing groups. + + Adding metadata references is not supported. + 不支援新增中繼資料參考。 - - named matched subexpression - named matched subexpression + + Adding project references is not supported. + 不支援新增專案參考。 - - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters are specified individually. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing additional documents is not supported. + 不支援變更其他文件。 - - negative character group - negative character group + + Changing documents is not supported. + 不支援變更文件。 - - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. - A negative character range specifies a list of characters that must not appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range, and 'lastCharacter' is the character that ends the range. - -Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F]. + + Changing project properties is not supported. + 不支援變更專案屬性。 - - negative character range - negative character range + + Removing additional documents is not supported. + 不支援移除其他文件。 - - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \P{ name } matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. + + Removing analyzer references is not supported. + 不支援移除分析器參考。 - - negative unicode category - negative unicode category + + Removing documents is not supported. + 不支援移除文件。 - - Matches a new-line character, \u000A - Matches a new-line character, \u000A + + Removing metadata references is not supported. + 不支援移除中繼資料參考。 - - new-line character - new-line character + + Removing project references is not supported. + 不支援移除專案參考。 - - no - no + + Service of type '{0}' is required to accomplish the task but is not available from the workspace. + 完成工作需要 '{0}' 類型的服務，但是無法從工作區取得。 - - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] - \D matches any non-digit character. It is equivalent to the \P{Nd} regular expression pattern. - -If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9] + + Supplied diagnostic cannot be null. + 提供的診斷不可為 null。 - - non-digit character - non-digit character + + At least one diagnostic must be supplied. + 至少必須提供一項診斷。 - - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] - \S matches any non-white-space character. It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. - -If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v] + + Diagnostic must have span '{0}' + 診斷範圍必須涵蓋 '{0}' - - non-white-space character - non-white-space character + + Cannot deserialize type '{0}'. + 無法將類型 '{0}' 還原序列化。 - - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. - The \B anchor specifies that the match must not occur on a word boundary. It is the opposite of the \b anchor. + + Cannot serialize type '{0}'. + 無法將類型 '{0}' 序列化。 - - non-word boundary - non-word boundary + + The type '{0}' is not understood by the serialization binder. + 序列化繫結器無法辨識類型 '{0}'。 - - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - \W matches any non-word character. It matches any character except for those in the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9] - Note: Ll, Lu, Lt, Lo, Lm, Mn, Nd, and Pc are all things that should not be localized. + + Label for node '{0}' is invalid, it must be within [0, {1}). + 節點 '{0}' 的標籤無效，它必須位於 [0, {1}) 內。 + - - non-word character - non-word character + + Matching nodes '{0}' and '{1}' must have the same label. + 相符節點 '{0}' 與 '{1}' 必須具有相同標籤。 - - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. - This construct disables backtracking. The regular expression engine will match as many characters in the input string as it can. When no further match is possible, it will not backtrack to attempt alternate pattern matches. (That is, the subexpression matches only strings that would be matched by the subexpression alone; it does not attempt to match a string based on the subexpression and any subexpressions that follow it.) - -This option is recommended if you know that backtracking will not succeed. Preventing the regular expression engine from performing unnecessary searching improves performance. + + Node '{0}' must be contained in the new tree. + 新的樹狀結構中必須包含節點 '{0}'。 - - nonbacktracking subexpression - nonbacktracking subexpression + + Node '{0}' must be contained in the old tree. + 舊的樹狀結構中必須包含節點 '{0}'。 - - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. - This construct does not capture the substring that is matched by a subexpression: - -The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest. - -If a regular expression includes nested grouping constructs, an outer noncapturing group construct does not apply to the inner nested group constructs. + + The member '{0}' is not declared within the declaration of the symbol. + 符號的宣告中並未宣告成員 '{0}'。 - - noncapturing group - noncapturing group + + The position is not within the symbol's declaration + 位置不在符號的宣告中。 - - number, decimal digit - number, decimal digit + + The symbol '{0}' cannot be located within the current solution. + 在目前的方案中找不到符號 '{0}'。 - - number, letter - number, letter + + Changing compilation options is not supported. + 不支援變更編譯選項。 - - number, other - number, other + + Changing parse options is not supported. + 不支援變更剖析選項。 - - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. - A numbered backreference, where 'number' is the ordinal position of the capturing group in the regular expression. For example, \4 matches the contents of the fourth capturing group. - -There is an ambiguity between octal escape codes (such as \16) and \number backreferences that use the same notation. If the ambiguity is a problem, you can use the \k<name> notation, which is unambiguous and cannot be confused with octal character codes. Similarly, hexadecimal codes such as \xdd are unambiguous and cannot be confused with backreferences. + + The node is not part of the tree. + 這個節點不屬於樹狀結構的一部分。 - - numbered backreference - numbered backreference + + This workspace does not support opening and closing documents. + 這個工作區不支援開啟及關閉文件。 - - other, control - other, control + + Usage: + 使用方式: - - other, format - other, format + + Exceptions: + 例外狀況: - - other, not assigned - other, not assigned + + '{0}' returned an uninitialized ImmutableArray + '{0}' 傳回未初始化的 ImmutableArray - - other, private use - other, private use + + Failure + 失敗 - - other, surrogate - other, surrogate + + Warning + 警告 - - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. - A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. + + Populate switch + 填入切換 - - positive character group - positive character group + + Member access should be qualified. + 必須限定成員存取。 - - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. - A positive character range specifies a range of characters, any one of which may appear in an input string for a match to occur. 'firstCharacter' is the character that begins the range and 'lastCharacter' is the character that ends the range. + + Add braces to '{0}' statement. + 為 '{0}' 陳述式加入大括號。 - - positive character range - positive character range + + Options did not come from Workspace + 選項並非來自工作工作區 - - punctuation, close - punctuation, close + + Enable + 啟用 - - punctuation, connector - punctuation, connector + + Enable and ignore future errors + 啟用並忽略未來的錯誤 - - punctuation, dash - punctuation, dash + + '{0}' encountered an error and has been disabled. + '{0}' 發生錯誤並已停用。 - - punctuation, final quote - punctuation, final quote + + Show Stack Trace + 顯示堆疊追蹤 - - punctuation, initial quote - punctuation, initial quote + + Stream is too long. + 資料流過長。 - - punctuation, open - punctuation, open + + Deserialization reader for '{0}' read incorrect number of values. + {0}' 的還原序列化讀取器所讀取的值數目不正確。 - - punctuation, other - punctuation, other + + Pascal Case + Pascal 命名法的大小寫 - - separator, line - separator, line - + + Abstract Method + 抽象方法 + {locked: abstract}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, paragraph - separator, paragraph - + + Async Method + 非同步方法 + {locked: async}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - separator, space - separator, space - + + Begins with I + 以 I 開頭 + {locked:I} - - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string. - + + Class + 類別 + {locked} unless the capitalization should be handled differently - - start of string only - start of string only - + + Delegate + 委派 + {locked} unless the capitalization should be handled differently - - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - The ^ anchor specifies that the following pattern must begin at the first character position of the string. If you use ^ with the RegexOptions.Multiline option, the match must occur at the beginning of each line. - + + Enum + 列舉 + {locked} unless the capitalization should be handled differently - - start of string or line - start of string or line - + + Event + 事件 + {locked} unless the capitalization should be handled differently - - subexpression - subexpression - + + Interface + 介面 + {locked} unless the capitalization should be handled differently - - symbol, currency - symbol, currency - + + Non-Field Members + 非欄位成員 + {locked:field} - - symbol, math - symbol, math - + + Private Method + 私人方法 + {locked: private}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - symbol, modifier - symbol, modifier - + + Private or Internal Field + 私人或內部欄位 + {locked: private}{locked: internal}{locked:field} - - symbol, other - symbol, other - + + Private or Internal Static Field + 私人或內部靜態欄位 + {locked: private}{locked: internal}{locked:static}{locked:field} - - Matches a tab character, \u0009 - Matches a tab character, \u0009 - + + Property + 屬性 + {locked} unless the capitalization should be handled differently - - tab character - tab character - + + Public or Protected Field + 公用或受保護欄位 + {locked: public}{locked: protected}{locked:field} - - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - The regular expression construct \p{ name } matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. - + + Static Field + 靜態欄位 + {locked:static}{locked:field} (unless the capitalization should be handled differently) - - unicode category - unicode category - + + Static Method + 靜態方法 + {locked: static}{locked: method} These are keywords (unless the order of words or capitalization should be handled differently) - - Matches a UTF-16 code unit whose value is #### hexadecimal. - Matches a UTF-16 code unit whose value is #### hexadecimal. - + + Struct + 結構 + {locked} unless the capitalization should be handled differently - - unicode escape - unicode escape - + + Types + 類型 + {locked:types} unless the capitalization should be handled differently - - Unicode General Category: {0} - Unicode General Category: {0} - + + Method + 方法 + {locked:method} unless the capitalization should be handled differently - - Matches a vertical-tab character, \u000B - Matches a vertical-tab character, \u000B + + Missing prefix: '{0}' + 遺漏前置詞: '{0}' - - vertical-tab character - vertical-tab character + + Error + 錯誤 - - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] - \s matches any white-space character. It is equivalent to the following escape sequences and Unicode categories: - - \f The form feed character, \u000C - \n The newline character, \u000A - \r The carriage return character, \u000D - \t The tab character, \u0009 - \v The vertical tab character, \u000B - \x85 The ellipsis or NEXT LINE (NEL) character (…), \u0085 - \p{Z} Matches any separator character - -If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v] + + None + 無 - - white-space character - white-space character + + Missing suffix: '{0}' + 遺漏尾碼: '{0}' - - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. - The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. The match may also occur on a word boundary at the beginning or end of the string. - -The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. + + These non-leading words must begin with an upper case letter: {0} + 非前置字組必須以大寫字母開頭: {0} - - word boundary - word boundary + + Suggestion + 建議 - - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] - \w matches any word character. A word character is a member of any of the following Unicode categories: - - Ll Letter, Lowercase - Lu Letter, Uppercase - Lt Letter, Titlecase - Lo Letter, Other - Lm Letter, Modifier - Mn Mark, Nonspacing - Nd Number, Decimal Digit - Pc Punctuation, Connector - -If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9] + + These non-leading words must begin with a lowercase letter: {0} + 非前置字組必須以小寫字母開頭: {0} - - word character - word character + + These words cannot contain lower case characters: {0} + 這些字組不可包含小寫字母: {0} - - yes - yes + + These words cannot contain upper case characters: {0} + 這些字組不可包含大寫字母: {0} - - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. - A zero-width negative lookahead assertion, where for the match to be successful, the input string must not match the regular expression pattern in subexpression. The matched string is not included in the match result. - -A zero-width negative lookahead assertion is typically used either at the beginning or at the end of a regular expression. At the beginning of a regular expression, it can define a specific pattern that should not be matched when the beginning of the regular expression defines a similar but more general pattern to be matched. In this case, it is often used to limit backtracking. At the end of a regular expression, it can define a subexpression that cannot occur at the end of a match. + + These words must begin with upper case characters: {0} + 這些字組必須包含大寫字母: {0} - - zero-width negative lookahead assertion - zero-width negative lookahead assertion + + The first word, '{0}', must begin with an upper case character + 第一個字組 '{0}' 必須以大寫字母開頭 - - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. - A zero-width negative lookbehind assertion, where for a match to be successful, 'subexpression' must not occur at the input string to the left of the current position. Any substring that does not match 'subexpression' is not included in the match result. - -Zero-width negative lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define precludes a match in the string that follows. They are also used to limit backtracking when the last character or characters in a captured group must not be one or more of the characters that match that group's regular expression pattern. + + The first word, '{0}', must begin with a lower case character + 第一個字組 '{0}' 必須以小寫字母開頭 - - zero-width negative lookbehind assertion - zero-width negative lookbehind assertion + + File '{0}' size of {1} exceeds maximum allowed size of {2} + 檔案 '{0}' 的大小 {1} 超過允許的大小上限 {2} - - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. - A zero-width positive lookahead assertion, where for a match to be successful, the input string must match the regular expression pattern in 'subexpression'. The matched substring is not included in the match result. A zero-width positive lookahead assertion does not backtrack. - -Typically, a zero-width positive lookahead assertion is found at the end of a regular expression pattern. It defines a substring that must be found at the end of a string for a match to occur but that should not be included in the match. It is also useful for preventing excessive backtracking. You can use a zero-width positive lookahead assertion to ensure that a particular captured group begins with text that matches a subset of the pattern defined for that captured group. + + Changing document properties is not supported + 不支援變更文件屬性 - - zero-width positive lookahead assertion - zero-width positive lookahead assertion - + + Alternation conditions cannot be comments + Alternation conditions cannot be comments + This is an error message shown to the user when they write an invalid Regular Expression. Example: a|(?#b) - - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - A zero-width positive lookbehind assertion, where for a match to be successful, 'subexpression' must occur at the input string to the left of the current position. 'subexpression' is not included in the match result. A zero-width positive lookbehind assertion does not backtrack. - -Zero-width positive lookbehind assertions are typically used at the beginning of regular expressions. The pattern that they define is a precondition for a match, although it is not a part of the match result. - + + Alternation conditions do not capture and cannot be named + Alternation conditions do not capture and cannot be named + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(?'x')) - - zero-width positive lookbehind assertion - zero-width positive lookbehind assertion + + A subtraction must be the last element in a character class + A subtraction must be the last element in a character class + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-[b]-c] + + + Cannot include class \{0} in character range + Cannot include class \{0} in character range + This is an error message shown to the user when they write an invalid Regular Expression. Example: [a-\w]. {0} is the invalid class (\w here) + + + Capture group numbers must be less than or equal to Int32.MaxValue + Capture group numbers must be less than or equal to Int32.MaxValue + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{2147483648} + + + Capture number cannot be zero + Capture number cannot be zero + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<0>a) + + + Illegal \ at end of pattern + Illegal \ at end of pattern + This is an error message shown to the user when they write an invalid Regular Expression. Example: \ + + + Illegal {x,y} with x > y + Illegal {x,y} with x > y + This is an error message shown to the user when they write an invalid Regular Expression. Example: a{1,0} + + + Incomplete \p{X} character escape + Incomplete \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{ Cc } + + + Insufficient hexadecimal digits + Insufficient hexadecimal digits + This is an error message shown to the user when they write an invalid Regular Expression. Example: \x + + + Invalid group name: Group names must begin with a word character + Invalid group name: Group names must begin with a word character + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<a >a) + + + malformed + malformed + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0 + + + Malformed \p{X} character escape + Malformed \p{X} character escape + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p {Cc} + + + Malformed \k<...> named back reference + Malformed \k<...> named back reference + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k' + + + Missing control character + Missing control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: \c + + + Nested quantifier {0} + Nested quantifier {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: a**. In this case {0} will be '*', the extra unnecessary quantifier. + + + Not enough )'s + Not enough )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: (a + + + Quantifier {x,y} following nothing + Quantifier {x,y} following nothing + This is an error message shown to the user when they write an invalid Regular Expression. Example: * + + + reference to undefined group + reference to undefined group + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(1)) + + + Reference to undefined group name {0} + Reference to undefined group name {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \k<a>. Here, {0} will be the name of the undefined group ('a') + + + Reference to undefined group number {0} + Reference to undefined group number {0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?<-1>). Here, {0} will be the number of the undefined group ('1') + + + Too many | in (?()|) + Too many | in (?()|) + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?(0)a|b|) + + + Too many )'s + Too many )'s + This is an error message shown to the user when they write an invalid Regular Expression. Example: ) + + + Unknown property + Unknown property + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{} + + + Unknown property '{0}' + Unknown property '{0}' + This is an error message shown to the user when they write an invalid Regular Expression. Example: \p{xxx}. Here, {0} will be the name of the unknown property ('xxx') + + + Unrecognized control character + Unrecognized control character + This is an error message shown to the user when they write an invalid Regular Expression. Example: [\c] + + + Unrecognized escape sequence \{0} + Unrecognized escape sequence \{0} + This is an error message shown to the user when they write an invalid Regular Expression. Example: \m. Here, {0} will be the unrecognized character ('m') + + + Unrecognized grouping construct + Unrecognized grouping construct + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?< + + + Unterminated [] set + Unterminated [] set + This is an error message shown to the user when they write an invalid Regular Expression. Example: [ + + + Unterminated (?#...) comment + Unterminated (?#...) comment + This is an error message shown to the user when they write an invalid Regular Expression. Example: (?# + + + .NET Coding Conventions + .NET Coding Conventions -- GitLab