Malling - Off-script Coding ARAM for Expert/Advanced

n the ther hand, it is als a fine illustratin f the imprtance f a gd algrithm. If a pattern includes several .* sequences, the straightfrward implementatin requires a lt f backtracking, and, in sme cases, will run very slwly indeed.

he standard Unix grep has the same backtracking prperties. Fr example, the cmmand:

grep 'a.a. a.*a.a'

takes abut 20 secnds t prcess a 4 MB text file n a typical machine.

n implementatin based n cnverting a nndeterministic finite autmatn t a deter-ministic autmatn, as in egrep, will have much better perfrmance n hard cases; it can prcess the same pattern and the same input in less than ne-tenth f a secnd, and run-ning time in general is independent f the pattern.

Extensins t the regular expressin class can frm the basis f a variety f assignments.

Fr example:

dd ther metacharacters, such as + fr ne r mre ccurrences f the previus character, r ? fr zer r ne matches. dd sme way t qute metacharacters, such as \$ t stand fr a literal ccurrence f $.

Separate regular expressin prcessing int a cmpilatin phase and an executin phase. Cmpilatin cnverts the regular expressin int an internal frm that makes the matching cde simpler r allws the subsequent matching t run faster. his separatin is nt necessary fr the simple class f regular expressins in the riginal design, but it makes sense in grep-like applicatins where the class is richer and the same regular expressin is used fr a large number f input lines.

dd character classes such as [abc] and [0-9], which in cnventinal grep ntatin match a r b r c and a digit, respectively. his can be dne in several ways, the mst natural f which seems t be replacing the char* variables f the riginal cde with a structure:

typedef struct RE {

int
type;
/* CHR, SR, etc. /
int
ch;
/ the character itself */
char
ccl;
/ fr [...] instead /
int
nccl;
/ true if class is negated [^...] */
} RE;

and mdifying the basic cde t handle an array f these instead f an array f characters. Its nt strictly necessary t separate cmpilatin frm executin fr this situatin, but it turns ut t be a lt easier. Students wh fllw the advice t pre-cmpile int such a structure invariably d better than thse wh try t interpret sme cmplicated pattern data structure n the fly.

Writing clear and unambiguus specificatins fr character classes is tugh, and implementing them perfectly is wrse, requiring a lt f tedius and uninstructive cding. I have simplified this assignment ver time, and tday mst ften ask fr Perl-like shrthands such as \d fr digit and \D fr nndigit instead f the riginal bracketed ranges.

REGULR EXPRESSIN MCHER 7

www.velk.uk

Use an paque type t hide the RE structure and all the implementatin details. his is a gd way t shw bject-riented prgramming in C, which desnt supprt much beynd this. In effect, this creates a regular expressin class that uses functin names like RE_new( ) and RE_match( ) fr the methds instead f the syntactic sugar f an bject-riented language.

Mdify the class f regular expressins t be like the wildcards in varius shells: matches are implicitly anchred at bth ends, * matches any number f characters, and ? matches any single character. ne can mdify the algrithm r map the input int the existing algrithm.

Cnvert the cde t Java. he riginal cde uses C pinters very well, and its gd practice t figure ut the alternatives in a different language. Java versins use either String.chart (indexing instead f pinters) r String.substring (clser t the pinter versin). Neither seems as clear as the C cde, and neither is as cmpact. lthugh perfrmance isnt really part f this exercise, it is interesting t see that the Java implementatin runs rughly six r seven times slwer than the C versins.

Write a wrapper class that cnverts frm this classs regular expressins t Javas Pattern and Matcher classes, which separate the cmpilatin and matching in a quite different way. his is a gd example f the dapter r Facade pattern, which puts a different face n an existing class r set f functins.

Ive als used this cde extensively t explre testing techniques. Regular expressins are rich enugh that testing is far frm trivial, but small enugh that ne can quickly write dwn a substantial cllectin f tests t be perfrmed mechanically. Fr extensins like thse just listed, I ask students t write a large number f tests in a cmpact language (yet anther example f ntatin) and use thse tests n their wn cde; naturally, I use their tests n ther students cde as well.

Cnclusin

I was amazed by hw cmpact and elegant this cde was when Rb Pike first wrte itit was much smaller and mre pwerful than I had thught pssible. In hindsight, ne can see a number f reasns why the cde is s small.

First, the features are well chsen t be the mst useful and t give the mst insight int implementatin, withut any frills. Fr example, the implementatin f the anchred pat-terns ^ and $ requires nly three r fur lines, but it shws hw t deal with special cases cleanly befre handling the general cases unifrmly. he clsure peratin * must be present because it is a fundamental ntin in regular expressins and prvides the nly way t handle patterns f unspecified lengths. But it wuld add n insight t als prvide

and ?, s thse are left as exercises.

8 CHPER NE

www.velk.uk

Secnd, recursin is a win. his fundamental prgramming technique almst always leads t smaller, cleaner, and mre elegant cde than the equivalent written with explicit lps, and that is the case here. he idea f peeling ff ne matching character frm the frnt f the regular expressin and frm the text, then recursing fr the rest, eches the recursive structure f the traditinal factrial r string length examples, but in a much mre inter-esting and useful setting.

hird, this cde really uses the underlying language t gd effect. Pinters can be mis-used, f curse, but here they are used t create cmpact expressins that naturally express the extracting f individual characters and advancing t the next character. rray indexing r substrings can achieve the same effect, but in this cde, pinters d a better jb, especially when cupled with C idims fr autincrement and implicit cnversin f truth values.

I dnt knw f anther piece f cde that des s much in s few lines while prviding such a rich surce f insight and further ideas.

REGULR EXPRESSIN MCHER 9

www.velk.uk

www.velk.uk

Chapter 2

CHPER W

Subversins Delta Editr: Interface s ntlgy

Karl Fgel

EXMPLES F BEUIFUL CDE END BE LCL SLUINS t well-bunded, easily cmprehen-sible prblems, such as Duffs Device (http://en.wikipedia .rg/wiki/Duffs_device) r rsyncs rlling checksum algrithm (http://en.wikipedia .rg/wiki/Rsync#lgrithm). his is nt because small, simple slutins are the nly beautiful kind, but because appreciating cmplex cde requires mre cntext than can be given n the back f a napkin.

Here, with the luxury f several pages t wrk in, Id like t talk abut a larger srt f beautynt necessarily the kind that wuld strike a passing reader immediately, but the kind that prgrammers wh wrk with the cde n a regular basis wuld cme t appreci-ate as they accumulate experience with the prblem dmain. My example is nt an alg-rithm, but an interface: the prgramming interface used by the pen surce versin cntrl system Subversin (http://subversi n.tigris.rg) t express the difference between tw directry trees, which is als the interface used t transfrm ne tree int the ther. In Subversin, its frmal name is the C type svn_delta_editr_t, but it is knwn cllqui-ally as the delta editr.

www.velk.uk

Subversins delta editr demnstrates the prperties that prgrammers lk fr in gd design. It breaks dwn the prblem alng bundaries s natural that anyne designing a new feature fr Subversin can easily tell when t call each functin, and fr what pur-pse. It presents the prgrammer with uncntrived pprtunities t maximize efficiency (such as by eliminating unnecessary data transfers ver the netwrk) and allws fr easy integratin f auxiliary tasks (such as prgress reprting). Perhaps mst imprtant, the design has prved very resilient during enhancements and updates.