插值字符串的转义引号

Question

I have a program that generates C# from bits of C# stored in an XML file. If I have a snippet like:

foo {bar}

I need to transform that into an interpolated string, like this:

$@"foo {bar}"

The problem is that, if I have quotes outside a placeholder, eg:

"foo" {bar}

I need to double those:

$@"""foo"" {bar}"

but ignore quotes inside placeholders:

foo {"bar"}

should produce:

$@"foo {"bar"}"

Also, need to look out for doubled braces:

foo {{"bar"}}

should produce:

$@"foo {{""bar""}}"

And perhaps the trickiest of all, if the placeholder is preceded and/or followed by an even number of braces:

foo {{{"bar"}}}

should produce:

$@"foo {{{"bar"}}}"

In short, if there's a placeholder then ignore everything inside. For the rest of the text, double quotes.

Can this be accomplished using regular expressions? If not, what alternatives do I have?

Answer 1

You will need at least 2 steps:

1. Add quotes inside the expression:

   "(?=[^}]*(?:}})*[^}]*$)|(?<=^[^{]*(?:{{)*)" => replace with ""

See demo

2. Enclose in $@"..." with string.Format("$@\\"{0}\\"", str);

Here is an IDEONE demo

var s = "\"foo\" {bar}";
var rx = new Regex(@"(?<!(?<!{){[^{}]*)""(?![^{}]*}(?!}))");
Console.WriteLine(string.Format("$@\"{0}\"",rx.Replace(s,"\"\"")));

And another demo here

Answer 2

This cannot be done with regular expressions. Knowing when a placeholder starts is easy, knowing when it ends is the hard part, since a placeholder can hold almost any C# expression, so you have to keep track of blocks ( {} ) and literals (strings, chars, comments) because any brace in a literal is not significant.

This is the code I came up with:

enum ParsingMode {
   Text,
   Code,
   InterpolatedString,
   InterpolatedVerbatimString,
   String,
   VerbatimString,
   Char,
   MultilineComment
}

public static string EscapeValueTemplate(string valueTemplate) {

   if (valueTemplate == null) throw new ArgumentNullException(nameof(valueTemplate));

   var quoteIndexes = new List<int>();

   var modeStack = new Stack<ParsingMode>();
   modeStack.Push(ParsingMode.Text);

   Func<ParsingMode> currentMode = () => modeStack.Peek();

   for (int i = 0; i < valueTemplate.Length; i++) {

      char c = valueTemplate[i];
      Func<char?> nextChar = () =>
         i + 1 < valueTemplate.Length ? valueTemplate[i + 1]
         : default(char?);

      switch (currentMode()) {
         case ParsingMode.Code:
            switch (c) {
               case '{':
                  modeStack.Push(ParsingMode.Code);
                  break;

               case '}':
                  modeStack.Pop();
                  break;

               case '\'':
                  modeStack.Push(ParsingMode.Char);
                  break;

               case '"':
                  ParsingMode stringMode = ParsingMode.String;

                  switch (valueTemplate[i - 1]) {
                     case '@':
                        if (i - 2 >= 0 && valueTemplate[i - 2] == '$') {
                           stringMode = ParsingMode.InterpolatedVerbatimString;
                        } else {
                           stringMode = ParsingMode.VerbatimString;
                        }
                        break;

                     case '$':
                        stringMode = ParsingMode.InterpolatedString;
                        break;
                  }

                  modeStack.Push(stringMode);
                  break;

               case '/':
                  if (nextChar() == '*') {
                     modeStack.Push(ParsingMode.MultilineComment);
                     i++;
                  }
                  break;
            }
            break;

         case ParsingMode.Text:
         case ParsingMode.InterpolatedString:
         case ParsingMode.InterpolatedVerbatimString:
            switch (c) {
               case '{':
                  if (nextChar() == '{') {
                     i++;
                  } else {
                     modeStack.Push(ParsingMode.Code);
                  }
                  break;

               case '"':
                  switch (currentMode()) {
                     case ParsingMode.Text:
                        quoteIndexes.Add(i);
                        break;

                     case ParsingMode.InterpolatedString:
                        modeStack.Pop();
                        break;

                     case ParsingMode.InterpolatedVerbatimString:
                        if (nextChar() == '"') {
                           i++;
                        } else {
                           modeStack.Pop();
                        }
                        break;
                  }
                  break;

               case '\\':
                  if (currentMode() == ParsingMode.InterpolatedString) {
                     i++;
                  }
                  break;
            }
            break;

         case ParsingMode.String:
            switch (c) {
               case '\\':
                  i++;
                  break;

               case '"':
                  modeStack.Pop();
                  break;
            }
            break;

         case ParsingMode.VerbatimString:
            if (c == '"') {
               if (nextChar() == '"') {
                  i++;
               } else {
                  modeStack.Pop();
               }
            }
            break;

         case ParsingMode.Char:
            switch (c) {
               case '\\':
                  i++;
                  break;
               case '\'':
                  modeStack.Pop();
                  break;
            }
            break;

         case ParsingMode.MultilineComment:
            if (c == '*') {
               if (nextChar() == '/') {
                  modeStack.Pop();
                  i++;
               }
            }
            break;
      }
   }

   var sb = new StringBuilder(valueTemplate, valueTemplate.Length + quoteIndexes.Count);

   for (int i = 0; i < quoteIndexes.Count; i++) {
      sb.Insert(quoteIndexes[i] + i, '"');
   }

   return sb.ToString();
}