Regex Considered Harmful: Use Rosie Pattern Language Instead

All Things Open 2016, Raleigh NC
Jamie A. Jennings, Ph.D.
IBM Cloud CTO Office
October, 2016
Regex Considered Harmful:
Use Rosie Pattern Language Instead

These slides describe work I have done for my employer, IBM, but
I am speaking here only for myself, not for IBM.
Disclaimer:

Problem space
“Every day, we create 2.5 quintillion bytes of data” IBM
“But most of it is like cat videos on YouTube” Nate Silver
Estimates are that less than 0.5% of data is ever analyzed!
(Antonio Regalado, MIT Technology Review, https://www.technologyreview.com/s/514346/the-data-made-me-do-it/)

How to parse out the relevant bits?
Est. <0.5% of data is ever analyzed4

IBM Bluemix Garage and the Garage Method
§ Encyclopedia of industry best practices
– Design Thinking
– Lean Startup
– Agile Development
– DevOps
– Cloud
§ to build and deliver innovative solutions
5
http://ibm.com/devops/method
http://ibm.com/bluemix/garage

DevOps Analytics Team:
applying machine learning and other analytics to DevOps data
to improve quality and efficiency of software development
• Logs
• Events
• Metrics
• Logs
• Events
• Metrics
• Logs
• Events
• Metrics
• Logs
• Events
• Metrics
• Logs
• Events
• Metrics
• Logs
• Events
• Metrics
• Logs
• Events
• Metrics
• Logs
• Events
• Metrics
DevOps Analytics Platform (includes Rosie)
Root cause
Analysis
Anomaly
Detection
Impact
Analysis
Business
Results
Web Experience
Analysis
A/B Testing
Analysis
Usage Patterns
Recognition
Correlation between
Usage Patterns and
Business Risk /
Growth Opportunities
Business
data
Business
Objectives
Business
data
Business
Analytics
In:
Out:
6
Disclaimer: This is a manager slide

16/02/08 10:14:33 INFO SparkContext: Running Spark version 1.6.0
16/02/08 10:14:33 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java
[...]
16/02/08 10:14:38 ERROR Executor: Exception in task 1.0 in stage 5.0 (TID 10)
java.lang.NullPointerException
at org.apache.spark.sql.types.Metadata$.org$apache$spark$sql$types$Metadata$$toJsonValue(Metadata.scala:185)
at org.apache.spark.sql.types.Metadata$$anonfun$2.apply(Metadata.scala:172)
at org.apache.spark.sql.types.Metadata$$anonfun$2.apply(Metadata.scala:172)
at
scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:244)
[...]
16/02/08 10:14:38 INFO DAGScheduler: Job 4 failed: collect at
/home/al/dev/git/devopsrca/pydevops/devops/test/rca_test.py:23, took 0.138982 s
Traceback (most recent call last):
File "/home/al/dev/git/devopsrca/pydevops/devops/test/rca_test.py", line 23, in <module>
print ind.collect()
File "/opt/spark-1.6.0-bin-hadoop2.6/python/pyspark/sql/dataframe.py", line 280, in collect
port = self._jdf.collectToPython()
File "/opt/spark-1.6.0-bin-hadoop2.6/python/lib/py4j-0.9-src.zip/py4j/java_gateway.py", line 813, in __call__
File "/opt/spark-1.6.0-bin-hadoop2.6/python/pyspark/sql/utils.py", line 45, in deco
return f(*a, **kw)
Log files: many formats, often mixed in the same file
E.g. Apache Spark logs contain “standard” entries mixed with Java exceptions and Python tracebacks
7

How to spend data science effort? 1. Get data
2. Write
code/expressions
to parse data
3. Test and
correct parser
4. Annotate data
with semantic
tags
5. Write code to
normalize values
6. Write code to
correlate entries
7. Calculate
meta-data
(enumerations,
ranges, etc.)
8. Perform
analytics
Goal:
get right
to the
analytics!
• Recurring estimate: 80% of analysis effort is preparing the data
• Much of the world’s data is unstructured or semi-structured
• Therefore, much of the world’s data needs to be:
• Parsed to extract the useful bits
• Annotated and labeled
• Normalized to standard formats
• Sanitized to hide sensitive bits
• And correlated with related bits of information
8
The key issue is scale:
ü Lots of data formats (“variety”)
ü Lots of data (“volume”)
ü Near-real-time requirements (“velocity”)

Current approaches
“If the only tool you have is a hammer…” Abraham Maslow

Grok’s networking patterns
# Networking
MAC (?:%{CISCOMAC}|%{WINDOWSMAC}|%{COMMONMAC})
CISCOMAC (?:(?:[A-Fa-f0-9]{4}.){2}[A-Fa-f0-9]{4})
WINDOWSMAC (?:(?:[A-Fa-f0-9]{2}-){5}[A-Fa-f0-9]{2})
COMMONMAC (?:(?:[A-Fa-f0-9]{2}:){5}[A-Fa-f0-9]{2})
IPV6 ((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-
4]d|1dd|[1-9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-
9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-
4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-
5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]d|1dd|[1-
9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-
4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]d|1dd|[1-
9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:)))(%.+)?
IPV4 (?<![0-9])(?:(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-
9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2}))(?![0-9])
IP (?:%{IPV6}|%{IPV4})
HOSTNAME b(?:[0-9A-Za-z][0-9A-Za-z-]{0,62})(?:.(?:[0-9A-Za-z][0-9A-Za-z-]{0,62}))*(.?|b)HOST %{HOSTNAME}
IPORHOST (?:%{HOSTNAME}|%{IP})
HOSTPORT %{IPORHOST}:%{POSINT}
10

Regex issue #1: Notoriously hard to read & maintain
§ Dense, cryptic syntax
§ Capabilities vary across implementations
§ Often, well-written expressions by expert programmers look like this:
/^d{4}-d{2}-d{2}Td{2}:d{2}:d{2}.d{2,}+d{4}[s]+[([w]+)/([d]+)][s]+
(OUT|ERR)[s]+.*[(d{4}-d{2}-d{2}
d{2}:d{2}:d{2}.d{2,})][s]+[(.*)][s]+(.*)[s]+-[s]+.*[d{2}m(.*)/i
“Some people, when confronted with a problem, think ‘I know, I'll use regular expressions.’
Now they have two problems.” (Jamie Zawinski, http://regex.info/blog/2006-09-15/247)
11

E.g. matching this 29-character string takes around 36 seconds in Perl*
$input = “aaaaaaaaaaaaaaaaaaaaaaaaaaaaa”;
$re =“a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaaaaaaaa”;
And this real-world example takes around 65 seconds in Perl*
$input = “1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,Bronze,Bronze,Gold,Silver”;
$re = “^(.*?,){29}Gold”;
Regex issue #2: Performance is highly variable
Regular expression matching (w/o extensions) can be implemented very efficiently
– In linear time and constant space in the input size
– Typically with a finite state machine representation
– As in awk and grep
Alas, "the worst-case exponential-time backtracking strategy [is] used almost everywhere
else, including ed, sed, Perl, PCRE, and Python.” (Russ Cox https://swtch.com/~rsc/regexp/regexp2.html)
(*) Perl 5.16.3 darwin-thread-multi-2level
12

Regex issue #1: Notoriously hard to read & maintain
§ Unmaintainable dense, cryptic syntax
§ Un-composable expressions
§ Not portable across implementations
13
Regex issue #2: Performance is highly variable
“The worst-case exponential-time backtracking strategy [is] used almost everywhere else,
including ed, sed, Perl, PCRE, and Python.” (Russ Cox https://swtch.com/~rsc/regexp/regexp2.html)
E.g. matching this 29-character string takes around 36 seconds in Perl*
$input = “aaaaaaaaaaaaaaaaaaaaaaaaaaaaa”;
$re =“a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaaaaaaaa”;
And this real-world example takes around 65 seconds in Perl*
$input = “1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,Bronze,Bronze,Gold,Silver”;
$re = “^(.*?,){29}Gold”;
“Some people, when confronted with a problem,
think ‘I know, I'll use regular expressions.’
Now they have two problems.”
(Jamie Zawinski, http://regex.info/blog/2006-09-15/247)

Regex considered harmful (at scale)
Lessons
(1) Do not use in a big data pipeline
– Not implemented efficiently; performance highly variable
– Limited portability; tied to the necessary scaffolding (Perl, Python, Ruby, Java, js, …)
(2) Avoid long expressions
– Dense syntax; hard to read; nearly impossible to maintain
– But composition is fraught!
(3) Avoid large collections of expressions
– Dense syntax; hard to read; nearly impossible to maintain
– Semantics and capabilities vary across implementations
14

Rosie Pattern Language
“All progress depends on the unreasonable [woman]”
George Bernard Shaw, paraphrased

{"syslog" : {"text" : "2015-08-23T03:36:30-05:00 10.91.62.208 pluto[10991]: "ui1_db1" #80338: max number of [...]",
"pos" : 1,
"subs" : [ {"datetime.datetime_RFC3339" : {"text" : "2015-08-23T03:36:30-05:00",
"pos" : 1,
"subs" : [ {"datetime.full_date_RFC3339" : {"text" : "2015-08-23",
"pos" : 1 } },
{"datetime.full_time_RFC3339" : {"text" : "03:36:30-05:00",
"pos" : 12 } } ] } },
{"network.ip_address" : {"text" : "10.91.62.208",
"pos" : 27 } },
{"process" : {"text" : "pluto[10991]",
"pos" : 40,
"subs" : [ {"common.word" : {"text" : "pluto",
"pos" : 40 } },
{"common.int" : {"text" : "10991",
"pos" : 46 } } ] } },
{"MAX" : {"text" : ""ui1_db1" #80338: max number of retransmissions (20) reached STATE_R1",
"pos" : 54,
"subs" : [ {"common.identifier_plus" : {"text" : "ui1_db1",
"pos" : 55 } },
{"common.int" : {"text" : "80338",
"pos" : 73 } } ] } } ] } }
Rosie Pattern Engine
16

RPL is designed
like a programming
language
17
RPL Language Reference
(Github)

Common syntactic patterns
(Dates, hosts, URLs, etc.)
Rosie Pattern Engine
SYSLOG
patterns
AppABClogs
AppXYZlogs
Salesdata,e.g.
Pattern Generators
Import
RegEx/Grok
DomainSpecific
MachineLearning
RosiePattern
Language
Online
(Run-time)
Offline
PatternGeneration
GUI
Rosie
(pattern definitions)
Architecture
RPL Pattern
Generators
are a focus of
ongoing work
• Rosie Pattern Language compiler and runtime
• Lua interpreter, Parsing Expression Grammar and JSON libraries
• TOTAL: ~350 KB binary on disk, ~2.5 MB in memory
RPL
patterns are
loaded into
the Rosie
Pattern
Engine
18
INFO: 2023 * Client in-bound response
2023 < 200
2023 < Content-Length: 3714
2023 < Date: Mon, 30 Mar 2015 06:01:26
2023 < Connection: keep-alive
2023 <
{"stacks": [{"description": "A document-
based template to configure your Software
Defined Environment.n", "links": [{"href":
"http://9.32.152.95:8004
Spark,
Kafka,
Cassandra,
etc.
INPUT: Raw data
OUTPUT: Tidy data
in JSON structures,
ready for analysis
Rosie Pattern
Engine
Run-time view
Patterns

Demo
“I want to believe” Fox Mulder, FBI

Highlights of Rosie Pattern Language (1)
Patterns are written like programs
• To match a literal string, put it in quotes
• Otherwise, it’s an identifier
• Identifiers are defined using assignment
statements
• When an identifier used within a pattern is
matched, it appears as a sub-match in the
output
Read/eval/print loop
prompt
(for interactive
pattern development)
Shorthand version of
JSON output contains:
Pattern name, position in
input, matching text, and
sub-matches
Pattern to match
Input to match
against
Notes
1. Patterns entered at the command line do not have names, so they are
represented by a “*” in the output in place of a name
2. A named pattern, such as “h” in this example, becomes a sub-match
3. A pattern is allowed to match a prefix of the input text
20

RPL Patterns share a lot with regular expressions
• $ . * ? + and bounded repetition, for example
• Character sets such as [:alpha:] and [A-F]
Some differences are:
• The choice operator is “/” and is ordered choice
• Parentheses are for grouping only
• Tokenization is automatic, but is disabled for
expressions inside curly braces {…}
(And in other places where tokenizing would be the wrong
thing to do, e.g. quantified expressions like d+. Generally,
Rosie tries to “do the right thing”.)
Ask Rosie what is the
definition of the
identifier “d”
Notes
1. There are hundreds of patterns in the RPL library
2. The RPL tokenizer behaves much like the word boundary operator in
regex, where it must be explicitly written as b
3. The parentheses in (d{2,3})+ are needed for proper tokenization
4. Without curly braces, the pattern “9” d d will match a 9 followed by two
more digits as separate tokens
This pattern matches
a sequence of exactly
2 or 3 digits
By adding a “+”, we
can match one or
more of the 2-or-3-
digit sequences
This pattern says:
Match a “9” followed by 2
more digits, OR (if that
fails) match everything
21

22
RPL Patterns are typically saved in files
• The Rosie Pattern Engine reads (and
compiles) RPL files
• There are hundreds of useful patterns
available in RPL packages, including:
• Timestamps in various formats
• Network addresses, paths
• Various log file formats
• Numbers, identifiers, etc.
An excerpt from rpl/network.rpl in the Rosie distribution: Comments start
with a double dash.
Note also the ability
to use whitespace
for readability
Note: Rosie does parse out the month, day, year, etc. separately. Those sub-
matches are not shown here for clarity.

The command-line interface to the Rosie Pattern
Engine reads pattern definitions from RPL files,
and matches against input from files
The “patterns”
option lists the
patterns loaded, and
the color in which
matches will appear
Any text can be
used as input
This pattern finds
lines that start with a
word followed by a
network address
Notes
1. There are hundreds of patterns in the RPL library
2. The single quotes on the command line prevent the shell from
interpreting characters (such as dot) in the RPL pattern
3. Rosie Pattern Engine generates JSON. The JSON is converted
to just the matching text and printed in color because this is
easier to read in a terminal window
4. In this example:
• Punctuation prints in black
• Words print in yellow, and likely identifiers in cyan
• Network addresses print in red
• Numbers, including hex, print as underlined
Basic.matchall is
pattern that looks for a few
dozen common patterns,
anywhere in the input
Highlights (4): CLI
23

The Rosie Pattern Engine has a read/eval/print loop that
can be used to develop and test patterns. Existing
patterns are available, and new patterns can be defined.
A detailed trace explains how a pattern matches (or
fails) against sample input.
A pattern name evaluates
to its definition, which
Rosie then displays
The input “0x3C”
matches
common.number,
generating a match
structure
Notes
1. The “.eval” command always produces a trace, whether the
match succeeds or fails.
2. The “.match” command by default prints a trace when a match
fails.
3. The effect of automatic tokenization is shown explicitly in the
trace output, where Rosie shows the step of matching
BOUNDARY (the inter-token boundary).
4. In this example, Rosie looks for BOUNDARY only after the
common.number is matched, and the end of the input
successfully matches BOUNDARY.
The “.eval” command takes
the same arguments as
“.match” and prints a trace
(highlighted at left) of the
matching process
Highlights (5):
Interactive Pattern
Development
24

Notes
1. The basic.matchall pattern can be used to
quickly see what Rosie can already
recognize in an input file
2. Then, more complex patterns can be
assembled interactively using existing
patterns
3. Here, the input files are Apache Spark logs
4. The logs contain a mix of Python and Java
information
Output generated using this RPL code
RPL code written to parse Apache Spark logs
RPL for root cause analysis
25

Design & Implementation
“Simplicity does not precede complexity, but follows it.” Alan Perlis

RPL is a language of parser combinators
Parser combinators are
– Recursive descent parsers
– Based on higher order functions
– Considered easy to read
– Often used to parse CFLs
– Recognizes deterministic CFLs
– Combinators are:
§ Sequence
§ Ordered choice
§ Quantified expressions
§ Predicates: look ahead, look behind, negation
– Tokenized (“cooked”) and untokenized (“raw”) expressions
27

Patterns in the RPL library (at present)
§ Basic
– number, identifier, word, and more
– and quoted/bracketed versions
§ Commonly used and specific
– int, float, hex, and other numbers
– several kinds of identifiers
– path names for Unix and Windows
– GUIDs
§ Network patterns
– ip address, domain name, email address,
http url and commands
§ Timestamps
– RFC3339, RFC2822, and more than a dozen
other common formats
§ CSV data
– delimiters: , ; |
– quoted fields: “foo” or ‘bar’
– escapes: "" or " or "”
§ JSON data
– full parse, or
– match nested and balanced {} []
§ Log files
– syslog constituents (covers most log files)
– Java exceptions, Python tracebacks
§ Source code (micro-grammar approach)
– Extract line and block comments
– Extract code (no comments)
– Python, Ruby, Perl, js, Java, Perl, C, C++, …
28

Performance
29
seconds
input size (# log entries)
Rosie
JGrok
Grok
Single threaded!
Few optimizations!
(0.5M) (2M)

Other capabilities, current and forthcoming
30
§ Lexical scope (nested environments)
§ Modules have their own environments
with import/export controls (forthcoming)
§ “Macros” (i.e. pattern generating
functions)
– Have Lua functions for AST à AST
– Need more experimentation
§ Post-processing instructions (forthcoming)
– Match à Match
– Lua as extension language
– Uses include
§ Format conversion
§ Sanitizing and anonymizing
§ Meta-data collection
Language
§ Self-hosting
– Allows easy language modifications
– A compiler extension interface would allow
language extensions
§ Interfaces: API, CLI, REPL
– Native APIs in C and Lua
– C API is auto-generated from Lua API
§ Foreign function interface: librosie
– Sample clients in
Python, Perl, Ruby, js, Go, Lua
– Grok replacement (for ELK stack)
§ Output generator is a Lua function
§ Persist compiled patterns to disk (forthcoming)
§ More debugging capabilities (forthcoming)
Implementation

Conclusion
31
§ Rosie Pattern Language
– Designed for parsing “in the large”
– More expressive than regex
– With in-line automated tokenization
– And many features commonly found in programming languages
§ Rosie Pattern Engine
– Small (~ 350 KB on disk, ~ 2.5 MB memory) and relatively fast (around 4x competition)
– With pattern development tools
§ REPL
§ Debugger
“Eval” (interpreter) shows full match trace
Future: breakpoints, single step, single identifier trace
– Implemented in Lua, using LPEG
– Released as open source in February, 2016

The End
“Turn out the lights, the party’s over” Willie Nelson, “The Party’s Over”
Open Source Software, MIT License
Github (public) https://github.com/jamiejennings/rosie-pattern-language/
IBM developerWorks Open (tutorials, blog) https://developer.ibm.com/open/rosie-pattern-language/

Implementation details (v0.92b)
33
Component Implementation language Description Location
“Sample” RPL patterns Rosie Pattern Language (RPL) 100’s of patterns:
• Numbers, identifiers
• Network, email addrs
• Many dates & times
• Syslog elements
• Etc.
Public github
MIT License
https://github.com/jamiejennings/rosie-
pattern-language/tree/master/rpl
Rosie REPL
Rosie CLI
Rosie Debugger
Lua ~ 600 lines of Lua code
~ 25 lines of RPL
These leverage the API
Public github
MIT License
https://github.com/jamiejennings/rosie-
pattern-languageRosie API Native: Lua, C
Others: via libffi
~ 20 functions
Rosie Compiler Lua
(parser in RPL, bootstrap in Lua/LPEG)
~ 1300 lines of Lua code
~ 60 lines of RPL
LPEG
CJSON
ANSI C Lua PEG library ~ 46 Kb
Lua JSON library ~ 54 Kb
Public web, MIT License
http://www.inf.puc-rio.br/~roberto/lpeg/
Lua ANSI C Lua interpreter ~ 224 Kb Public web, MIT License
http://lua.org

Rosie Pattern Engine API
§ Engine management
– New engine
– Configure engine
– Delete engine
– Query engine configuration
– Query engine environment
– Future: Set logging level
§ Environment (per engine)
– Load string (RPL definitions)
– Load file (RPL definitions)
– Load manifest (files of RPL definitions)
– Erase environment
§ Matching (per engine)
– Match against string
– Match against file
§ Debugging (per engine)
– Eval against input string (full trace)
– Eval against input file (full trace)
– Future:
§ Trace single identifier (combinator)
§ Breakpoint
34

Rosie is self-hosting
§ Rosie is a parser, and Rosie is used to parse Rosie Pattern Language
§ About 60 lines of RPL (core) to define the current RPL (v0.99)
§ Capabilities (e.g. syntax error reporting) made for RPL itself can be applied to user patterns,
and vice-versa (e.g. macros)
§ Ability to support multiple versions of RPL, even different dialects
§ Non-trivial user extensions to RPL can be had by:
– Specifying RPL for the extension (to RPL)
– Writing a compiler “plug-in” for the extension
– The compiler plug-in interface has not yet been designed
35

Tokenization is non-trivial
§ Token boundary
– Token boundary is denoted “~”
– Has a default value (approx. b)
– Default is idempotent
– Is redefinable!
– User’s definition may not be
idempotent
§ Requires careful implementation
§ E.g. implementation of (p)* in Lua/lpeg:
peg = (p * (~ * p)^0)^-1
36
a a a~a
(a a) a~a
{a a} aa
a+ aaaa...a
a+ b aaaa...a~b
(a)+ a~a~a~a~...~a
(a)+ b a~a~a~a~...~a~b
(a / b) a
b
(a / b) c a~c
b~c
{{a / b} c} ac
bc
{(a / b) c} ??? à Same as {{a / b} c}
(a b)+ a~b~a~b~...a~b
{a b}+ ababab...ab
(a b)+ c a~b~a~b~...~c
{a b}+ c abab...ab~c
RPL Meaning

Parsing Expression Grammars
§ Rosie’s operators
– Parsing Expression Grammars
– Instead of CFG or regex
– Express all deterministic CFLs
– And some non-CFLs, e.g. anbncn
§ PEGs [Ford, 2004]
– Scanner-less parsing
– Compare to regular expressions
§ Greedy quantifiers: *, +, ?
§ Ordered choice operator: /
§ Predicates: “looking at”, “not looking at”
– Linear time algorithms
– Languages recognized by PEGs are
§ A superset of regular languages
§ All languages recognized by LL(k) and LR(k) parsers
37

Infinite loop in Perl RE?
§ Claimed on stack exchange that this regex never terminates?
– See ‘man perlre’
– 'foo' =~ m{ ( o? )* }x;
– “Perl has special code to detect infinite recursion in this case and break out.”
– Alex Brown Dec 7 '10 at 16:09
§ http://stackoverflow.com/questions/4378455/what-is-the-complexity-of-regular-expression
38

Regex Considered Harmful: Use Rosie Pattern Language Instead

More Related Content

What's hot

Viewers also liked

Similar to Regex Considered Harmful: Use Rosie Pattern Language Instead

More from All Things Open

Recently uploaded

Regex Considered Harmful: Use Rosie Pattern Language Instead