In computer programming, leaning toothpick syndrome (LTS) is the situation in which a quoted expression becomes visually confusing because it contains a large number of escape characters to avoid delimiter collision (i.e., to avoid ambiguous, non-deterministic interpretations in the program).
Escape characters are usually backslashes (\), but can be other character types as well. An example of LTS would be /^\\\/\\+\/\\?\/\\$/. Leaning Toothpick Syndrome is named as such due to the visual appearance of each backslash (or forward slash, another common escape character) resembling a leaning toothpick, combined with LTS-suffering strings containing a large number of the tilted slashes. LTS appears in many programming languages and in many situations, including in patterns that match Uniform Resource Identifiers (URIs), programs that manipulate files and their contents, and programs that output quoted text (i.e., text that either contains quote characters, is surrounded by quote characters, or both). Many quines fall into the latter category. The official Perl documentation introduced the term to wider usage; there, the phrase is used to describe regular expressions that match Unix-style paths, in which the elements are separated by slashes /. The slash is also used as the default regular expression delimiter; so to be used literally in the expression, it must be escaped with a backslash \, leading to frequent escaped slashes represented as \/. If doubled, as in URLs, this yields \/\/ for an escaped //. A similar phenomenon occurs for MS-DOS and Windows paths, where the backslash is used as a path separator, such as in C:\Users\Amy\Desktop\Q1-report.pdf, rather than a Unix-style /home/Amy/Desktop/Q1-report.pdf with forward slashes. As a result of using \ for paths instead of /, Windows typically requires extra escape characters when compared to Unix-style paths. Therefore, Windows paths are more likely to cause frustration to programmers.
MS Windows paths, string storage, regex When doing any file operations that require storing (as opposed to immediately using) Windows-style paths, the operations require the path to have a doubled-up backslash \\ for each original backslash, creating C:\\Users\\Amy\\Desktop\\Q1-report.pdf.
The now-storable path string can then be re-escaped for use inside a regular expression (still inside an escaped string), requiring \\\\ to "match" a single backslash in the original text.
Parsing-wise, the order of conversions/"escapes" is ({\\}{\\}). The two innermost parts, {\\} and {\\}, are used for merely storing the string inside a program. After storage, the outermost part, (...), now equivalent to \\ as the entire string, then proceeds to be used for the regular expression where the resulting \\ is to be interpreted as \(special regex matching operator to be used with ambiguous symbols) \(single symbol to be matched) rather than \(single symbol to be matched) \(single symbol to be matched). Note that {},[],() in these parsing diagrams are meant to indicate human-readable groupings, not any reserved regex groupings such as equivalence classes and \( \) atoms for callbacks.
Pattern example Consider the following Perl regular expression intended to match URIs that identify files under the pub directory of an FTP site:
Perl, like sed before it, solves this problem by allowing many other characters to be delimiters for a regular expression. For example, the following three examples are equivalent to the expression given above:
m{ftp://[^/]*/pub/} m#ftp://[^/]*/pub/# m!ftp://[^/]*/pub/!
Or this common translation to convert backslashes to forward slashes:
may be easier to understand when written like this:
Text With Quotes - Perl & PHP example A Perl program to print an HTML link tag, where the URL and link text are stored in variables $url and $text respectively, might look like this. Notice the use of backslashes to escape the quoted double-quote characters:
Using single quotes to delimit the string is not feasible, as Perl does not expand variables inside single-quoted strings. The code below, for example, would not work as intended:
Using the printf function is a viable solution in many languages (Perl, PHP):
The qq operator in Perl allows for any delimiter:
Here documents are especially well suited for multi-line strings; however, Perl here documents hadn't allowed for proper indentation before v5.26. This example shows the Perl syntax:
Other languages
C# The C# programming language handles LTS by the use of the @ symbol at the start of string literals, before the initial quotation marks, e.g.
rather than otherwise requiring:
C++ The C++11 standard adds raw strings:
If the string contains the characters )", an optional delimiter can be used, such as d in the following example:
Go Go indicates that a string is raw by using the backtick as a delimiter:
Raw strings may contain any character except backticks; there is no escape code for a backtick in a raw string. Raw strings may also span multiple lines, as in this example, where the strings s and t are equivalent:
Python Python has a similar construct using r:
One can also use them together with triple quotes:
R R has a similar construct using r or R with various bracket deliminators ((, [, {):
For raw strings that contain ( instances
For additional flexibility, a number of dashes can be placed between the opening quote and the opening delimiter, as long as the same number of dashes appear between the closing delimiter and the closing quote.
Ruby Ruby uses single quote to indicate raw string:
It also has regex percent literals with choice of delimiter like Perl:
Rust Rust uses a variant of the r prefix:
The literal starts with r followed by any number of #, followed by one ". Further " contained in the literal are considered part of the literal, unless followed by at least as many # as used after the opening r. As such, a string literal opened with r#" cannot have "# in its content.
Scala Scala allows usage of triple quotes in order to prevent escaping confusion:
The triple quotes also allow for multiline strings, as shown here:
Sed Sed regular expressions, particularly those using the "s" operator, are much similar to Perl (sed is a predecessor to Perl). The default delimiter is "/", but any delimiter can be used; the default is s/regexp/replacement/, but s:regexp:replacement: is also a valid form. For example, to match a "pub" directory (as in the Perl example) and replace it with "foo", the default (escaping the slashes) is
… excerpt ends here. Continue reading the full article.
