3 -Remove the 'noend' write option from examples/atoi.rl. This example is
4 referenced a lot as a first example and as such it shouldn't contain a
5 special purpose write option like 'noend'.
6 -Introcuded the "eof" variable for indicating the end of file. The p variable
7 is checked against eof when the processing loop reaches the end of a block.
8 If p == eof at this time then the EOF actions are executed. The variable is
9 required only when EOF actions have been emebedded.
10 -The "write eof" command is no longer needed and was removed.
11 -Scanners now use EOF actions to generate tokens. This eliminates the need to
13 -Restructured the Java driver; a switch statement with fallthrough cases are
14 now used to emulate gotos.
15 -Ruby code generation was also restructured. Gotos are elmulated using a
17 -Gone back to 3.X semantics for >, % and error actions. The > operator also
18 embeds a leaving action/priority into the start state if it is final. If EOF
19 happens in a state with a leaving operator then leaving action it is
20 executed. If EOF happens in a non-final state that has an error action, the
21 error action is executed.
22 -The Ragel program now executes frontend and backend processes separately,
23 connecting them with a temporary file in the current directory. Without the
24 -f option the "ragel" program marshals arguments and calls the frontend and
25 backend. With the -f option the "ragel" program acts as the frontend only.
26 -Added name finding for executables. If any forward slash is found in argv0
27 then it is assumed that the path is explicit and the path to the backend
28 executable should be derived from that. Whe check that location and also go
29 up one then inside a directory of the same name in case we are executing
30 from the source tree. If no forward slash is found it is assumed the file is
31 being run from the installed location. The PREFIX supplied during
32 configuration is used.
33 -On windows GetModuleFileNameEx is used to find out where the the current
34 process's binary is. That location is searched first. If that fails then we
35 go up one directory and look for the executable inside a directory of the
36 same name in case we are executing from the source tree.
37 -Changed the -l option in rlgen-cd to -L because it is covered in the
38 frontend. Added a passthrough in the frontend for the backend options.
39 -Dot file generation can now be invoked using the -V option to the parent. We
40 now require an input file. If standard in is used then we don't have a file
41 name on which to base the output.
42 -Rather than have the frontend process call the backend, the ragel program
43 now calls the frontend (itself with the -f option) and the backend.
44 -Able to build native windows executables using Cygwin+MinGW.
45 -Patch from David Waite: Large arrays are now created by copying in the data
46 from smaller arrays using System.arraycopy(). This eliminates the debug data
47 associated with explicit initialization statements. It is also much easier
48 on the java compiler which can run out of memory compiling very large
49 machines. The downside is that it takes slightly longer to initialize static
51 -The fbreak statement now advances p.
52 -In the :> :>> and <: operators it was possible for the priority assignment
53 to be bypassed via the zero length string. In :> this was fixed
54 automatically with the semantics change to the entering priority operator.
55 If the start state is final it now embeds a leaving action into it,
56 preventing persistance through the zero length string. In :>> and <: this
57 was fixed explicitly. With <: the entering priority operator was used and
58 with :> a sepecial exception was added. Since it uses the finishing
59 transition operator it also adds a leaving priority to the start state if it
61 -Ranlib is now run on the archives. Patch from Kenny MacDermid.
62 -The case statement syntax in ruby code generation used a form depreciated in
64 -Made a number of fixes that eliminate warnings in GCC 4.3. Mostly concern
65 the now depreciate automatic conversion of string contsants to "char*" type.
66 Other fixes include adding parenthesis around && within ||.
68 Ragel 5.25 - Dec 24, 2007
69 =========================
70 -Fixed segfault reported by Ryan Phelps. Affected Java and Ruby code
71 generation. The dataExpr variable was not initialized.
72 -Fixed incorrect case label in test/runtests. Caused Objective-C tests to be
74 -Added missing include to common.cpp.
76 Ragel 5.24 - Sep 16, 2007
77 =========================
78 -Applied patch from Victor Hugo Borja <vic@rubyforge.org>. This patch
79 implements -T1 -F0 -F1 and -G0 in the ruby code generator. Goto-driven code
80 generation is experimental and requires rubinius asm directives (specify
81 with --rbx option). These code generators pass all the ruby tests.
82 -If the condition embedding code runs out of available characters in the
83 keyspace an error message is emitted.
84 -The first example that appeared in the manual used the special-purpose
85 'noend' write option. This caused confusion. Now a basic example appears
87 -Added two new statements: prepush and postpop. These are code blocks that
88 are written out during call and return statements. The prepush code is
89 written immediately before pushing the current state to the state stack
90 during a call. The postpop code is written immediately after popping the
91 current state during return. These can be used to implement a dynamically
94 Ragel 5.23 - Jul 24, 2007
95 =========================
96 -Eliminated the use of callcc as an alternative to goto. Instead, the named
97 breaks implementation used in the Java code generator is imitated using
98 control flow variables.
99 -Improved the error message given when there is a write statement but no
100 machine instantiations and hence no state machine.
101 -Documentation improvements: updates to "Machine Instantiation", "Write Init"
102 and "Write Exports" sectons. Added the "Variables Used by Ragel" section.
103 -Renamed "Entering Actions" to "Starting Actions."
104 -Other documentation updates.
106 Ragel 5.22 - June 14, 2007
107 ==========================
108 -Bug fix: need to isolate the start state of a scanner before setting the
109 to-state and from-state actions which clear and set tokstart. This affected
110 very simple scanners only. Most scanners have an isolated start state due to
111 the pattern structure.
112 -Bug fix: when -S or -M was given the ragel version number was not emitted,
113 causing the backend to reject the intermediate format. From Tim Potter.
114 -The p varialbe is now set up at the beginning of a scanner action, rather
115 than at the end. This leaves scanner actions free to manipulate p and
116 removes the need for the special holdTE and execTE (TE for tokend) versions
117 of hold and exec. It also removes the need to set p = tokend-1 immediately
118 before any control flow. We loose the ability to determine where in the
119 input stream a scanner action is executed, however this information is of
120 little use because it is primarily an artifact of the scanner implementation
121 (sometimes the last char, other times later on). The gains of this change
122 are consistency and simplicity.
123 -The "data" variable (used in Java and Ruby code generation only) can now be
124 overridden using the variable statement.
126 Ragel 5.21 - May 9, 2007
127 ========================
128 -Fixed an inconsistency in the value of p following an error. In the C
129 directly executable code (rlgen-cd -G2) p is left at the character where
130 the error occurred, which is correct. In all other code generators it was
131 left at the following character. This was fixed. Now in all code generators
132 p is left at the character where the error occurred.
133 -Bug fix: when fhold was used in scanner pattern actions which get executed
134 on the last character of the pattern (pattern matches which do not require
135 any lookahead), fhold was modifying p instead of tokend. This was fixed and
136 the patact.rl test was modified to cover the case.
137 -Fixed typos in the guide, improved the state action embedding operator
138 section and added subsections on the variable, import, and export
140 -Implemented a better solution than the pri hack for resolving the '-'
141 ambiguity: force a shortest match of term.
142 -Fixed bugs in the binary searching for condition keys in both the Ruby and
143 Java code generation.
144 -Can now embed the negative sense of a condition. Added a language-
145 independent test case for this feature and the necessary transformation
147 -Added new condition embedding syntax:
148 expr inwhen cond - The transitions into the machine (starting transitions).
149 expr outwhen cond - The pending transitions out of the machine.
150 -The argument to the variable statement which affects the name of the current
151 state variable was changed from "curstate" to "cs" (the default name used
152 for the current state)
153 -Implemented the other variables names in the variable statement. Now all
154 variables (p, pe, cs, top, stack, act, tokstart, tokend) can be renamed.
155 -Parse errors in the intermediate XML file now cause the backend to exit
156 immediately rather then forge on. The recovery infrastructure isn't there
157 and segfaults are likely.
158 -When no input is given to the backend program, it should not print an error
159 message, it should just return a non-zero exit status. The assumption is
160 that the frontend printed an error.
161 -The version number is now included in the intermediate file. An error is
162 emitted if there is a mismatch.
163 -The alphabet type is now communicated from the frontend to the backend using
164 a one-word internal name instead of an array offset.
165 -The Ruby host language types had been just copied from Java. Reduced them to
166 two basic types: char and int, both signed with the usual C sizes.
168 Ragel 5.20 - Apr 7, 2007
169 ========================
170 -The cs variable is now always initialized, unless the "nocs" option is given
171 to the write init command. If there is no main machine, cs is initialized to
172 the entry point defined by the last machine instantiation.
173 -A number of fixes were made to the Ruby code generator.
174 -The frontend now scans ruby comments and regular expressions.
175 -A transformation for Ruby was added to the language-independent test suite.
176 The Ruby code generator passes on all the language-independent tests.
177 -A new Ruby test and two language-independent tests were added.
178 -Some portability fixes were made (Patches from Josef Goettgens and Aaron
180 -Fixed a make dependency bug which caused a problem for parallel building
181 (Patch from Jeremy Hinegardner).
183 Ragel 5.19 - Mar 14, 2007
184 =========================
185 -Added an import statement to ragel. This statement takes a literal string as
186 an argument, interprets it as a file name, then scrapes the file for
187 sequences of tokens that match the following forms. Tokens inside ragel
188 sections are ignored. An example is in test/import1.rl
192 "define" name lit_string
193 -Added an export mechanism which writes defines for single character machines
194 that have been tagged with the export keyword in their definition. Defines
195 are used for C, ints for D, Java and Ruby. Examples of the export feature
196 are in test/export*.rl.
197 -All machine instantiations are now always generated, even if they are not
198 referenced. In the backend, entry points for all instantiations are written
199 out alongside start, error and first final states.
200 -If the main machine is not present then do not emit an error. Generate the
201 machine without a start state and do not initialize cs in the write init
203 -Added an option -l to rlgen-cd which inhibits the writing of #line
205 -Added a new syntax for verbose embeddings. This adds parentheses:
207 Verbose embeddings without parentheses can make code difficult to read
208 because they force a space in the middle of an action embedding. There is a
209 tendency to associtate spaces with concatenation. Without syntax
210 highlighting to make it clear that the embedding type is a keyword, the
211 problem is especially bad. The danger is that a verbose embedding could be
212 read as an embedding of the keyword representing the empbedding type. With
213 parentheses, verbose embeddings read much more clearly.
214 -Conditions now have a forced order when more than one is executed on a
215 single character. Previously ordering relied on pointers, which caused
216 results to vary by compiler. Ordering is now done using conditon action
217 declaration order. This fixes the failure of cond4.rl which occured with
218 g++ 4.1 and other compiler versions.
219 -In the port from flex to ragel, the name separator :: in Ragel code was
221 -In the examples directory switched from rlcodegen to rlgen-cd. Silenced a
222 warning in statechart.rl.
223 -In the root makefile the distclean target was fixed. It was calling clean in
224 the subdirs. In docs, the clean target was not deleting the new manpages for
225 the rlgen-* programs. Fixed.
226 -Portability and other fixes from Josef Goettgens were applied.
227 -The @datadir@ and @mandir@ variables are made use of in doc/Makefile.in for
228 specifying where documentation should be installed. Patch from Marcus
231 Ragel 5.18 - Feb 13, 2007
232 =========================
233 -There is now a 100% correspondence between state id numbers in the
234 intermediate XML file, Graphviz dot files and generated code. This was
235 achieved by moving code which determines if the error state is necessary
236 into the frontend, and then assigning state numbers before writing out the
238 -Backened class structure was reorganized to make it easier to add new code
239 generators without having to also modify the existing code generators.
240 -The C and D code generation executable was changed to rlgen-cd.
241 -The Java code generation was split out into it's own exectuable (rlgen-java)
242 to allow it to freely diverge from the C/D-based code generation.
243 -The graphviz dot file generation was also split out to it's own executable
245 -The Ruby code generation patch from Victor Hugo Borja was added. This is
246 highly experimental code and is not yet completely functional. It is in the
247 executable rlgen-ruby.
248 -The problem with large state machine machines in Java was fixed. This
249 problem was discovered by Colin Fleming, who also contributed a patch.
250 Rather than specify arrays as comma-separated lists of literals, array
251 initialization is now done in a static function. This is the approach used
252 by the Java compiler. Unlike the compiler Ragel is careful split large
253 initilization functions.
254 -The manual was expanded and reorganized somewhat.
255 -Eliminated per-example directories in examples/.
256 -Made some fixes to the pullscan.rl example.
257 -In the frontend CR characters are now treated as whitespace.
258 -Updated to the latest aapl. This completely eliminates the shallowCopy
259 function. With that, a definitive memory leak is fixed.
260 -Control codes with escape sequences are now printable characters (-p
261 option). Also, the space character is now printed as SP.
262 -Fixed the null dereference and consequential segfault which occurred when
263 trying to create empty machines with [] and // and /a[]b/.
264 -Fixed the segfault which occured when a machine reference failed.
265 -Discontinuing ragel.spec. It is more appropriate for this to be written by
266 package maintenance developers.
268 Ragel 5.17 - Jan 28, 2007
269 =========================
270 -The scanners and parsers in both the frontend and backend programs were
271 completely rewritten using Ragel and Kelbt.
272 -The '%when condition' syntax was functioning like '$when condition'. This
274 -In the Vim syntax file fixes to the matching of embedding operators were
275 made. Also, improvements to the sync patterns were made.
276 -Added pullscan.rl to the examples directory. It is an example of doing
277 pull-based scanning. Also, xmlscan.rl in rlcodegen is a pull scanner.
278 -The introduction chapter of the manual was improved. The manually-drawn
279 figures for the examples were replaced with graphviz-drawn figures.
281 Ragel 5.16 - Nov 20, 2006
282 =========================
283 -Policy change: the fhold and fexec directives did not function correctly in
284 scanner pattern actions. In this context manipulations of p may be lost or
285 made invalid. In the previous version of Ragel they were banned because of
286 this. Instead of banning these directives they have been fixed. The fexec
287 and fhold directives now manipulate tokend, which is now always used to
288 update p when the action terminates.
290 Ragel 5.15 - Oct 31, 2006
291 =========================
292 -A language independent test harness was introduced. Test cases can be
293 written using a custom mini-language in the embedded actions. This
294 mini-language is then translated to C, D and Java when generating the
295 language-specific test cases.
296 -Several existing tests have been ported to the language-independent format
297 and a number of new language-independent test cases have been added.
298 -The state-based embedding operators which access states that are not the
299 start state and are not final (the 'middle' states) have changed. They
301 <@/ eof action into middle states
302 <@! error action into middle states
303 <@^ local error action into middle states
304 <@~ to-state action into middle states
305 <@* from-state action into middle states
307 <>/ eof action into middle states
308 <>! error action into middle states
309 <>^ local error action into middle states
310 <>~ to-state action into middle states
311 <>* from-state action into middle states
312 -The verbose form of embeddings using the <- operator have been removed.
313 This syntax was difficult to remember.
314 -A new verbose form of state-based embedding operators have been added.
315 These are like the symbol versions, except they replace the symbols:
317 with literal keywords:
319 -The following words have been promoted to keywords:
320 when eof err lerr to from
321 -The write statment now gets its own lexical scope in the scanner to ensure
322 that commands are passed through as is (not affected by keywords).
323 -Bug fix: in the code generation of fret in scanner actions the adjustment to
324 p that is needed in some cases (dependent on content of patterns) was not
326 -The fhold directive, which decrements p, cannot be permitted in the pattern
327 action of a scanner item because it will not behave consistently. At the end
328 of a pattern action p could be decremented, set to a new value or left
329 alone. This depends on the contents of the scanner's patterns. The user
330 cannot be expected to predict what will happen to p.
331 -Conditions in D code require a cast to the widec type when computing widec.
332 -Like Java, D code also needs if (true) branches for control flow in actions
333 in order to fool the unreachable code detector. This is now abstracted in
334 all code generators using the CTRL_FLOW() function.
335 -The NULL_ITEM value in java code should be -1. This is needed for
336 maintaining tokstart.
338 Ragel 5.14 - Oct 1, 2006
339 ========================
340 -Fixed the check for use of fcall in actions embedded within longest match
341 items. It was emitting an error if an item's longest-match action had an
342 fcall, which is allowed. This bug was introduced while fixing a segfault in
344 -A new minimization option was added: MinimizeMostOps (-l). This option
345 minimizes at every operation except on chains of expressions and chains of
346 terms (eg, union and concat). On these chains it minimizes only at the last
347 operation. This makes test cases with many states compile faster, without
348 killing the performance on grammars like strings2.rl.
349 -The -l minimiziation option was made the default.
350 -Fixes to Java code: Use of the fc value did not work, now fixed. Static data
351 is now declared with the final keyword. Patch from Colin Fleming. Conditions
352 now work when generating Java code.
353 -The option -p was added to rlcodegen which causes printable characters to be
354 printed in GraphViz output. Patch from Colin Fleming.
355 -The "element" keyword no longer exists, removed from vim syntax file.
356 Updated keyword highlighting.
357 -The host language selection is now made in the frontend.
358 -Native host language types are now used when specifying the alphtype.
359 Previously all languages used the set defined by C, and these were mapped to
360 the appropriate type in the backend.
362 Ragel 5.13 - Sep 7, 2006
363 ========================
364 -Fixed a careless error which broke Java code generation.
366 Ragel 5.12 - Sep 7, 2006
367 ========================
368 -The -o flag did not work in combination with -V. This was fixed.
369 -The split code generation format uses only the required number of digits
370 when writing out the number in the file name of each part.
371 -The -T0, -F0 and -G0 codegens should write out the action list iteration
372 variables only when there are regular, to state or from state actions. The
373 code gens should not use anyActions().
374 -If two states have the same EOF actions, they are written out in the finish
376 -The split and in-place goto formats would sometimes generate _out when it is
377 not needed. This was fixed.
378 -Improved the basic partitioning in the split code gen. The last partition
379 would sometimes be empty. This was fixed.
380 -Use of 'fcall *' was not causing top to be initialized. Fixed.
381 -Implemented a Java backend, specified with -J. Only the table-based format
383 -Implemented range compression in the frontend. This has no effect on the
384 generated code, however it reduces the work of the backend and any programs
385 that read the intermediate format.
387 Ragel 5.11 - Aug 10, 2006
388 =========================
389 -Added a variable to the configure.in script which allows the building of
390 the parsers to be turned off (BUILD_PARSERS). Parser building is off by
391 default for released versions.
392 -Removed configure tests for bison defines header file. Use --defines=file
394 -Configure script doesn't test for bison, flex and gperf when building of the
395 parsers is turned off.
396 -Removed check for YYLTYPE structure from configure script. Since shipped
397 code will not build parsers by default, we don't need to be as accomodating
398 of other versions of bison.
399 -Added a missing include that showed up with g++ 2.95.3.
400 -Failed configure test for Objective-C compiler is now silent.
402 Ragel 5.10 - Jul 31, 2006
403 =========================
404 -Moved the check for error state higher in the table-based processing loop.
405 -Replaced naive implementations of condition searching with proper ones. In
406 the table-based formats the searching is also table-based. In the directly
407 executed formats the searching is also directly executable.
408 -The minimization process was made aware of conditions.
409 -A problem with the condition implementation was fixed. Previously we were
410 taking pointers to transitions and then using them after a call to
411 outTransCopy, which was a bad idea because they may be changed by the call.
412 -Added test mailbox3.rl which is based on mailbox2.rl but includes conditions
413 for restricting header and message body lengths.
414 -Eliminated the initial one-character backup of p just before resuming
416 -Added the -s option to the frontend for printing statistics. This currently
417 includes just the number of states.
418 -Sped up the generation of the in-place goto-driven (-G2) code style.
419 -Implemented a split version of in-place goto-driven code style. This code
420 generation style is suitable for producing fast implementations of very
421 large machines. Partitioning is currently naive. In the future a
422 high-quality partitioning program will be employed. The flag for accessing
423 this feature is -Pn, where n is the number of partitions.
424 -Converted mailbox1.rl, strings2.rl and cppscan1.rl tests to support the
425 split code generation.
426 -Fixes and updates were made to the runtests script: added -c for compiling
427 only, changed the -me option to -e, and added support for testing the split
430 Ragel 5.9 - Jul 19, 2006
431 ========================
432 -Fixed a bug in the include system which caused malformed output from the
433 frontend when the include was made from a multi-line machine spec and the
434 included file ended in a single line spec (or vice versa).
435 -Static data is now const.
436 -Actions which referenced states but were not embedded caused the frontend to
438 -Manual now built with pdflatex.
439 -The manual was reorganized and expanded. Chapter sequence is now:
440 Introduction, Constructing Machines, Embedding Actions, Controlling
441 Nondeterminism and Interfacing to the Host program.
443 Ragel 5.8 - Jun 17, 2006
444 ========================
445 -The internal representation of the alphabet type has been encapsulated
446 into a class and all operations on it have been defined as C++ operators.
447 -The condition implementation now supports range transitions. This allows
448 conditions to be embedded into arbitrary machines. Conditions are still
450 -More condition embedding operators were added
451 1. Isolate the start state and embed a condition into all transitions
454 2. Embed a condition into all transitions:
455 when cond OR $when cond OR $?cond
456 3. Embed a condition into pending out transitions:
458 -Improvements were made to the determinization process to support pending out
460 -The Vim sytax file was fixed so that :> doesn't cause the match of a label.
461 -The test suite was converted to a single-file format which uses less disk
462 space than the old directory-per-test format.
464 Ragel 5.7 - May 14, 2006
465 ========================
466 -Conditions will not be embedded like actions because they involve a
467 manipulation of the state machine they are specified in. They have therefore
468 been taken out of the verbose action embedding form (using the <- compound
469 symbol). A new syntax for specifying conditions has been created:
470 m = '\n' when {i==4};
471 -Fixed a bug which prevented state machine commands like fcurs, fcall, fret,
472 etc, from being accounted for in from-state actions and to-state actions.
473 This prevented some necessary support code from being generated.
474 -Implemented condition testing in remaining code generators.
475 -Configure script now checks for gperf, which is required for building.
476 -Added support for case-insensitive literal strings (in addition to regexes).
477 A case-insensitive string is made by appending an 'i' to the literal, as in
479 -Fixed a bug which caused all or expressions inside of all regular
480 expressions to be case-insensitive. For example /[fo]o bar/ would make the
481 [fo] part case-insensitive even though no 'i' was given following the
484 Ragel 5.6 - Apr 1, 2006
485 =======================
486 -Added a left-guarded concatenation operator. This operator <: is equivalent
487 to ( expr1 $1 . expr2 >0 ). It is useful if you want to prefix a sequence
488 with a sequence of a subset of the characters it matches. For example, one
489 can consume leading whitespace before tokenizing a sequence of whitespace
490 separated words: ( ' '* <: ( ' '+ | [a-z]+ )** )
491 -Removed context embedding code, which has been dead since 5.0.
493 Ragel 5.5 - Mar 28, 2006
494 ========================
495 -Implemented a case-insensitive option for regular expressions: /get/i.
496 -If no input file is given to the ragel program it reads from standard input.
497 -The label of the start state has been changed from START to IN to save on
498 required screen space.
499 -Bug fix: \0 was not working in literal strings, due to a change that reduced
500 memory usage by concatenating components of literal strings. Token data
501 length is now passed from the scanner to the paser so that we do not need to
502 rely on null termination.
504 Ragel 5.4 - Mar 12, 2006
505 ========================
506 -Eliminated the default transition from the frontend implementation. This
507 default transition was a space-saving optimization that at best could reduce
508 the number of allocated transitions by one half. Unfortunately it
509 complicated the implementation and this stood in the way of introducing
510 conditionals. The default transition may be reintroduced in the future.
511 -Added entry-guarded concatenation. This operator :>, is syntactic sugar
512 for expr1 $0 . expr >1. This operator terminates the matching of the first
513 machine when a first character of the second machine is matched. For
514 example in any* . ';' we never leave the any* machine. If we use any* :> ';'
515 then the any* machine is terminiated upon matching the semi-colon.
516 -Added finish-guarded concatenation. This operator :>>, is syntactic sugar
517 for expr1 $0 . expr @1. This operator is like entry guarded concatenation
518 except the first machine is terminated when the second machine enters a
519 final state. This is useful for delaying the guard until a full pattern is
520 matched. For example as in '/*' any* :>> '*/'.
521 -Added strong subtraction. Where regular subtraction removes from the first
522 machine any strings that are matched by the second machine, strong
523 subtraction removes any strings from the first that contain any strings of
524 the second as a substring. Strong subtraction is syntactic sugar for
525 expr1 - ( any* expr2 any* ).
526 -Eliminated the use of priorities from the examples. Replaced with
527 subtraction, guarded concatenation and longest-match kleene star.
528 -Did some initial work on supporting conditional transitions. Far from
529 complete and very buggy. This code will only be active when conditionals are
532 Ragel 5.3 - Jan 27, 2006
533 ========================
534 -Added missing semi-colons that cause the build to fail when using older
536 -Fix for D code: if the contents of an fexec is a single word, the generated
537 code will get interpreted as a C-style cast. Adding two brackets prevents
538 this. Can now turn eliminate the "access this.;" in cppscan5 that was used to
539 get around this problem.
540 -Improved some of the tag names in the intermediate format.
541 -Added unsigned long to the list of supported alphabet types.
542 -Added ids of actions and action lists to XML intermediate format. Makes it
544 -Updated to latest Aapl package.
546 Ragel 5.2 - Jan 6, 2006
547 ========================
548 -Ragel emits an error if the target of fentry, fcall, fgoto or fnext is inside
549 a longest match operator, or if an action embedding in a longest match
550 machine uses fcall. The fcall command can still be used in pattern actions.
551 -Made improvements to the clang, rlscan, awkemu and cppscan examples.
552 -Some fixes to generated label names: they should all be prefixed with _.
553 -A fix to the Vim syntax highlighting script was made
554 -Many fixes and updates to the documentation. All important features and
555 concepts are now documented. A second chapter describing Ragel's use
558 Ragel 5.1 - Dec 22, 2005
559 ========================
560 -Fixes to the matching of section delimiters in Vim syntax file.
561 -If there is a longest match machine, the tokend var is now initialized by
562 write init. This is not necessary for correct functionality, however
563 prevents compiler warnings.
564 -The rlscan example was ported to the longest match operator and changed to
566 -Fix to the error handling in the frontend: if there are errors in the lookup
567 of names at machine generation time then do not emit anything.
568 -If not compiling the full machine in the frontend (by using -M), avoid
569 errors and segfaults caused by names that are not part of the compiled
571 -Longest match bug fix: need to init tokstart when returing from fsm calls
572 that are inside longest match actions.
573 -In Graphviz drawing, the arrow into the start state is not a real
574 transition, do not draw to-state actions on the label.
575 -A bug fix to the handling of non-tag data within an XML tag was made.
576 -Backend exit value fixed: since the parser now accepts nothing so as to
577 avoid a redundant parse error when the frontend dies, we must force an
578 error. The backend should now be properly reporting errors.
579 -The longest match machine now has it's start state set final. An LM machine
580 is in a final state when it has not matched anything, when it has matched
581 and accepted a token and is ready for another, and when it has matched a
582 token but is waiting for some lookahead before determining what to do about
583 it (similar to kleene star).
584 -Element statement removed from some tests.
585 -Entry point names are propagated to the backend and used to label the entry
586 point arrows in Graphviz output.
588 Ragel 5.0 - Dec 17, 2005
589 ========================
590 (additional details in V5 release notes)
591 -Ragel has been split into two executables: A frontend which compiles
592 machines and emits them in an XML format, and a backend which generates code
593 or a Graphviz dot file from the XML input. The purpose of this split is to
594 allow Ragel to interface with other tools by means of the XML intermediate
595 format and to reduce complexity by strictly separating the previously
596 entangled phases. The intermediate format will provide a better platform
597 inspecting compiled machines and for extending Ragel to support other host
599 -The host language interface has been reduced significantly. Ragel no longer
600 expects the machine to be implemented as a structure or class and does not
601 generate functions corresponding to initialization, execution and EOF.
602 Instead, Ragel just generates the code of these components, allowing all of
603 them to be placed in a single function if desired. The user specifies a
604 machine in the usual manner, then indicates at which place in the program
605 text the state machine code is to be generated. This is done using the write
606 statement. It is possible to specify to Ragel how it should access the
607 variables it needs (such as the current state) using the access statement.
608 -The host language embedding delimiters have been changed. Single line
609 machines start with '%%' and end at newline. Multiline machines start with
610 '%%{' and end with '}%%'. The machine name is given with the machine
611 statement at the very beginning of the specification. This purpose of this
612 change is to make it easier separate Ragel code from the host language. This
613 will ease the addition of supported host languages.
614 -The structure and class parsing which was previously able to extract a
615 machine's name has been removed since this feature is dependent on the host
616 language and inhibits the move towards a more language-independent frontend.
617 -The init, element and interface statements have been made obsolete by the
618 new host language interface and have been removed.
619 -The fexec action statement has been changed to take only the new position to
620 move to. This statement is more useful for moving backwards and reparsing
621 input than for specifying a whole new buffer entirely and has been shifted
622 to this new use. Giving it only one argument also simplifies the parsing of
623 host code embedded in a Ragel specification. This will ease the addition of
624 supported host languages.
625 -Introduced the fbreak statement, which allows one to stop processing data
626 immediately. The machine ends up in the state that the current transition
627 was to go to. The current character is not changed.
628 -Introduced the noend option for writing the execute code. This inhibits
629 checking if we have reached pe. The machine will run until it goes into the
630 error state or fbreak is hit. This allows one to parse null-terminate
631 strings without first computing the length.
632 -The execute code now breaks out of the processing loop when it moves into
633 the error state. Previously it would run until pe was hit. Breaking out
634 makes the noend option useful when an error is encountered and allows
635 user code to determine where in the input the error occured. It also
636 eliminates needlessly iterating the input buffer.
637 -Introduced the noerror, nofinal and noprefix options for writing the machine
638 data. The first two inhibit the writing of the error state and the
639 first-final state should they not be needed. The noprefix eliminates the
640 prefixing of the data items with the machine name.
641 -Support for the D language has been added. This is specified in the backend
643 -Since the new host language interface has been reduced considerably, Ragel
644 no longer needs to distinguish between C-based languages. Support for C, C++
645 and Objective-C has been folded into one option in the backend: -C
646 -The code generator has been made independent of the languages that it
647 supports by pushing the language dependent apsects down into the lower
648 levels of the code generator.
649 -Many improvements to the longest match construction were made. It is no
650 longer considered experimental. A longest match machine must appear at the
651 top level of a machine instantiation. Since it does not generate a pure
652 state machine (it may need to backtrack), it cannot be used as an operand to
654 -References to the current character and current state are now completely
655 banned in EOF actions.
657 Ragel 4.2 - Sep 16, 2005
658 ========================
659 (additional details in V4 release notes)
660 -Fixed a bug in the longest match operator. In some states it's possible that
661 we either match a token or match nothing at all. In these states we need to
662 consult the LmSwitch on error so it must be prepared to execute an error
663 handler. We therefore need to init act to this error value (which is zero).
664 We can compute if we need to do this and the code generator emits the
665 initialization only if necessary.
666 -Changed the definition of the token end of longest match actions. It now
667 points to one past the last token. This makes computing the token length
668 easier because you don't have to add one. The longest match variables token
669 start, action identifier and token end are now properly initialized in
670 generated code. They don't need to be initialized in the user's code.
671 -Implemented to-state and from-state actions. These actions are executed on
672 transitions into the state (after the in transition's actions) and on
673 transitions out of the state (before the out transition's actions). See V4
674 release notes for more information.
675 -Since there are no longer any action embedding operators that embed both on
676 transitions and on EOF, any actions that exist in both places will be there
677 because the user has explicitly done so. Presuming this case is rare, and
678 with code duplication in the hands of the user, we therefore give the EOF
679 actions their own action switch in the finish() function. This is further
680 motivated by the fact that the best solution is to do the same for to-state
681 and from-state actions in the main loop.
682 -Longest match actions can now be specified using a named action. Since a
683 word following a longest match item conflicts with the concatenation of a
684 named machine, the => symbol must come immediately before a named action.
685 -The longest match operator permits action and machine definitions in the
686 middle of a longest match construction. These are parsed as if they came
687 before the machine definition they are contained in. Permitting action and
688 machine definitions in a longest match construction allows objects to be
689 defined closer to their use.
690 -The longest match operator can now handle longest match items with no
691 action, where previously Ragel segfaulted.
692 -Updated to Aapl post 2.12.
693 -Fixed a bug in epsilon transition name lookups. After doing a name lookup
694 the result was stored in the parse tree. This is wrong because if a machine
695 is used more than once, each time it may resolve to different targets,
696 however it will be stored in the same place. We now store name resolutions
697 in a separated data structure so that each walk of a parse tree uses the
698 name resolved during the corresponding walk in the name lookup pass.
699 -The operators used to embed context and actions into states have been
700 modified. The V4 release notes contain the full details.
701 -Added zlen builtin machine to represent the zero length machine. Eventually
702 the name "null" will be phased out in favour of zlen because it is unclear
703 whether null matches the zero length string or if it does not match any
704 string at all (as does the empty builtin).
705 -Added verbose versions of action, context and priority embedding. See the V4
706 release notes for the full details. A small example:
707 machine <- all exec { foo(); } <- final eof act1
708 -Bugfix for machines with epsilon ops, but no join operations. I had
709 wrongfully assumed that because epsilon ops can only increase connectivity,
710 that no states are ever merged and therefore a call to fillInStates() is not
711 necessary. In reality, epsilon transitions within one machine can induce the
712 merging of states. In the following, state 2 follows two paths on 'i':
713 main := 'h' -> i 'i h' i: 'i';
714 -Changed the license of the guide from a custom "do not propagate modified
715 versions of this document" license to the GPL.
717 Ragel 4.1 - Jun 26, 2005
718 ========================
719 (additional details in V4 release notes)
720 -A bug in include processing was fixed. Surrounding code in an include file
721 was being passed through to the output when it should be ignored. Includes
722 are only for including portions of another machine into he current. This
723 went unnoticed because all tested includes were wrapped in #ifndef ...
724 #endif directives and so did not affect the compilation of the file making
726 -Fixes were made to Vim syntax highlighting file.
727 -Duplicate actions are now removed from action lists.
728 -The character-level negation operator ^ was added. This operator produces a
729 machine that matches single characters that are not matched by the machine
730 it is applied to. This unary prefix operator has the same precedence level
732 -The use of + to specify the a positive literal number was discontinued.
733 -The parser now assigns the subtraction operator a higher precedence than
734 the negation of literal number.
736 Ragel 4.0 - May 26, 2005
737 ========================
738 (additional details in V4 release notes)
739 -Operators now strictly embed into a machine either on a specific class of
740 characters or on EOF, but never both. This gives a cleaner association
741 between the operators and the physical state machine entitites they operate
742 on. This change is made up of several parts:
743 1. '%' operator embeds only into leaving characters.
744 2. All global and local error operators only embed on error character
745 transitions, their action will not be triggerend on EOF in non-final
747 3. EOF action embedding operators have been added for all classes of states
748 to make up for functionality removed from other operators. These are
750 4. Start transition operator '>' no longer implicitly embeds into leaving
751 transtions when start state is final.
752 -Ragel now emits warnings about the improper use of statements and values in
753 action code that is embedded as an EOF action. Warnings are emitted for fpc,
754 fc, fexec, fbuf and fblen.
755 -Added a longest match construction operator |* machine opt-action; ... *|.
756 This is for repetition where an ability to revert to a shorter, previously
757 matched item is required. This is the same behaviour as flex and re2c. The
758 longest match operator is not a pure FSM construction, it introduces
759 transitions that implicitly hold the current character or reset execution to
760 a previous location in the input. Use of this operator requires the caller
761 of the machine to occasionally hold onto data after a call to the exectute
762 routine. Use of machines generated with this operator as the input to other
763 operators may have undefined results. See examples/cppscan for an example.
764 This is very experimental code.
765 -Action ids are only assigned to actions that are referenced in the final
766 constructed machine, preventing gaps in the action id sequence. Previously
767 an action id was assigned if the action was referenced during parsing.
768 -Machine specifications now begin with %% and are followed with an optional
769 name and either a single Ragel statement or a sequence of statements
771 -Ragel no longer generates the FSM's structure or class. It is up to the user
772 to declare the structure and to give it a variable named curs of type
773 integer. If the machine uses the call stack the user must also declare a
774 array of integers named stack and an integer variable named top.
775 -In the case of Objective-C, Ragel no longer generates the interface or
776 implementation directives, allowing the user to declare additional methods.
777 -If a machine specification does not have a name then Ragel tries to find a
778 name for it by first checking if the specification is inside a struct, class
779 or interface. If it is not then it uses the name of the previous machine
780 specification. If still no name is found then this is an error.
781 -Fsm specifications now persist in memory and statements accumulate.
782 -Ragel now has an include statement for including the statements of a machine
783 spec in another file (perhaps because it is the corresponding header file).
784 The include statement can also be used to draw in the statements of another
785 fsm spec in the current file.
786 -The fstack statement is now obsolete and has been removed.
787 -A new statement, simply 'interface;', indicates that ragel should generate
788 the machine's interface. If Ragel sees the main machine it generates the
789 code sections of the machine. Previously, the header portion was generated
790 if the (now removed) struct statement was found and code was generated if
791 any machine definition was found.
792 -Fixed a bug in the resolution of fsm name references in actions. The name
793 resolution code did not recurse into inline code items with children
794 (fgoto*, fcall*, fnext*, and fexec), causing a segfault at code generation
796 -Cleaned up the code generators. FsmCodeGen was made into a virtual base
797 class allowing for the language/output-style specific classes to inherit
798 both a language specific and style-specific base class while retaining only
799 one copy of FsmCodeGen. Language specific output can now be moved into the
800 language specific code generators, requiring less duplication of code in the
801 language/output-style specific leaf classes.
802 -Fixed bugs in fcall* implementation of IpgGoto code generation.
803 -If the element type has not been defined Ragel now uses a constant version
804 of the alphtype, not the exact alphtype. In most cases the data pointer of
805 the execute routine should be const. A non-const element type can still be
806 defined with the element statement.
807 -The fc special value now uses getkey for retrieving the current char rather
808 than *_p, which is wrong if the element type is a structure.
809 -User guide converted to TeX and updated for new 4.0 syntax and semantics.
811 Ragel 3.7 - Oct 31, 2004
812 ========================
813 -Bug fix: unreferenced machine instantiations causing segfault due to name
814 tree and parse tree walk becomming out of syncronization.
815 -Rewrote representation of inline code blocks using a tree data structure.
816 This allows special keywords such as fbuf to be used as the operatands of
818 -Documentation updates.
819 -When deciding whether or not to generate machine instantiations, search the
820 entire name tree beneath the instantiation for references, not just the
822 -Removed stray ';' in keller2.rl
823 -Added fexec for restarting the machine with new buffer data (state stays the
824 same), fbuf for retrieving the the start of the buf, and fblen for
825 retrieving the orig buffer length.
826 -Implemented test/cppscan2 using fexec. This allows token emitting and restart
827 to stay inside the execute routine, instead of leaving and re-entering on
829 -Changed examples/cppscan to use fexec and thereby go much faster.
830 -Implemented flex and re2c versions of examples/cppscan. Ragel version
831 goes faster than flex version but not as fast as re2c version.
832 -Merged in Objective-C patch from Erich Ocean.
833 -Turned off syncing with stdio in C++ tests to make them go faster.
834 -Renamed C++ code generaion classes with the Cpp Prefix instead of CC to make
836 -In the finish function emit fbuf as 0 cast to a pointer to the element type
837 so it's type is not interpreted as an integer.
838 -The number -128 underflows char alphabets on some architectures. Removed
840 -Disabled the keller2 test because it causes problems on many architectures
841 due to its large size and compilation requirements.
843 Ragel 3.6 - Jul 10, 2004
844 ========================
845 -Many documentation updates.
846 -When resolving names, return a set of values so that a reference in an
847 action block that is embedded more than once won't report distinct entry
848 points that are actually the same.
849 -Implemented flat tables. Stores a linear array of indicies into the
850 transition array and only a low and high key value. Faster than binary
851 searching for keys but not usable for large alphabets.
852 -Fixed bug in deleting of transitions leftover from converstion from bst to
853 list implementation of transitions. Other code cleanup.
854 -In table based output calculate the cost of using an index. Don't use if
856 -Changed fstate() value available in init and action code to to fentry() to
857 reflect the fact that the values returned are intended to be used as targets
858 in fgoto, fnext and fcall statements. The returned state is not a unique
859 state representing the label. There can be any number of states representing
861 -Added keller2 test, C++ scanning tests and C++ scanning example.
862 -In table based output split up transitions into targets and actions. This
863 allows actions to be omitted.
864 -Broke the components of the state array into separate arrays. Requires
865 adding some fields where they could previously be omitted, however allows
866 finer grained control over the sizes of items and an overal size reduction.
867 Also means that state numbers are not an offset into the state array but
868 instead a sequence of numbers, meaning the context array does not have any
870 -Action lists and transition also have their types chosen to be the smallest
871 possible for accomodating the contained values.
872 -Changed curs state stored in fsm struct from _cs to curs. Keep fsm->curs ==
873 -1 while in machine. Added tests curs1 and curs2.
874 -Implemented the notion of context. Context can be embedded in states using
875 >:, $:, @: and %: operators. These embed a named context into start states,
876 all states, non-start/non-final and final states. If the context is declared
877 using a context statment
879 then the context can be quered for any state using fsm_name_ctx_name(state)
880 in C code and fsm_name::ctx_name(state) in C++ code. This feature makes it
881 possible to determine what "part" of the machine is currently active.
882 -Fixed crash on machine generation of graphs with no final state. If there
883 is no reference to a final state in a join operation, don't generate one.
884 -Updated Vim sytax: added labels to inline code, added various C++ keywords.
885 Don't highlight name separations as labels. Added switch labels, improved
886 alphtype, element and getkey.
887 -Fixed line info in error reporting of bad epsilon trans.
888 -Fixed fstate() for tab code gen.
889 -Removed references to malloc.h.
891 Ragel 3.5 - May 29, 2004
892 ========================
893 -When parse errors occur, the partially generated output file is deleted and
894 an non-zero exit status is returned.
895 -Updated Vim syntax file.
896 -Implemented the setting of the element type that is passed to the execute
897 routine as well as method for specifying how ragel should retrive the key
898 from the element type. This lets ragel process arbitrary structures inside
899 of which is the key that is parsed.
900 element struct Element;
901 getkey fpc->character;
902 -The current state is now implemented with an int across all machines. This
903 simplifies working with current state variables. For example this allows a
904 call stack to be implemented in user code.
905 -Implemented a method for retrieving the current state, the target state, and
907 fcurs -retrieve the current state
908 ftargs -retrieve the target state
909 fstate(name) -retrieve a named state.
910 -Implemented a mechanism for jumping to and calling to a state stored in a
912 fgoto *<expr>; -goto the state returned by the C/C++ expression.
913 fcall *<expr>; -call the state returned by the C/C++ expression.
914 -Implemented a mechanism for specifying the next state without immediately
915 transfering control there (any code following statement is executed).
916 fnext label; -set the state pointed to by label as the next state.
917 fnext *<expr>; -set the state returned by the C/C++ expression as the
919 -Action references are determined from the final machine instead of during
920 the parse tree walk. Some actions can be referenced in the parse tree but not
921 show up in the final machine. Machine analysis is now done based on this new
923 -Named state lookup now employs a breadth-first search in the lookup and
924 allows the user to fully qualify names, making it possible to specify
925 jumps/calls into parts of the machine deep in the name hierarchy. Each part
926 of name (separated by ::) employs a breadth first search from it's starting
928 -Name references now must always refer to a single state. Since references to
929 multiple states is not normally intended, it no longer happens
930 automatically. This frees the programmer from thinking about whether or not
931 a state reference is unique. It also avoids the added complexity of
932 determining when to merge the targets of multiple references. The effect of
933 references to multiple states can be explicitly created using the join
934 operator and epsilon transitions.
935 -M option was split into -S and -M. -S specifies the machine spec to generate
936 for graphviz output and dumping. -M specifies the machine definition or
938 -Machine function parameters are now prefixed with and underscore to
939 avoid the hiding of class members.
941 Ragel 3.4 - May 8, 2004
942 =======================
943 -Added the longest match kleene star operator **, which is synonymous
944 with ( ( <machine> ) $0 %1 ) *.
945 -Epsilon operators distinguish between leaving transitions (going to an
946 another expression in a comma separated list) and non-leaving transitions.
947 Leaving actions and priorities are appropriately transferred.
948 -Relative priority of following ops changed to:
952 If label is done first then the isolation of the start state in > operators
953 will cause the label to point to the old start state that doesn't have the
955 -Merged >! and >~, @! and @~, %! and %~, and $! and $~ operators to have one
956 set of global error action operators (>!, @!, %! and $!) that are invoked on
957 error by unexpected characters as well as by unexepected EOF.
958 -Added the fpc keyword for use in action code. This is a pointer to the
959 current character. *fpc == fc. If an action is invoked on EOF then fpc == 0.
960 -Added >^, @^, %^, and $^ local error operators. Global error operators (>!,
961 @!, $!, and %!) cause actions to be invoked if the final machine fails.
962 Local error actions cause actions to be invoked if if the current machine
964 -Changed error operators to mean embed global/local error actions in:
965 >! and !^ -the start state.
966 @! and @^ -states that are not the start state and are not final.
967 %! and %^ -final states.
968 $! and $^ -all states.
969 -Added >@! which is synonymous >! then @!
970 -Added >@^ which is synonymous >^ then @^
971 -Added @%! which is synonymous @! then %!
972 -Added @%^ which is synonymous >^ then @^
973 -FsmGraph representation of transition lists was changed from a mapping of
974 alphabet key -> transition objects using a BST to simply a list of
975 transition objects. Since the transitions are no longer divided by
976 single/range, the fast finding of transition objects by key is no longer
977 required functionality and can be eliminated. This new implementation uses
978 the same amount of memory however causes less allocations. It also make more
979 sense for supporting error transitions with actions. Previously an error
980 transition was represented by a null value in the BST.
981 -Regular expression ranges are checked to ensure that lower <= upper.
982 -Added printf-like example.
983 -Added atoi2, erract2, and gotcallret to the test suite.
984 -Improved build test to support make -jN and simplified the compiling and
987 Ragel 3.3 - Mar 7, 2004
988 =======================
989 -Portability bug fixes were made. Minimum and maximum integer values are
990 now taken from the system. An alignment problem on 64bit systems
993 Ragel 3.2 - Feb 28, 2004
994 ========================
995 -Added a Vim syntax file.
996 -Eliminated length var from generated execute code in favour of an end
997 pointer. Using length requires two variables be read and written. Using an
998 end pointer requires one variable read and written and one read. Results in
999 more optimizable code.
1000 -Minimization is now on by default.
1001 -States are ordered in output by depth first search.
1002 -Bug in minimization fixed. States were not being distinguished based on
1004 -Added null and empty builtin machines.
1005 -Added EOF error action operators. These are >~, >@, $~, and %~. EOF error
1006 operators embed actions to take if the EOF is seen and interpreted as an
1007 error. The operators correspond to the following states:
1009 -any state with a transition to a final state
1010 -any state with a transiion out
1012 -Fixed bug in generation of unreference machine vars using -M. Unreferenced
1013 vars don't have a name tree built underneath when starting from
1014 instantiations. Need to instead build the name tree starting at the var.
1015 -Calls, returns, holds and references to fc in out action code are now
1016 handled for ipgoto output.
1017 -Only actions referenced by an instantiated machine expression are put into
1018 the action index and written out.
1019 -Added rlscan, an example that lexes Ragel input.
1021 Ragel 3.1 - Feb 18, 2004
1022 ========================
1023 -Duplicates in OR literals are removed and no longer cause an assertion
1025 -Duplicate entry points used in goto and call statements are made into
1026 deterministic entry points.
1027 -Base FsmGraph code moved from aapl into ragel, as an increasing amount
1028 of specialization is required. Too much time was spent attempting to
1029 keep it as a general purpose template.
1030 -FsmGraph code de-templatized and heirarchy squashed to a single class.
1031 -Single transitions taken out of FsmGraph code. In the machine construction
1032 stage, transitions are now implemented only with ranges and default
1033 transtions. This reduces memory consumption, simplifies code and prevents
1034 covered transitions. However it requires the automated selection of single
1035 transitions to keep goto-driven code lean.
1036 -Machine reduction completely rewritten to be in-place. As duplicate
1037 transitions and actions are found and the machine is converted to a format
1038 suitable for writing as C code or as GraphViz input, the memory allocated
1039 for states and transitions is reused, instead of newly allocated.
1040 -New reduction code consolodates ranges, selects a default transition, and
1041 selects single transitions with the goal of joining ranges that are split by
1042 any number of single characters.
1043 -Line directive changed from "# <num> <file>" to the more common format
1044 "#line <num> <file>".
1045 -Operator :! changed to @!. This should have happened in last release.
1046 -Added params example.
1048 Ragel 3.0 - Jan 22, 2004
1049 ========================
1050 -Ragel now parses the contents of struct statements and action code.
1051 -The keyword fc replaces the use of *p to reference the current character in
1053 -Machine instantiations other than main are allowed.
1054 -Call, jump and return statements are now available in action code. This
1055 facility makes it possible to jump to an error handling machine, call a
1056 sub-machine for parsing a field or to follow paths through a machine as
1057 determined by arbitrary C code.
1058 -Added labels to the language. Labels can be used anywhere in a machine
1059 expression to define an entry point. Also references to machine definitions
1060 cause the implicit creation of a label.
1061 -Added epsilon transitions to the language. Epsilon operators may reference
1062 labels in the current name scope resolved when join operators are evaluated
1063 and at the root of the expression tree of machine assignment/instantiation.
1064 -Added the comma operator, which joins machines together without drawing any
1065 transitions between them. This operator is useful in combination with
1066 labels, the epsilon operator and user code transitions for defining machines
1067 using the named state and transition list paradigm. It is also useful for
1068 invoking transitions based on some analysis of the input or on the
1070 -Added >!, :!, $!, %! operators for specifying actions to take should the
1071 machine fail. These operators embed actions to execute if the machine
1074 -any state with a transition to a final state
1075 -any state with a transiion out
1077 The general rule is that if an action embedding operator embeds an action
1078 into a set of transitions T, then the error-counterpart with a ! embeds an
1079 action into the error transition taken when any transition T is a candidate,
1080 but does not match the input.
1081 -The finishing augmentation operator ':' has been changed to '@'. This
1082 frees the ':' symbol for machine labels and avoids hacks to the parser to
1083 allow the use of ':' for both labels and finishing augmentations. The best
1084 hack required that label names be distinct from machine definition names as
1085 in main := word : word; This restriction is not good because labels are
1086 local to the machine that they are used in whereas machine names are global
1087 entities. Label name choices should not be restricted by the set of names
1088 that are in use for machines.
1089 -Named priority syntax now requires parenthesis surrounding the name and
1090 value pair. This avoids grammar ambiguities now that the ',' operator has
1091 been introduced and makes it more clear that the name and value are an
1093 -Backslashes are escaped in line directive paths.
1095 Ragel 2.2 - Oct 6, 2003
1096 =======================
1097 -Added {n}, {,n}, {n,} {n,m} repetition operators.
1098 <expr> {n} -- exactly n repetitions
1099 <expr> {,n} -- zero to n repetitions
1100 <expr> {n,} -- n or more repetitions
1101 <expr> {n,m} -- n to m repetitions
1102 -Bug in binary search table in Aapl fixed. Fixes crashing on machines that
1103 add to action tables that are implicitly shared among transitions.
1104 -Tests using obsolete minimization algorithms are no longer built and run by
1106 -Added atoi and concurrent from examples to the test suite.
1108 Ragel 2.1 - Sep 22, 2003
1109 ========================
1110 -Bug in priority comparison code fixed. Segfaulted on some input with many
1111 embedded priorities.
1112 -Added two new examples.
1114 Ragel 2.0 - Sep 7, 2003
1115 =======================
1116 -Optional (?), One or More (+) and Kleene Star (*) operators changed from
1117 prefix to postfix. Rationale is that postfix version is far more common in
1118 regular expression implementations and will be more readily understood.
1119 -All priority values attached to transitions are now accompanied by a name.
1120 Transitions no longer have default priority values of zero assigned
1121 to them. Only transitions that have different priority values assigned
1122 to the same name influence the NFA-DFA conversion. This scheme reduces
1123 side-effects of priorities.
1124 -Removed the %! statement for unsetting pending out priorities. With
1125 named priorities, it is not necessary to clear the priorities of a
1126 machine with $0 %! because non-colliding names can be used to avoid
1128 -Removed the clear keyword, which was for removing actions from a machine.
1129 Not required functionality and it is non-intuitive to have a language
1130 feature that undoes previous definitions.
1131 -Removed the ^ modifier to repetition and concatenation operators. This
1132 undocumented feature prevented out transitions and out priorities from being
1133 transfered from final states to transitions leaving machines. Not required
1134 functionality and complicates the language unnecessarily.
1135 -Keyword 'func' changed to 'action' as a part of the phasing out of the term
1136 'function' in favour of 'action'. Rationale is that the term 'function'
1137 implies that the code is called like a C function, which is not necessarily
1138 the case. The term 'action' is far more common in state machine compiler
1140 -Added the instantiation statement, which looks like a standard variable
1141 assignment except := is used instead of =. Instantiations go into the
1142 same graph dictionary as definitions. In the the future, instantiations
1143 will be used as the target for gotos and calls in action code.
1144 -The main graph should now be explicitly instantiated. If it is not,
1145 a warning is issued.
1146 -Or literal basic machines ([] outside of regular expressions) now support
1147 negation and ranges.
1148 -C and C++ interfaces lowercased. In the C interface an underscore now
1149 separates the fsm machine and the function name. Rationale is that lowercased
1150 library and generated routines are more common.
1152 int fsm_init( struct clang *fsm );
1153 int fsm_execute( struct clang *fsm, char *data, int dlen );
1154 int fsm_finish( struct clang *fsm );
1157 int fsm::execute( char *data, int dlen );
1159 -Init, execute and finish all return -1 if the machine is in the error state
1160 and can never accept, 0 if the machine is in a non-accepting state that has a
1161 path to a final state and 1 if the machine is in an accepting state.
1162 -Accept routine eliminated. Determining whether or not the machine accepts is
1163 done by examining the return value of the finish routine.
1164 -In C output, fsm structure is no longer a typedef, so referencing requires
1165 the struct keyword. This is to stay in line with C language conventions.
1166 -In C++ output, constructor is no longer written by ragel. As a consequence,
1167 init routine is not called automatically. Allows constructor to be supplied
1168 by user as well as the return value of init to be examined without calling it
1170 -Static start state and private structures are taken out of C++ classes.
1172 Ragel 1.5.4 - Jul 14, 2003
1173 ==========================
1174 -Workaround for building with bison 1.875, which produces an
1175 optimization that doesn't build with newer version gcc.
1177 Ragel 1.5.3 - Jul 10, 2003
1178 ==========================
1179 -Fixed building with versions of flex that recognize YY_NO_UNPUT.
1180 -Fixed version numbers in ragel.spec file.
1182 Ragel 1.5.2 - Jul 7, 2003
1183 =========================
1184 -Transition actions and out actions displayed in the graphviz output.
1185 -Transitions on negative numbers handled in graphviz output.
1186 -Warning generated when using bison 1.875 now squashed.
1188 Ragel 1.5.1 - Jun 21, 2003
1189 ==========================
1190 -Bugs fixed: Don't delete the output objects when writing to standard out.
1191 Copy mem into parser buffer with memcpy, not strcpy. Fixes buffer mem errror.
1192 -Fixes for compiling with Sun WorkShop 6 compilers.
1194 Ragel 1.5.0 - Jun 10, 2003
1195 ==========================
1196 -Line directives written to the output so that errors in the action code
1197 are properly reported in the ragel input file.
1198 -Simple graphviz dot file output format is supported. Shows states and
1199 transitions. Does not yet show actions.
1200 -Options -p and -f dropped in favour of -d output format.
1201 -Added option -M for specifying the machine to dump with -d or the graph to
1203 -Error recovery implemented.
1204 -Proper line and column number tracking implemented in the scanner.
1205 -All action/function code is now embedded in the main Execute routine. Avoids
1206 duplication of action code in the Finish routine and the need to call
1207 ExecFuncs which resulted in huge code bloat. Will also allow actions to
1208 modify cs when fsm goto, call and return is supported in action code.
1209 -Fsm spec can have no statements, nothing will be generated.
1210 -Bug fix: Don't accept ] as the opening of a .-. range a reg exp.
1211 -Regular expression or set ranges (ie /[0-9]/) are now handled by the parser
1212 and consequently must be well-formed. The following now generates a parser
1213 error: /[+-]/ and must be rewritten as /[+\-]/. Also fixes a bug whereby ]
1214 might be accepted as the opening of a .-. range causing /[0-9]-[0-9]/ to
1216 -\v, \f, and \r are now treated as whitespace in an fsm spec.
1218 Ragel 1.4.1 - Nov 19, 2002
1219 ==========================
1220 -Compile fixes. The last release (integer alphabets) was so exciting
1221 that usual portability checks got bypassed.
1223 Ragel 1.4.0 - Nov 19, 2002
1224 ==========================
1225 -Arbitrary integer alphabets are now fully supported! A new language
1227 'alphtype <type>' added for specifying the type of the alphabet. Default
1228 is 'char'. Possible alphabet types are:
1229 char, unsigned char, short, unsigned short, int, unsigned int
1230 -Literal machines specified in decimal format can now be negative when the
1231 alphabet is a signed type.
1232 -Literal machines (strings, decimal and hex) have their values checked for
1233 overflow/underflow against the size of the alphabet type.
1234 -Table driven and goto driven output redesigned to support ranges. Table
1235 driven uses a binary search for locating single characters and ranges. Goto
1236 driven uses a switch statement for single characters and nested if blocks for
1238 -Switch driven output removed due to a lack of consistent advantages. Most of
1239 the time the switch driven FSM is of no use because the goto FSM makes
1240 smaller and faster code. Under certain circumstances it can produce smaller
1241 code than a goto driven fsm and be almost as fast, but some sporadic case
1242 does not warrant maintaining it.
1243 -Many warnings changed to errors.
1244 -Added option -p for printing the final fsm before minimization. This lets
1245 priorities be seen. Priorties are all reset to 0 before minimization. The
1246 exiting option -f prints the final fsm after minimization.
1247 -Fixed a bug in the clang test and example that resulted in redundant actions
1250 Ragel 1.3.4 - Nov 6, 2002
1251 =========================
1252 -Fixes to Chapter 1 of the guide.
1253 -Brought back the examples and made them current.
1254 -MSVC is no longer supported for compiling windows binaries because its
1255 support for the C++ standard is frustratingly inadequate, it will cost money
1256 to upgrade if it ever gets better, and MinGW is a much better alternative.
1257 -The build system now supports the --host= option for building ragel
1258 for another system (used for cross compiling a windows binary with MinGW).
1259 -Various design changes and fixes towards the goal of arbitrary integer
1260 alphabets and the handling of larger state machines were made.
1261 -The new shared vector class is now used for action lists in transitions and
1262 states to reduce memory allocations.
1263 -An avl tree is now used for the reduction of transitions and functions of an
1264 fsm graph before making the final machine. The tree allows better scalability
1265 and performance by not requiring consecutively larger heap allocations.
1266 -Final stages in the separation of fsm graph code from action embedding and
1267 priority assignment is complete. Makes the base graph leaner and easier to reuse
1268 in other projects (like Keller).
1270 Ragel 1.3.3 - Oct 22, 2002
1271 ==========================
1272 -More diagrams were added to section 1.7.1 of the user guide.
1273 -FSM Graph code was reworked to spearate the regex/nfa/minimizaion graph
1274 algorithms from the manipulation of state and transition properties.
1275 -An rpm spec file from Cris Bailiff was added. This allows an rpm for ragel
1276 to be built with the command 'rpm -ta ragel-x.x.x.tar.gz'
1277 -Fixes to the build system and corresponding doc updates in the README.
1278 -Removed autil and included the one needed source file directly in the top
1279 level ragel directory.
1280 -Fixed a bug that nullified the 20 times speedup in large compilations
1281 claimed by the last version.
1282 -Removed awk from the doc build (it was added with the last release -- though
1283 not mentioned in the changelog).
1284 -Install of man page was moved to the doc dir. The install also installs the
1285 user guide to $(PREFIX)/share/doc/ragel/
1287 Ragel 1.3.2 - Oct 16, 2002
1288 ==========================
1289 -Added option -v (or --version) to show version information.
1290 -The subtract operator no longer removes transition data from the machine
1291 being subtracted. This is left up to the user for the purpose of making it
1292 possible to transfer transitions using subtract and also for speeding up the
1293 subtract routine. Note that it is possible to explicitly clear transition
1294 data before a doing a subtract.
1295 -Rather severe typo bug fixed. Bug was related to transitions with higher
1296 priorities taking precedence. A wrong ptr was being returned. It appears to
1297 have worked most of the time becuase the old ptr was deleted and the new one
1298 allocated immediatly after so the old ptr often pointed to the same space.
1300 -Bug in the removing of dead end paths was fixed. If the start state
1301 has in transitions then those paths were not followed when finding states to
1302 keep. Would result in non-dead end states being removed from the graph.
1303 -In lists and in ranges are no longer maintained as a bst with the key as the
1304 alphabet character and the value as a list of transitions coming in on that
1305 char. There is one list for each of inList, inRange and inDefault. Now that
1306 the required functionality of the graph is well known it is safe to remove
1307 these lists to gain in speed and footprint. They shouldn't be needed.
1308 -IsolateStartState() runs on modification of start data only if the start
1309 state is not already isolated, which is now possible with the new in list
1311 -Concat, Or and Star operators now use an approximation to
1312 removeUnreachableStates that does not require a traversal of the entire
1313 graph. This combined with an 'on-the-fly' management of final bits and final
1314 state status results is a dramatic speed increase when compiling machines
1315 that use those operators heavily. The strings2 test goes 20 times faster.
1316 -Before the final minimization, after all fsm operations are complete,
1317 priority data is reset which enables better minimization in cases where
1318 priorities would otherwise separate similar states.
1320 Ragel 1.3.1 - Oct 2, 2002
1321 =========================
1322 -Range transitions are now used to implement machines made with /[a-z]/ and
1323 the .. operator as well as most of the builtin machines. The ranges are not
1324 yet reflected in the output code, they are expanded as if they came from the
1325 regular single transitions. This is one step closer to arbitrary integer
1327 -The builtin machine 'any' was added. It is equiv to the builtin extend,
1328 matching any characters.
1329 -The builtin machine 'cntrl' now includes newline.
1330 -The builtin machine 'space' now includes newline.
1331 -The builtin machine 'ascii' is now the range 0-127, not all characters.
1332 -A man page was written.
1333 -A proper user guide was started. Chapter 1: Specifying Ragel Programs
1334 was written. It even has some diagrams :)
1336 Ragel 1.3.0 - Sep 4, 2002
1337 =========================
1338 -NULL keyword no longer used in table output.
1339 -Though not yet in use, underlying graph structure changed to support range
1340 transitions. As a result, most of the code that walks transition lists is now
1341 implemented with an iterator that hides the complexity of the transition
1342 lists and ranges. Range transitions will be used to implement /[a-z]/ style
1343 machines and machines made with the .. operator. Previously a single
1344 transition would be used for each char in the range, which is very costly.
1345 Ranges eliminate much of the space complexity and allow for the .. operator
1346 to be used with very large (integer) alphabets.
1347 -New minimization similar to Hopcroft's alg. It does not require n^2 space and
1348 runs close to O(n*log(n)) (an exact analysis of the alg is very hard). It is
1349 much better than the stable and approx minimization and obsoletes them both.
1350 An exact implementation of Hopcroft's alg is desirable but not possible
1351 because the ragel implementation does not assume a finite alphabet, which
1352 Hopcroft's requires. Ragel will support arbitrary integer alphabets which
1353 must be treated as an infinite set for implementation considerations.
1354 -New option -m using above described minimization to replace all previous
1355 minimization options. Old options sill work but are obsolete and not
1357 -Bug fixed in goto style output. The error exit set the current state to 0,
1358 which is actually a valid state. If the machine was entered again it would go
1359 into the first state, very wrong. If the first state happened to be final then
1360 an immediate finish would accept when in fact it should fail.
1361 -Slightly better fsm minimization now capable due to clearing of the
1362 transition ordering numbers just prior to minimization.
1364 Ragel 1.2.2 - May 25, 2002
1365 ==========================
1366 -Configuration option --prefix now works when installing.
1367 -cc file extension changed to cpp for better portability.
1368 -Unlink of output file upon error no longer happens, removes dependency on
1369 unlink system command.
1370 -All multiline strings removed: not standard c++.
1371 -Awk build dependency removed.
1372 -MSVC 6.0 added to the list of supported compilers (with some tweaking of
1373 bison and flex output).
1375 Ragel 1.2.1 - May 13, 2002
1376 ==========================
1377 -Automatic dependencies were fixed, they were not working correctly.
1378 -Updated AUTHORS file to reflect contributors.
1379 -Code is more C++ standards compliant: compiles with g++ 3.0
1380 -Fixed bugs that only showed up in g++ 3.0
1381 -Latest (unreleased) Aapl.
1382 -Configuration script bails out if bison++ is installed. Ragel will not
1383 compile with bison++ because it is coded in c++ and bison++ automatically
1384 generates a c++ parser. Ragel uses a c-style bison parser.
1386 Ragel 1.2.0 - May 3, 2002
1387 =========================
1388 -Underlying graph structure now supports default transitions. The result is
1389 that a transition does not need to be made for each char of the alphabet
1390 when making 'extend' or '/./' machines. Ragel compiles machines that
1391 use the aforementioned primitives WAY faster.
1392 -The ugly hacks needed to pick default transitions now go away due to
1393 the graph supporting default transitions directly.
1394 -If -e is given, but minimization is not turned on, print a warning.
1395 -Makefiles use automatic dependencies.
1397 Ragel 1.1.0 - Apr 15, 2002
1398 ==========================
1399 -Added goto fsm: much faster than any other fsm style.
1400 -Default operator (if two machines are side by side with no operator
1401 between them) is concatenation. First showed up in 1.0.4.
1402 -The fsm machine no longer auotmatically builds the flat table for
1403 transition indicies. Instead it keeps the key,ptr pair. In tabcodegen
1404 the flat table is produced. This way very large alphabets with sparse
1405 transitions will not consume large amounts of mem. This is also in prep
1406 for fsm graph getting a default transition.
1407 -Generated code contains a statement explicitly stating that ragel fsms
1408 are NOT covered by the GPL. Technically, Ragel copies part of itself
1409 to the output to make the generic fsm execution routine (for table driven
1410 fsms only) and so the output could be considered under the GPL. But this
1411 code is very trivial and could easlily be rewritten. The actual fsm data
1412 is subject to the copyright of the source. To promote the use of Ragel,
1413 a special exception is made for the part of the output copied from Ragel:
1414 it may be used without restriction.
1415 -Much more elegant code generation scheme is employed. Code generation
1416 class members need only put the 'codegen' keyword after their 'void' type
1417 in order to be automatically registerd to handle macros of the same name.
1418 An awk script recognises this keyword and generates an appropriate driver.
1419 -Ragel gets a test suite.
1420 -Postfunc and prefunc go away because they are not supported by non
1421 loop-driven fsms (goto, switch) and present duplicate functionality.
1422 Universal funcs can be implemented by using $ operator.
1423 -Automatic dependencies used in build system, no more make depend target.
1424 -Code generation section in docs.
1425 -Uses the latests aapl.
1427 Ragel 1.0.5 - Mar 3, 2002
1428 =========================
1429 -Bugfix in SetErrorState that caused an assertion failure when compiling
1430 simple machines that did not have full transition tables (and thus did
1431 not show up on any example machines). Assertion failure did not occur
1432 when using the switch statement code as ragel does not call SetErrorState
1434 -Fixed some missing includes, now compiles on redhat.
1435 -Moved the FsmMachTrans Compare class out of FsmMachTrans. Some compilers
1436 don't deal with nested classes in templates too well.
1437 -Removed old unused BASEREF in fsmgraph and ragel now compiles using
1438 egcs-2.91.66 and presumably SUNWspro. The baseref is no longer needed
1439 because states do not support being elements in multiple lists. I would
1440 rather be able to support more compilers than have this feature.
1441 -Started a README with compilation notes. Started an AUTHORS file.
1442 -Started the user documentation. Describes basic machines and operators.
1444 Ragel 1.0.4 - Mar 1, 2002
1445 =========================
1446 -Ported to the version of Aapl just after 2.2.0 release. See
1447 http://www.ragel.ca/aapl/ for details on aapl.
1448 -Fixed a bug in the clang example: the newline machine was not stared.
1449 -Added explanations to the clang and mailbox examples. This should
1450 help people that want to learn the lanuage as the manual is far from
1453 Ragel 1.0.3 - Feb 2, 2002
1454 =========================
1455 -Added aapl to the ragel tree. No longer requires you to download
1456 and build aapl separately. Should avoid discouraging impatient users
1457 from compiling ragel.
1458 -Added the examples to the ragel tree.
1459 -Added configure script checks for bison and flex.
1460 -Fixed makefile so as not to die with newer versions of bison that
1461 write the header of the parser to a .hh file.
1462 -Started ChangeLog file.
1464 Ragel 1.0.2 - Jan 30, 2002
1465 ==========================
1466 -Bug fix in calculating highIndex for table based code. Was using
1467 the length of out tranisition table rather than the value at the
1469 -If high/low index are at the limits, output a define in their place,
1470 not the high/low values themselves so as not to cause compiler warnings.
1471 -If the resulting machines don't have any indicies or functions, then
1472 omit the empty unrefereced static arrays so as not to cause compiler
1473 warnings about unused static vars.
1474 -Fixed variable sized indicies support. The header cannot have any
1475 reference to INDEX_TYPE as that info is not known at the time the header
1476 data is written. Forces us to use a void * for pointers to indicies. In
1477 the c++ versions we are forced to make much of the data non-member
1478 static data in the code portion for the same reason.
1480 Ragel 1.0.1 - Jan 28, 2002
1481 ==========================
1482 -Exe name change from reglang to ragel.
1483 -Added ftabcodegen output code style which uses a table for states and
1484 transitions but uses a switch statement for the function execution.
1485 -Reformatted options in usage dump to look better.
1486 -Support escape sequences in [] sections of regular expressions.
1488 Ragel 1.0 - Jan 25, 2002
1489 ========================