将JSON多路树解码为F＃多路树识别联盟(Decode JSON Multiway Tree into an F# Multiway Tree Discriminated Union)

 简单的答案是[.\n]可能不会做你认为它做的事情。 在字符类中，大多数元字符都失去了它们的特殊含义，因此字符类只包含两个字符：文字. 和换行符。 你应该使用(.|\n) 。 
 
 但这不会解决问题。 
 
 根本原因是使用固定的重复计数。 如果匹配区域的末端不明确，则大的（或甚至不那么大的）重复计数可导致状态机的指数爆炸。 
 
 随着[.\n]的重复，重复匹配具有明确的终止，除非正则表达式的其余部分可以以点或换行符开头。 所以"." 触发问题，但"A"没有。 如果您更正重复以匹配任何字符，则任何后续字符都将触发指数性爆炸。 因此，如果您进行上述建议的更改，则正则表达式将继续无法编译。 
 
 将重复次数更改为无限重复（星型运算符）可以避免此问题。 
 
 
 为了说明这个问题，我使用-v选项检查具有不同重复次数的状态数。 这清楚地显示了状态计数的指数增加，并且显然不可能超过14次重复。 （我没有显示时间消耗;足以说flex的算法在DFA的大小上不是线性的，所以虽然每次额外的重复都会使状态数量增加一倍，但它大约是时间消耗的四倍;在16个州flex需要45秒，所以假设它需要大约一个星期才能完成23次重复是合理的，前提是它需要的6GB内存可以在没有太多交换的情况下使用。我没有尝试实验。） 
 
$ cat badre.l
%%
"on"[ \t\r]*[.\n]{0,XXX}"."[ \t\r]*[.\n]{0,XXX}"from"
$ for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14; do
>   printf '{0,%d}:\t%24s\n' $i \
>      "$(flex -v -o /dev/null <( sed "s/XXX/$i/g" badre.l) |&
>         grep -o '.*DFA states')"
> done
{0,1}:        17/1000 DFA states
{0,2}:        25/1000 DFA states
{0,3}:        41/1000 DFA states
{0,4}:        73/1000 DFA states
{0,5}:       137/1000 DFA states
{0,6}:       265/1000 DFA states
{0,7}:       521/1000 DFA states
{0,8}:      1033/2000 DFA states
{0,9}:      2057/3000 DFA states
{0,10}:     4105/6000 DFA states
{0,11}:    8201/11000 DFA states
{0,12}:   16393/21000 DFA states
{0,13}:   32777/41000 DFA states
{0,14}:   65545/82000 DFA states
 
 将正则表达式改为使用(.|\n)两次重复大致使状态数量增加三倍，因为随着这种改变， 两次重复都变得模糊不清（并且两者之间存在交互）。 

The simple answer is that [.\n] probably doesn't do what you think it does. Inside a character class, most metacharacters lose their special meaning, so that character class contains only two characters: a literal . and a newline. You should use (.|\n).
 
But that won't solve the problem.
 
The underlying cause is the use of a fixed repetition count. Large (or even not so large) repetition counts can result in exponential blow-up of the state machine, if the end of the matched region is ambiguous. 
 
With the repetition of [.\n], the repeated match has an unambiguous termination unless the rest of the regex can start with a dot or a newline. So "." triggers the problem, but "A" doesn't. If you correct the repetition to match any character, then any following character will trigger exponential blow-up. So if you make the change suggested above, the regular expression will continue to be uncompilable.
 
Changing the repetition count to an indefinite repetition (the star operator) would avoid the problem.
 
 
To illustrate the problem, I used the -v option to check the number of states with different repetition counts. This clearly shows the exponential increase in state count, and it's obvious that going much further than 14 repetitions would be impossible. (I didn't show the time consumption; suffice it to say that flex's algorithms are not linear in the size of the DFA, so while each additional repetition doubles the number of states, it roughly quadruples the time consumption; at 16 states, flex took 45 seconds, so it's reasonable to assume that it would take about a week to do 23 repetitions, provided that the 6GB of RAM it would need was available without too much swapping. I didn't try the experiment.)
 
$ cat badre.l
%%
"on"[ \t\r]*[.\n]{0,XXX}"."[ \t\r]*[.\n]{0,XXX}"from"
$ for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14; do
>   printf '{0,%d}:\t%24s\n' $i \
>      "$(flex -v -o /dev/null <( sed "s/XXX/$i/g" badre.l) |&
>         grep -o '.*DFA states')"
> done
{0,1}:        17/1000 DFA states
{0,2}:        25/1000 DFA states
{0,3}:        41/1000 DFA states
{0,4}:        73/1000 DFA states
{0,5}:       137/1000 DFA states
{0,6}:       265/1000 DFA states
{0,7}:       521/1000 DFA states
{0,8}:      1033/2000 DFA states
{0,9}:      2057/3000 DFA states
{0,10}:     4105/6000 DFA states
{0,11}:    8201/11000 DFA states
{0,12}:   16393/21000 DFA states
{0,13}:   32777/41000 DFA states
{0,14}:   65545/82000 DFA states
 
Changing the regex to use (.|\n) for both repetitions roughly triples the number of states, because with that change both repetitions become ambiguous (and there is an interaction between the two of them).