Comment simplifier cette méthode (en séparant les guillemets sans guillemets, sans crochets, sans échappement)?

Question

curieux de savoir si cela peut être simplifié ...

internal static IEnumerable<string> Split(string str, char sep = ',') 
{ 
    int lastIndex = 0; 
    bool quoted = false; 
    bool escaped = false; 
    bool bracketed = false; 
    char lastQuote = '\0'; 

    for (int i = 0; i < str.Length; ++i) 
    { 
     if (str[i] == '[') 
     { 
      if (!quoted && !escaped) 
       bracketed = true; 
      escaped = false; 
     } 
     else if (str[i] == ']') 
     { 
      if (!quoted && !escaped) 
       bracketed = false; 
      escaped = false; 
     } 
     else if (str[i] == '\\') 
     { 
      escaped = !escaped; 
     } 
     else if (str[i] == '"' || str[i] == '\'') 
     { 
      if (!escaped) 
      { 
       if (quoted) 
       { 
        if (lastQuote == str[i]) 
         quoted = false; 
       } 
       else 
       { 
        quoted = true; 
        lastQuote = str[i]; 
       } 
      } 
      escaped = false; 
     } 
     else if (str[i] == sep) 
     { 
      if (!quoted && !escaped && !bracketed) 
      { 
       yield return str.Substring(lastIndex, i - lastIndex); 
       lastIndex = i + 1; 
      } 
      escaped = false; 
     } 
     else 
     { 
      escaped = false; 
     } 
    } 

    yield return str.Substring(lastIndex); 
} 

A écrit cette méthode pour diviser sur des virgules qui ne sont pas à l'intérieur [], ne sont pas traités et ne sont pas échappés. Est-ce que c'est un problème intrinsèquement difficile, ou est-ce que j'ai pris une approche stupide?

Entrée:

foreach(var sel in SharpQuery.SplitCommas("\"comma, in quotes\", comma[in,brackets], comma[in \"quotes, and brackets\"], \"woah, 'nelly,' \\\"now you,re [talking, crazy\\\"\"")) { 
    Console.WriteLine(sel); 
} 

Sortie prévue:

"comma, in quotes" 
comma[in,brackets] 
comma[in "quotes, and brackets"] 
"woah, 'nelly,' \"now you,re [talking, crazy\"" 

Answer 1

Un peu d'un choix difficile à garder votre état d'automate. J'utiliserais une seule variable ou une pile dans ce cas. Donc, votre état actuel est toujours stateStack.Peek(). Facile à lire. Facile à gérer les états imbriqués.

edit: heres un exemple rapide. Je suis sûr que vous pouvez l'étendre pour ajouter la gestion des erreurs et les spécificités de vos règles.

enum ParserState 
    { 
     Text, 
     Bracketed, 
     Quoted, 
     EscapChar, 
    } 

    internal static IEnumerable<string> Split(string str, char sep) 
    { 
     int lastIdx = 0; 
     char c; 
     ParserState s; 
     Stack<ParserState> state = new Stack<ParserState>(); 
     state.Push(ParserState.Text); 

     for (int i = 0; i < str.Length; i++) 
     { 
      c = str[i]; 
      s = state.Peek(); 

      if (s == ParserState.EscapChar 
       || (s == ParserState.Bracketed && c == ']') 
       || (s == ParserState.Quoted && c == '"')) 
      { 
       state.Pop(); 
      } 
      else if (c == '[') 
       state.Push(ParserState.Bracketed); 
      else if (c == '"') 
       state.Push(ParserState.Quoted); 
      else if (c == '\\') 
       state.Push(ParserState.EscapChar); 
      else if (s == ParserState.Text && c == sep) 
      { 
       yield return str.Substring(lastIdx, i - lastIdx); 
       lastIdx = i + 1; 
      } 
     } 
     yield return str.Substring(lastIdx); 
    }