Remove incorrect tag directorypyparsing_2.1.6

git-svn-id: svn://svn.code.sf.net/p/pyparsing/code/tags/pyparsing_2.1.6@405 9bf210a0-9d2d-494c-87cf-cfb32e7dff7b

1 files changed, 0 insertions, 2139 deletions

diff --git a/trunk/src/CHANGES b/trunk/src/CHANGES
deleted file mode 100644
index 0e48b21..0000000
--- a/trunk/src/CHANGES
+++ /dev/null
@@ -1,2139 +0,0 @@
-==========

-Change Log

-==========

-

-Version 2.1.6 - 

-------------------------------

-- *Major packrat upgrade*, inspired by patch provided by Tal Einat - 

-  many, many, thanks to Tal for working on this! Tal's tests show 

-  faster parsing performance (2X in some tests), *and* memory reduction 

-  from 3GB down to ~100MB! Requires no changes to existing code using 

-  packratting. (Uses OrderedDict, available in Python 2.7 and later.

-  For Python 2.6 users, will attempt to import from ordereddict

-  backport. If not present, will implement pure-Python Fifo dict.)

-

-- Minor API change - to better distinguish between the flexible

-  numeric types defined in pyparsing_common, I've changed "numeric" 

-  (which parsed numbers of different types and returned int for ints, 

-  float for floats, etc.) and "number" (which parsed numbers of int

-  or float type, and returned all floats) to "number" and "fnumber"

-  respectively. I hope the "f" prefix of "fnumber" will be a better

-  indicator of its internal conversion of parsed values to floats, 

-  while the generic "number" is similar to the flexible number syntax

-  in other languages. Also fixed a bug in pyparsing_common.numeric

-  (now renamed to pyparsing_common.number), integers were parsed and 

-  returned as floats instead of being retained as ints.

-

-- Fixed bug in upcaseTokens and downcaseTokens introduced in 2.1.5,

-  when the parse action was used in conjunction with results names.

-  Reported by Steven Arcangeli from the dql project, thanks for your

-  patience, Steven!

-

-- Major change to docs! After seeing some comments on reddit about 

-  general issue with docs of Python modules, and thinking that I'm a 

-  little overdue in doing some doc tuneup on pyparsing, I decided to

-  following the suggestions of the redditor and add more inline examples

-  to the pyparsing reference documentation. I hope this addition 

-  will clarify some of the more common questions people have, especially

-  when first starting with pyparsing/Python.

-

-- Deprecated ParseResults.asXML. I've never been too happy with this

-  method, and it usually forces some unnatural code in the parsers in

-  order to get decent tag names. The amount of guesswork that asXML 

-  has to do to try to match names with values should have been a red

-  flag from day one. If you are using asXML, you will need to implement 

-  your own ParseResults->XML serialization. Or consider migrating to

-  a more current format such as JSON (which is very easy to do: 

-  results_as_json = json.dumps(parse_result.asDict()) Hopefully, when

-  I remove this code in a future version, I'll also be able to simplify 

-  some of the craziness in ParseResults, which IIRC was only there to try 

-  to make asXML work.

-

-- Updated traceParseAction parse action decorator to show the repr

-  of the input and output tokens, instead of the str format, since 

-  str has been simplified to just show the token list content.  

-  

-  (The change to ParseResults.__str__ occurred in pyparsing 2.0.4, but

-  it seems that didn't make it into the release notes - sorry! Too

-  many users, especially beginners, were confused by the 

-  "([token_list], {names_dict})" str format for ParseResults, thinking 

-  they were getting a tuple containing a list and a dict. The full form 

-  can be seen if using repr().)

-

-  For tracing tokens in and out of parse actions, the more complete 

-  repr form provides important information when debugging parse actions.

-

-

-Verison 2.1.5 - June, 2016

-------------------------------

-- Added ParserElement.split() generator method, similar to re.split(). 

-  Includes optional arguments maxsplit (to limit the number of splits),

-  and includeSeparators (to include the separating matched text in the 

-  returned output, default=False).

-

-- Added a new parse action construction helper tokenMap, which will

-  apply a function and optional arguments to each element in a 

-  ParseResults. So this parse action:

-  

-      def lowercase_all(tokens):

-          return [str(t).lower() for t in tokens]

-      OneOrMore(Word(alphas)).setParseAction(lowercase_all)

-

-  can now be written:

-  

-      OneOrMore(Word(alphas)).setParseAction(tokenMap(str.lower))

-

-  Also simplifies writing conversion parse actions like:

-  

-      integer = Word(nums).setParseAction(lambda t: int(t[0]))

-

-  to just:

-  

-      integer = Word(nums).setParseAction(tokenMap(int))

-

-  If additional arguments are necessary, they can be included in the

-  call to tokenMap, as in:

-  

-      hex_integer = Word(hexnums).setParseAction(tokenMap(int, 16))

-

-- Added more expressions to pyparsing_common:

-  . IPv4 and IPv6 addresses (including long, short, and mixed forms

-    of IPv6)

-  . MAC address

-  . ISO8601 date and date time strings (with named fields for year, month, etc.)

-  . UUID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)

-  . hex integer (returned as int)

-  . fraction (integer '/' integer, returned as float)

-  . mixed integer (integer '-' fraction, or just fraction, returned as float)

-  . stripHTMLTags (parse action to remove tags from HTML source)

-  . parse action helpers convertToDate and convertToDatetime to do custom parse

-    time conversions of parsed ISO8601 strings

-

-- runTests now returns a two-tuple: success if all tests succeed,

-  and an output list of each test and its output lines.

-

-- Added failureTests argument (default=False) to runTests, so that

-  tests can be run that are expected failures, and runTests' success 

-  value will return True only if all tests *fail* as expected. Also,

-  parseAll now defaults to True.

-

-- New example numerics.py, shows samples of parsing integer and real

-  numbers using locale-dependent formats:

-

-    4.294.967.295,000 

-    4 294 967 295,000  

-    4,294,967,295.000  

-  

-

-Version 2.1.4 - May, 2016

-------------------------------

-- Split out the '==' behavior in ParserElement, now implemented

-  as the ParserElement.matches() method. Using '==' for string test 

-  purposes will be removed in a future release.

-

-- Expanded capabilities of runTests(). Will now accept embedded

-  comments (default is Python style, leading '#' character, but 

-  customizable). Comments will be emitted along with the tests and

-  test output. Useful during test development, to create a test string

-  consisting only of test case description comments separated by 

-  blank lines, and then fill in the test cases. Will also highlight

-  ParseFatalExceptions with "(FATAL)".

-

-- Added a 'pyparsing_common' class containing common/helpful little 

-  expressions such as integer, float, identifier, etc. I used this 

-  class as a sort of embedded namespace, to contain these helpers 

-  without further adding to pyparsing's namespace bloat.

-

-- Minor enhancement to traceParseAction decorator, to retain the 

-  parse action's name for the trace output.

-

-- Added optional 'fatal' keyword arg to addCondition, to indicate that

-  a condition failure should halt parsing immediately.

-

-

-Version 2.1.3 - May, 2016

-------------------------------

-- _trim_arity fix in 2.1.2 was very version-dependent on Py 3.5.0.

-  Now works for Python 2.x, 3.3, 3.4, 3.5.0, and 3.5.1 (and hopefully

-  beyond).

-

-

-Version 2.1.2 - May, 2016

-------------------------------

-- Fixed bug in _trim_arity when pyparsing code is included in a

-  PyInstaller, reported by maluwa.

-

-- Fixed catastrophic regex backtracking in implementation of the

-  quoted string expressions (dblQuotedString, sglQuotedString, and

-  quotedString). Reported on the pyparsing wiki by webpentest,

-  good catch! (Also tuned up some other expressions susceptible to the 

-  same backtracking problem, such as cStyleComment, cppStyleComment, 

-  etc.)

-

-

-Version 2.1.1 - March, 2016

----------------------------

-- Added support for assigning to ParseResults using slices.

-

-- Fixed bug in ParseResults.toDict(), in which dict values were always

-  converted to dicts, even if they were just unkeyed lists of tokens.

-  Reported on SO by Gerald Thibault, thanks Gerald!

-

-- Fixed bug in SkipTo when using failOn, reported by robyschek, thanks!

-

-- Fixed bug in Each introduced in 2.1.0, reported by AND patch and

-  unit test submitted by robyschek, well done!

-

-- Removed use of functools.partial in replaceWith, as this creates

-  an ambiguous signature for the generated parse action, which fails in 

-  PyPy. Reported by Evan Hubinger, thanks Evan!

-

-- Added default behavior to QuotedString to convert embedded '\t', '\n',

-  etc. characters to their whitespace counterparts. Found during Q&A

-  exchange on SO with Maxim.

-

-

-Version 2.1.0 - February, 2016

-------------------------------

-- Modified the internal _trim_arity method to distinguish between 

-  TypeError's raised while trying to determine parse action arity and

-  those raised within the parse action itself. This will clear up those

-  confusing "<lambda>() takes exactly 1 argument (0 given)" error 

-  messages when there is an actual TypeError in the body of the parse

-  action. Thanks to all who have raised this issue in the past, and

-  most recently to Michael Cohen, who sent in a proposed patch, and got

-  me to finally tackle this problem.

-

-- Added compatibility for pickle protocols 2-4 when pickling ParseResults. 

-  In Python 2.x, protocol 0 was the default, and protocol 2 did not work.

-  In Python 3.x, protocol 3 is the default, so explicitly naming 

-  protocol 0 or 1 was required to pickle ParseResults. With this release,

-  all protocols 0-4 are supported. Thanks for reporting this on StackOverflow,

-  Arne Wolframm, and for providing a nice simple test case!

-

-- Added optional 'stopOn' argument to ZeroOrMore and OneOrMore, to

-  simplify breaking on stop tokens that would match the repetition 

-  expression. 

-  

-  It is a common problem to fail to look ahead when matching repetitive 

-  tokens if the sentinel at the end also matches the repetition

-  expression, as when parsing "BEGIN aaa bbb ccc END" with:

-  

-    "BEGIN" + OneOrMore(Word(alphas)) + "END"

-

-  Since "END" matches the repetition expression "Word(alphas)", it will

-  never get parsed as the terminating sentinel. Up until now, this has 

-  to be resolved by the user inserting their own negative lookahead:

-  

-    "BEGIN" + OneOrMore(~Literal("END") + Word(alphas)) + "END"

-  

-  Using stopOn, they can more easily write:

-  

-    "BEGIN" + OneOrMore(Word(alphas), stopOn="END") + "END"

-  

-  The stopOn argument can be a literal string or a pyparsing expression.

-  Inspired by a question by Lamakaha on StackOverflow (and many previous

-  questions with the same negative-lookahead resolution).

-

-- Added expression names for many internal and builtin expressions, to 

-  reduce name and error message overhead during parsing.

-

-- Converted helper lambdas to functions to refactor and add docstring

-  support.

-

-- Fixed ParseResults.asDict() to correctly convert nested ParseResults

-  values to dicts.

-  

-- Cleaned up some examples, fixed typo in fourFn.py identified by

-  aristotle2600 on reddit.

-

-- Removed keepOriginalText helper method, which was deprecated ages ago.

-  Superceded by originalTextFor.

-

-- Same for the Upcase class, which was long ago deprecated and replaced

-  with the upcaseTokens method.

-

-

-

-Version 2.0.7 - December, 2015

-------------------------------

-- Simplified string representation of Forward class, to avoid memory

-  and performance errors while building ParseException messages. Thanks,

-  Will McGugan, Andrea Censi, and Martijn Vermaat for the bug reports and

-  test code.

-

-- Cleaned up additional issues from enhancing the error messages for

-  Or and MatchFirst, handling Unicode values in expressions. Fixes Unicode

-  encoding issues in Python 2, thanks to Evan Hubinger for the bug report.

-

-- Fixed implementation of dir() for ParseResults - was leaving out all the

-  defined methods and just adding the custom results names.

-

-- Fixed bug in ignore() that was introduced in pyparsing 1.5.3, that would

-  not accept a string literal as the ignore expression.

-

-- Added new example parseTabularData.py to illustrate parsing of data 

-  formatted in columns, with detection of empty cells.

-

-- Updated a number of examples to more current Python and pyparsing 

-  forms.

-

-

-Version 2.0.6 - November, 2015

-------------------------------

-- Fixed a bug in Each when multiple Optional elements are present.

-  Thanks for reporting this, whereswalden on SO.

-

-- Fixed another bug in Each, when Optional elements have results names

-  or parse actions, reported by Max Rothman - thank you, Max!

-

-- Added optional parseAll argument to runTests, whether tests should

-  require the entire input string to be parsed or not (similar to 

-  parseAll argument to parseString). Plus a little neaten-up of the

-  output on Python 2 (no stray ()'s).

-

-- Modified exception messages from MatchFirst and Or expressions. These

-  were formerly misleading as they would only give the first or longest

-  exception mismatch error message. Now the error message includes all

-  the alternatives that were possible matches. Originally proposed by 

-  a pyparsing user, but I've lost the email thread - finally figured out

-  a fairly clean way to do this.

-

-- Fixed a bug in Or, when a parse action on an alternative raises an 

-  exception, other potentially matching alternatives were not always tried.

-  Reported by TheVeryOmni on the pyparsing wiki, thanks!

-

-- Fixed a bug to dump() introduced in 2.0.4, where list values were shown

-  in duplicate.

-

-

-Version 2.0.5 - October, 2015

------------------------------

-- (&$(@#&$(@!!!!  Some "print" statements snuck into pyparsing v2.0.4,

-  breaking Python 3 compatibility! Fixed. Reported by jenshn, thanks!

-  

-

-Version 2.0.4 - October, 2015

------------------------------

-- Added ParserElement.addCondition, to simplify adding parse actions 

-  that act primarily as filters. If the given condition evaluates False,

-  pyparsing will raise a ParseException. The condition should be a method

-  with the same method signature as a parse action, but should return a

-  boolean. Suggested by Victor Porton, nice idea Victor, thanks!

-

-- Slight mod to srange to accept unicode literals for the input string,

-  such as "[а-яА-Я]" instead of "[\u0430-\u044f\u0410-\u042f]". Thanks 

-  to Alexandr Suchkov for the patch!

-

-- Enhanced implementation of replaceWith.

-

-- Fixed enhanced ParseResults.dump() method when the results consists

-  only of an unnamed array of sub-structure results. Reported by Robin

-  Siebler, thanks for your patience and persistence, Robin!

-

-- Fixed bug in fourFn.py example code, where pi and e were defined using

-  CaselessLiteral instead of CaselessKeyword. This was not a problem until

-  adding a new function 'exp', and the leading 'e' of 'exp' was accidentally

-  parsed as the mathematical constant 'e'. Nice catch, Tom Grydeland - thanks!

-

-- Adopt new-fangled Python features, like decorators and ternary expressions, 

-  per suggestions from Williamzjc - thanks William! (Oh yeah, I'm not

-  supporting Python 2.3 with this code any more...) Plus, some additional

-  code fixes/cleanup - thanks again!

-

-- Added ParserElement.runTests, a little test bench for quickly running

-  an expression against a list of sample input strings. Basically, I got 

-  tired of writing the same test code over and over, and finally added it

-  as a test point method on ParserElement.

-

-- Added withClass helper method, a simplified version of withAttribute for

-  the common but annoying case when defining a filter on a div's class - 

-  made difficult because 'class' is a Python reserved word.

-

-

-Version 2.0.3 - October, 2014

------------------------------

-- Fixed escaping behavior in QuotedString. Formerly, only quotation

-  marks (or characters designated as quotation marks in the QuotedString

-  constructor) would be escaped. Now all escaped characters will be

-  escaped, and the escaping backslashes will be removed.

-

-- Fixed regression in ParseResults.pop() - pop() was pretty much

-  broken after I added *improvements* in 2.0.2. Reported by Iain

-  Shelvington, thanks Iain!

-

-- Fixed bug in And class when initializing using a generator.

-

-- Enhanced ParseResults.dump() method to list out nested ParseResults that

-  are unnamed arrays of sub-structures.

-

-- Fixed UnboundLocalError under Python 3.4 in oneOf method, reported

-  on Sourceforge by aldanor, thanks!

-

-- Fixed bug in ParseResults __init__ method, when returning non-ParseResults

-  types from parse actions that implement __eq__. Raised during discussion 

-  on the pyparsing wiki with cyrfer.

-

-

-Version 2.0.2 - April, 2014

----------------------------

-- Extended "expr(name)" shortcut (same as "expr.setResultsName(name)")

-  to accept "expr()" as a shortcut for "expr.copy()".

-

-- Added "locatedExpr(expr)" helper, to decorate any returned tokens

-  with their location within the input string. Adds the results names

-  locn_start and locn_end to the output parse results.

-

-- Added "pprint()" method to ParseResults, to simplify troubleshooting

-  and prettified output. Now instead of importing the pprint module

-  and then writing "pprint.pprint(result)", you can just write

-  "result.pprint()".  This method also accepts addtional positional and

-  keyword arguments (such as indent, width, etc.), which get passed 

-  through directly to the pprint method 

-  (see http://docs.python.org/2/library/pprint.html#pprint.pprint).

-

-- Removed deprecation warnings when using '<<' for Forward expression

-  assignment. '<<=' is still preferred, but '<<' will be retained

-  for cases whre '<<=' operator is not suitable (such as in defining

-  lambda expressions).

-

-- Expanded argument compatibility for classes and functions that

-  take list arguments, to now accept generators as well.

-

-- Extended list-like behavior of ParseResults, adding support for

-  append and extend. NOTE: if you have existing applications using

-  these names as results names, you will have to access them using

-  dict-style syntax: res["append"] and res["extend"]

-

-- ParseResults emulates the change in list vs. iterator semantics for

-  methods like keys(), values(), and items(). Under Python 2.x, these

-  methods will return lists, under Python 3.x, these methods will 

-  return iterators.

-

-- ParseResults now has a method haskeys() which returns True or False

-  depending on whether any results names have been defined. This simplifies

-  testing for the existence of results names under Python 3.x, which 

-  returns keys() as an iterator, not a list.

-

-- ParseResults now supports both list and dict semantics for pop().

-  If passed no argument or an integer argument, it will use list semantics

-  and pop tokens from the list of parsed tokens. If passed a non-integer

-  argument (most likely a string), it will use dict semantics and 

-  pop the corresponding value from any defined results names. A

-  second default return value argument is supported, just as in 

-  dict.pop().

-

-- Fixed bug in markInputline, thanks for reporting this, Matt Grant!

-

-- Cleaned up my unit test environment, now runs with Python 2.6 and 

-  3.3.

-

-

-Version 2.0.1 - July, 2013

---------------------------

-- Removed use of "nonlocal" that prevented using this version of 

-  pyparsing with Python 2.6 and 2.7. This will make it easier to 

-  install for packages that depend on pyparsing, under Python 

-  versions 2.6 and later. Those using older versions of Python

-  will have to manually install pyparsing 1.5.7.

-

-- Fixed implementation of <<= operator to return self; reported by

-  Luc J. Bourhis, with patch fix by Mathias Mamsch - thanks, Luc

-  and Mathias!

-

-

-Version 2.0.0 - November, 2012

-------------------------------

-- Rather than release another combined Python 2.x/3.x release

-  I've decided to start a new major version that is only 

-  compatible with Python 3.x (and consequently Python 2.7 as

-  well due to backporting of key features). This version will

-  be the main development path from now on, with little follow-on

-  development on the 1.5.x path.

-

-- Operator '<<' is now deprecated, in favor of operator '<<=' for

-  attaching parsing expressions to Forward() expressions. This is

-  being done to address precedence of operations problems with '<<'.

-  Operator '<<' will be removed in a future version of pyparsing.

-

-

-Version 1.5.7 - November, 2012

------------------------------

-- NOTE: This is the last release of pyparsing that will try to 

-  maintain compatibility with Python versions < 2.6. The next

-  release of pyparsing will be version 2.0.0, using new Python

-  syntax that will not be compatible for Python version 2.5 or

-  older.

-

-- An awesome new example is included in this release, submitted

-  by Luca DellOlio, for parsing ANTLR grammar definitions, nice

-  work Luca!

-

-- Fixed implementation of ParseResults.__str__ to use Pythonic

-  ''.join() instead of repeated string concatenation. This

-  purportedly has been a performance issue under PyPy.

-

-- Fixed bug in ParseResults.__dir__ under Python 3, reported by

-  Thomas Kluyver, thank you Thomas!

-

-- Added ParserElement.inlineLiteralsUsing static method, to 

-  override pyparsing's default behavior of converting string

-  literals to Literal instances, to use other classes (such

-  as Suppress or CaselessLiteral).

-

-- Added new operator '<<=', which will eventually replace '<<' for 

-  storing the contents of a Forward(). '<<=' does not have the same

-  operator precedence problems that '<<' does.

-

-- 'operatorPrecedence' is being renamed 'infixNotation' as a better

-  description of what this helper function creates. 'operatorPrecedence'

-  is deprecated, and will be dropped entirely in a future release.

-

-- Added optional arguments lpar and rpar to operatorPrecedence, so that 

-  expressions that use it can override the default suppression of the

-  grouping characters.

-

-- Added support for using single argument builtin functions as parse 

-  actions.  Now you can write 'expr.setParseAction(len)' and get back

-  the length of the list of matched tokens.  Supported builtins are:

-  sum, len, sorted, reversed, list, tuple, set, any, all, min, and max.

-  A script demonstrating this feature is included in the examples

-  directory.

-

-- Improved linking in generated docs, proposed on the pyparsing wiki

-  by techtonik, thanks!

-

-- Fixed a bug in the definition of 'alphas', which was based on the 

-  string.uppercase and string.lowercase "constants", which in fact 

-  *aren't* constant, but vary with locale settings. This could make 

-  parsers locale-sensitive in a subtle way. Thanks to Kef Schecter for

-  his diligence in following through on reporting and monitoring 

-  this bugfix!

-

-- Fixed a bug in the Py3 version of pyparsing, during exception

-  handling with packrat parsing enabled, reported by Catherine 

-  Devlin - thanks Catherine!

-

-- Fixed typo in ParseBaseException.__dir__, reported anonymously on 

-  the SourceForge bug tracker, thank you Pyparsing User With No Name.

-

-- Fixed bug in srange when using '\x###' hex character codes.

-

-- Addeed optional 'intExpr' argument to countedArray, so that you 

-  can define your own expression that will evaluate to an integer,

-  to be used as the count for the following elements. Allows you 

-  to define a countedArray with the count given in hex, for example,

-  by defining intExpr as "Word(hexnums).setParseAction(int(t[0],16))".

-

-

-Version 1.5.6 - June, 2011

-----------------------------

-- Cleanup of parse action normalizing code, to be more version-tolerant,

-  and robust in the face of future Python versions - much thanks to 

-  Raymond Hettinger for this rewrite!

-

-- Removal of exception cacheing, addressing a memory leak condition

-  in Python 3. Thanks to Michael Droettboom and the Cape Town PUG for

-  their analysis and work on this problem!

-

-- Fixed bug when using packrat parsing, where a previously parsed

-  expression would duplicate subsequent tokens - reported by Frankie 

-  Ribery on stackoverflow, thanks!

-

-- Added 'ungroup' helper method, to address token grouping done

-  implicitly by And expressions, even if only one expression in the

-  And actually returns any text - also inspired by stackoverflow

-  discussion with Frankie Ribery!

-

-- Fixed bug in srange, which accepted escaped hex characters of the 

-  form '\0x##', but should be '\x##'.  Both forms will be supported

-  for backwards compatibility.

-

-- Enhancement to countedArray, accepting an optional expression to be

-  used for matching the leading integer count - proposed by Mathias on

-  the pyparsing mailing list, good idea!

-

-- Added the Verilog parser to the provided set of examples, under the

-  MIT license.  While this frees up this parser for any use, if you find

-  yourself using it in a commercial purpose, please consider making a

-  charitable donation as described in the parser's header.

-

-- Added the excludeChars argument to the Word class, to simplify defining

-  a word composed of all characters in a large range except for one or

-  two. Suggested by JesterEE on the pyparsing wiki.

-

-- Added optional overlap parameter to scanString, to return overlapping

-  matches found in the source text.

-

-- Updated oneOf internal regular expression generation, with improved

-  parse time performance.

-  

-- Slight performance improvement in transformString, removing empty

-  strings from the list of string fragments built while scanning the

-  source text, before calling ''.join.  Especially useful when using 

-  transformString to strip out selected text.

-

-- Enhanced form of using the "expr('name')" style of results naming,

-  in lieu of calling setResultsName.  If name ends with an '*', then

-  this is equivalent to expr.setResultsName('name',listAllMatches=True).

-

-- Fixed up internal list flattener to use iteration instead of recursion,

-  to avoid stack overflow when transforming large files.

-

-- Added other new examples:

-  . protobuf parser - parses Google's protobuf language

-  . btpyparse - a BibTex parser contributed by Matthew Brett,

-    with test suite test_bibparse.py (thanks, Matthew!)

-  . groupUsingListAllMatches.py - demo using trailing '*' for results 

-    names

-

-

-Version 1.5.5 - August, 2010

-----------------------------

-

-- Typo in Python3 version of pyparsing, "builtin" should be "builtins".

-  (sigh)

-

-

-Version 1.5.4 - August, 2010

-----------------------------

-

-- Fixed __builtins__ and file references in Python 3 code, thanks to 

-  Greg Watson, saulspatz, sminos, and Mark Summerfield for reporting 

-  their Python 3 experiences.

-

-- Added new example, apicheck.py, as a sample of scanning a Tcl-like

-  language for functions with incorrect number of arguments (difficult

-  to track down in Tcl languages).  This example uses some interesting

-  methods for capturing exceptions while scanning through source

-  code.

-

-- Added new example deltaTime.py, that takes everyday time references

-  like "an hour from now", "2 days ago", "next Sunday at 2pm".

-

-

-Version 1.5.3 - June, 2010

---------------------------

-

-- ======= NOTE:  API CHANGE!!!!!!! ===============

-  With this release, and henceforward, the pyparsing module is 

-  imported as "pyparsing" on both Python 2.x and Python 3.x versions.

-

-- Fixed up setup.py to auto-detect Python version and install the 

-  correct version of pyparsing - suggested by Alex Martelli, 

-  thanks, Alex! (and my apologies to all those who struggled with 

-  those spurious installation errors caused by my earlier 

-  fumblings!)

-

-- Fixed bug on Python3 when using parseFile, getting bytes instead of

-  a str from the input file.

-

-- Fixed subtle bug in originalTextFor, if followed by

-  significant whitespace (like a newline) - discovered by

-  Francis Vidal, thanks!

-

-- Fixed very sneaky bug in Each, in which Optional elements were

-  not completely recognized as optional - found by Tal Weiss, thanks

-  for your patience.

-  

-- Fixed off-by-1 bug in line() method when the first line of the

-  input text was an empty line. Thanks to John Krukoff for submitting

-  a patch!

-  

-- Fixed bug in transformString if grammar contains Group expressions,

-  thanks to patch submitted by barnabas79, nice work!

-  

-- Fixed bug in originalTextFor in which trailing comments or otherwised

-  ignored text got slurped in with the matched expression.  Thanks to

-  michael_ramirez44 on the pyparsing wiki for reporting this just in

-  time to get into this release!

-

-- Added better support for summing ParseResults, see the new example,

-  parseResultsSumExample.py.

-  

-- Added support for composing a Regex using a compiled RE object; 

-  thanks to my new colleague, Mike Thornton!

-

-- In version 1.5.2, I changed the way exceptions are raised in order

-  to simplify the stacktraces reported during parsing.  An anonymous

-  user posted a bug report on SF that this behavior makes it difficult

-  to debug some complex parsers, or parsers nested within parsers. In

-  this release I've added a class attribute ParserElement.verbose_stacktrace,

-  with a default value of False. If you set this to True, pyparsing will 

-  report stacktraces using the pre-1.5.2 behavior.

-

-- New examples: 

-

-  . pymicko.py, a MicroC compiler submitted by Zarko Zivanov. 

-    (Note: this example is separately licensed under the GPLv3, 

-    and requires Python 2.6 or higher.)  Thank you, Zarko!

-

-  . oc.py, a subset C parser, using the BNF from the 1996 Obfuscated C

-    Contest.

-

-  . stateMachine2.py, a modified version of stateMachine.py submitted 

-    by Matt Anderson, that is compatible with Python versions 2.7 and 

-    above - thanks so much, Matt!

-    

-  . select_parser.py, a parser for reading SQLite SELECT statements, 

-    as specified at http://www.sqlite.org/lang_select.html; this goes

-    into much more detail than the simple SQL parser included in pyparsing's

-    source code

-    

-  . excelExpr.py, a *simplistic* first-cut at a parser for Excel 

-    expressions, which I originally posted on comp.lang.python in January, 

-    2010; beware, this parser omits many common Excel cases (addition of

-    numbers represented as strings, references to named ranges)

-    

-  . cpp_enum_parser.py, a nice little parser posted my Mark Tolonen on

-    comp.lang.python in August, 2009 (redistributed here with Mark's

-    permission).  Thanks a bunch, Mark!

-    

-  . partial_gene_match.py, a sample I posted to Stackoverflow.com,

-    implementing a special variation on Literal that does "close" matching,

-    up to a given number of allowed mismatches.  The application was to 

-    find matching gene sequences, with allowance for one or two mismatches.

-    

-  . tagCapture.py, a sample showing how to use a Forward placeholder to

-    enforce matching of text parsed in a previous expression.

-

-  . matchPreviousDemo.py, simple demo showing how the matchPreviousLiteral

-    helper method is used to match a previously parsed token.

-

-

-Version 1.5.2 - April, 2009

-------------------------------

-- Added pyparsing_py3.py module, so that Python 3 users can use

-  pyparsing by changing their pyparsing import statement to:

-  

-      import pyparsing_py3

-

-  Thanks for help from Patrick Laban and his friend Geremy 

-  Condra on the pyparsing wiki.

-  

-- Removed __slots__ declaration on ParseBaseException, for

-  compatibility with IronPython 2.0.1.  Raised by David

-  Lawler on the pyparsing wiki, thanks David!

-  

-- Fixed bug in SkipTo/failOn handling - caught by eagle eye 

-  cpennington on the pyparsing wiki!

-

-- Fixed second bug in SkipTo when using the ignore constructor

-  argument, reported by Catherine Devlin, thanks!

-  

-- Fixed obscure bug reported by Eike Welk when using a class

-  as a ParseAction with an errant __getitem__ method.

-

-- Simplified exception stack traces when reporting parse 

-  exceptions back to caller of parseString or parseFile - thanks

-  to a tip from Peter Otten on comp.lang.python.

-

-- Changed behavior of scanString to avoid infinitely looping on

-  expressions that match zero-length strings.  Prompted by a

-  question posted by ellisonbg on the wiki.

-

-- Enhanced classes that take a list of expressions (And, Or, 

-  MatchFirst, and Each) to accept generator expressions also.

-  This can be useful when generating lists of alternative

-  expressions, as in this case, where the user wanted to match

-  any repetitions of '+', '*', '#', or '.', but not mixtures

-  of them (that is, match '+++', but not '+-+'):

-  

-      codes = "+*#."

-      format = MatchFirst(Word(c) for c in codes)

-      

-  Based on a problem posed by Denis Spir on the Python tutor

-  list.

-

-- Added new example eval_arith.py, which extends the example

-  simpleArith.py to actually evaluate the parsed expressions.

-

-

-Version 1.5.1 - October, 2008

--------------------------------

-- Added new helper method originalTextFor, to replace the use of

-  the current keepOriginalText parse action.  Now instead of 

-  using the parse action, as in:

-  

-      fullName = Word(alphas) + Word(alphas)

-      fullName.setParseAction(keepOriginalText)

-      

-  (in this example, we used keepOriginalText to restore any white

-  space that may have been skipped between the first and last

-  names)

-  You can now write:

-  

-      fullName = originalTextFor(Word(alphas) + Word(alphas))

-      

-  The implementation of originalTextFor is simpler and faster than

-  keepOriginalText, and does not depend on using the inspect or

-  imp modules.

-  

-- Added optional parseAll argument to parseFile, to be consistent

-  with parseAll argument to parseString.  Posted by pboucher on the

-  pyparsing wiki, thanks!

-

-- Added failOn argument to SkipTo, so that grammars can define

-  literal strings or pyparsing expressions which, if found in the

-  skipped text, will cause SkipTo to fail.  Useful to prevent 

-  SkipTo from reading past terminating expression.  Instigated by

-  question posed by Aki Niimura on the pyparsing wiki.

-

-- Fixed bug in nestedExpr if multi-character expressions are given

-  for nesting delimiters.  Patch provided by new pyparsing user,

-  Hans-Martin Gaudecker - thanks, H-M!

-

-- Removed dependency on xml.sax.saxutils.escape, and included

-  internal implementation instead - proposed by Mike Droettboom on

-  the pyparsing mailing list, thanks Mike!  Also fixed erroneous

-  mapping in replaceHTMLEntity of &quot; to ', now correctly maps

-  to ".  (Also added support for mapping &apos; to '.)

-

-- Fixed typo in ParseResults.insert, found by Alejandro Dubrovsky,

-  good catch!

-

-- Added __dir__() methods to ParseBaseException and ParseResults,

-  to support new dir() behavior in Py2.6 and Py3.0.  If dir() is

-  called on a ParseResults object, the returned list will include

-  the base set of attribute names, plus any results names that are

-  defined.

-

-- Fixed bug in ParseResults.asXML(), in which the first named

-  item within a ParseResults gets reported with an <ITEM> tag 

-  instead of with the correct results name.

-  

-- Fixed bug in '-' error stop, when '-' operator is used inside a 

-  Combine expression.

-

-- Reverted generator expression to use list comprehension, for 

-  better compatibility with old versions of Python.  Reported by

-  jester/artixdesign on the SourceForge pyparsing discussion list.

-

-- Fixed bug in parseString(parseAll=True), when the input string

-  ends with a comment or whitespace.

-

-- Fixed bug in LineStart and LineEnd that did not recognize any

-  special whitespace chars defined using ParserElement.setDefault-

-  WhitespaceChars, found while debugging an issue for Marek Kubica,

-  thanks for the new test case, Marek!

-

-- Made Forward class more tolerant of subclassing.

-

-

-Version 1.5.0 - June, 2008

---------------------------

-This version of pyparsing includes work on two long-standing

-FAQ's: support for forcing parsing of the complete input string

-(without having to explicitly append StringEnd() to the grammar),

-and a method to improve the mechanism of detecting where syntax

-errors occur in an input string with various optional and

-alternative paths.  This release also includes a helper method

-to simplify definition of indentation-based grammars.  With

-these changes (and the past few minor updates), I thought it was

-finally time to bump the minor rev number on pyparsing - so

-1.5.0 is now available!  Read on...

-

-- AT LAST!!!  You can now call parseString and have it raise

-  an exception if the expression does not parse the entire

-  input string.  This has been an FAQ for a LONG time.

-

-  The parseString method now includes an optional parseAll

-  argument (default=False).  If parseAll is set to True, then

-  the given parse expression must parse the entire input

-  string.  (This is equivalent to adding StringEnd() to the

-  end of the expression.)  The default value is False to

-  retain backward compatibility.

-

-  Inspired by MANY requests over the years, most recently by

-  ecir-hana on the pyparsing wiki!

-

-- Added new operator '-' for composing grammar sequences. '-'

-  behaves just like '+' in creating And expressions, but '-'

-  is used to mark grammar structures that should stop parsing

-  immediately and report a syntax error, rather than just

-  backtracking to the last successful parse and trying another

-  alternative.  For instance, running the following code:

-

-    port_definition = Keyword("port") + '=' + Word(nums)

-    entity_definition = Keyword("entity") + "{" +

-        Optional(port_definition) + "}"

-

-    entity_definition.parseString("entity { port 100 }")

-

-  pyparsing fails to detect the missing '=' in the port definition.

-  But, since this expression is optional, pyparsing then proceeds

-  to try to match the closing '}' of the entity_definition.  Not

-  finding it, pyparsing reports that there was no '}' after the '{'

-  character.  Instead, we would like pyparsing to parse the 'port'

-  keyword, and if not followed by an equals sign and an integer,

-  to signal this as a syntax error.

-

-  This can now be done simply by changing the port_definition to:

-

-    port_definition = Keyword("port") - '=' + Word(nums)

-

-  Now after successfully parsing 'port', pyparsing must also find

-  an equals sign and an integer, or it will raise a fatal syntax

-  exception.

-

-  By judicious insertion of '-' operators, a pyparsing developer

-  can have their grammar report much more informative syntax error

-  messages.

-

-  Patches and suggestions proposed by several contributors on

-  the pyparsing mailing list and wiki - special thanks to

-  Eike Welk and Thomas/Poldy on the pyparsing wiki!

-

-- Added indentedBlock helper method, to encapsulate the parse

-  actions and indentation stack management needed to keep track of

-  indentation levels.  Use indentedBlock to define grammars for

-  indentation-based grouping grammars, like Python's.

-

-  indentedBlock takes up to 3 parameters:

-    - blockStatementExpr - expression defining syntax of statement

-        that is repeated within the indented block

-    - indentStack - list created by caller to manage indentation

-        stack (multiple indentedBlock expressions

-        within a single grammar should share a common indentStack)

-    - indent - boolean indicating whether block must be indented

-        beyond the the current level; set to False for block of

-        left-most statements (default=True)

-

-  A valid block must contain at least one indented statement.

-

-- Fixed bug in nestedExpr in which ignored expressions needed

-  to be set off with whitespace.  Reported by Stefaan Himpe,

-  nice catch!

-

-- Expanded multiplication of an expression by a tuple, to

-  accept tuple values of None:

-  . expr*(n,None) or expr*(n,) is equivalent

-    to expr*n + ZeroOrMore(expr)

-    (read as "at least n instances of expr")

-  . expr*(None,n) is equivalent to expr*(0,n)

-    (read as "0 to n instances of expr")

-  . expr*(None,None) is equivalent to ZeroOrMore(expr)

-  . expr*(1,None) is equivalent to OneOrMore(expr)

-

-  Note that expr*(None,n) does not raise an exception if

-  more than n exprs exist in the input stream; that is,

-  expr*(None,n) does not enforce a maximum number of expr

-  occurrences.  If this behavior is desired, then write

-  expr*(None,n) + ~expr

-

-- Added None as a possible operator for operatorPrecedence.

-  None signifies "no operator", as in multiplying m times x

-  in "y=mx+b".

-

-- Fixed bug in Each, reported by Michael Ramirez, in which the

-  order of terms in the Each affected the parsing of the results.

-  Problem was due to premature grouping of the expressions in

-  the overall Each during grammar construction, before the

-  complete Each was defined.  Thanks, Michael!

-

-- Also fixed bug in Each in which Optional's with default values

-  were not getting the defaults added to the results of the

-  overall Each expression.

-

-- Fixed a bug in Optional in which results names were not

-  assigned if a default value was supplied.

-

-- Cleaned up Py3K compatibility statements, including exception

-  construction statements, and better equivalence between _ustr

-  and basestring, and __nonzero__ and __bool__.

-

-

-Version 1.4.11 - February, 2008

--------------------------------

-- With help from Robert A. Clark, this version of pyparsing

-  is compatible with Python 3.0a3.  Thanks for the help,

-  Robert!

-

-- Added WordStart and WordEnd positional classes, to support

-  expressions that must occur at the start or end of a word.

-  Proposed by piranha on the pyparsing wiki, good idea!

-

-- Added matchOnlyAtCol helper parser action, to simplify

-  parsing log or data files that have optional fields that are

-  column dependent.  Inspired by a discussion thread with

-  hubritic on comp.lang.python.

-

-- Added withAttribute.ANY_VALUE as a match-all value when using

-  withAttribute.  Used to ensure that an attribute is present,

-  without having to match on the actual attribute value.

-

-- Added get() method to ParseResults, similar to dict.get().

-  Suggested by new pyparsing user, Alejandro Dubrovksy, thanks!

-

-- Added '==' short-cut to see if a given string matches a

-  pyparsing expression.  For instance, you can now write:

-

-    integer = Word(nums)

-    if "123" == integer:

-       # do something

-

-    print [ x for x in "123 234 asld".split() if x==integer ]

-    # prints ['123', '234']

-

-- Simplified the use of nestedExpr when using an expression for

-  the opening or closing delimiters.  Now the content expression

-  will not have to explicitly negate closing delimiters.  Found

-  while working with dfinnie on GHOP Task #277, thanks!

-

-- Fixed bug when defining ignorable expressions that are

-  later enclosed in a wrapper expression (such as ZeroOrMore,

-  OneOrMore, etc.) - found while working with Prabhu

-  Gurumurthy, thanks Prahbu!

-

-- Fixed bug in withAttribute in which keys were automatically

-  converted to lowercase, making it impossible to match XML

-  attributes with uppercase characters in them.  Using with-

-  Attribute requires that you reference attributes in all

-  lowercase if parsing HTML, and in correct case when parsing

-  XML.

-

-- Changed '<<' operator on Forward to return None, since this

-  is really used as a pseudo-assignment operator, not as a

-  left-shift operator.  By returning None, it is easier to

-  catch faulty statements such as a << b | c, where precedence

-  of operations causes the '|' operation to be performed

-  *after* inserting b into a, so no alternation is actually

-  implemented.  The correct form is a << (b | c).  With this

-  change, an error will be reported instead of silently

-  clipping the alternative term.  (Note: this may break some

-  existing code, but if it does, the code had a silent bug in

-  it anyway.)  Proposed by wcbarksdale on the pyparsing wiki,

-  thanks!

-

-- Several unit tests were added to pyparsing's regression

-  suite, courtesy of the Google Highly-Open Participation

-  Contest.  Thanks to all who administered and took part in

-  this event!

-

-

-Version 1.4.10 - December 9, 2007

----------------------------------

-- Fixed bug introduced in v1.4.8, parse actions were called for

-  intermediate operator levels, not just the deepest matching

-  operation level.  Again, big thanks to Torsten Marek for

-  helping isolate this problem!

-

-

-Version 1.4.9 - December 8, 2007

---------------------------------

-- Added '*' multiplication operator support when creating

-  grammars, accepting either an integer, or a two-integer

-  tuple multiplier, as in:

-    ipAddress = Word(nums) + ('.'+Word(nums))*3

-    usPhoneNumber = Word(nums) + ('-'+Word(nums))*(1,2)

-  If multiplying by a tuple, the two integer values represent

-  min and max multiples.  Suggested by Vincent of eToy.com,

-  great idea, Vincent!

-

-- Fixed bug in nestedExpr, original version was overly greedy!

-  Thanks to Michael Ramirez for raising this issue.

-

-- Fixed internal bug in ParseResults - when an item was deleted,

-  the key indices were not updated.  Thanks to Tim Mitchell for

-  posting a bugfix patch to the SF bug tracking system!

-

-- Fixed internal bug in operatorPrecedence - when the results of

-  a right-associative term were sent to a parse action, the wrong

-  tokens were sent.  Reported by Torsten Marek, nice job!

-

-- Added pop() method to ParseResults.  If pop is called with an

-  integer or with no arguments, it will use list semantics and

-  update the ParseResults' list of tokens.  If pop is called with

-  a non-integer (a string, for instance), then it will use dict

-  semantics and update the ParseResults' internal dict.

-  Suggested by Donn Ingle, thanks Donn!

-

-- Fixed quoted string built-ins to accept '\xHH' hex characters

-  within the string.

-

-

-Version 1.4.8 - October, 2007

------------------------------

-- Added new helper method nestedExpr to easily create expressions

-  that parse lists of data in nested parentheses, braces, brackets,

-  etc.

-

-- Added withAttribute parse action helper, to simplify creating

-  filtering parse actions to attach to expressions returned by

-  makeHTMLTags and makeXMLTags.  Use withAttribute to qualify a

-  starting tag with one or more required attribute values, to avoid

-  false matches on common tags such as <TD> or <DIV>.

-

-- Added new examples nested.py and withAttribute.py to demonstrate

-  the new features.

-

-- Added performance speedup to grammars using operatorPrecedence,

-  instigated by Stefan Reichör - thanks for the feedback, Stefan!

-

-- Fixed bug/typo when deleting an element from a ParseResults by

-  using the element's results name.

-

-- Fixed whitespace-skipping bug in wrapper classes (such as Group,

-  Suppress, Combine, etc.) and when using setDebug(), reported by

-  new pyparsing user dazzawazza on SourceForge, nice job!

-

-- Added restriction to prevent defining Word or CharsNotIn expressions

-  with minimum length of 0 (should use Optional if this is desired),

-  and enhanced docstrings to reflect this limitation.  Issue was

-  raised by Joey Tallieu, who submitted a patch with a slightly

-  different solution.  Thanks for taking the initiative, Joey, and

-  please keep submitting your ideas!

-

-- Fixed bug in makeHTMLTags that did not detect HTML tag attributes

-  with no '= value' portion (such as "<td nowrap>"), reported by

-  hamidh on the pyparsing wiki - thanks!

-

-- Fixed minor bug in makeHTMLTags and makeXMLTags, which did not

-  accept whitespace in closing tags.

-

-

-Version 1.4.7 - July, 2007

---------------------------

-- NEW NOTATION SHORTCUT: ParserElement now accepts results names using

-  a notational shortcut, following the expression with the results name

-  in parentheses.  So this:

-

-    stats = "AVE:" + realNum.setResultsName("average") + \

-            "MIN:" + realNum.setResultsName("min") + \

-            "MAX:" + realNum.setResultsName("max")

-

-  can now be written as this:

-

-    stats = "AVE:" + realNum("average") + \

-            "MIN:" + realNum("min") + \

-            "MAX:" + realNum("max")

-

-  The intent behind this change is to make it simpler to define results

-  names for significant fields within the expression, while keeping

-  the grammar syntax clean and uncluttered.

-

-- Fixed bug when packrat parsing is enabled, with cached ParseResults

-  being updated by subsequent parsing.  Reported on the pyparsing

-  wiki by Kambiz, thanks!

-

-- Fixed bug in operatorPrecedence for unary operators with left

-  associativity, if multiple operators were given for the same term.

-

-- Fixed bug in example simpleBool.py, corrected precedence of "and" vs.

-  "or" operations.

-

-- Fixed bug in Dict class, in which keys were converted to strings

-  whether they needed to be or not.  Have narrowed this logic to

-  convert keys to strings only if the keys are ints (which would

-  confuse __getitem__ behavior for list indexing vs. key lookup).

-

-- Added ParserElement method setBreak(), which will invoke the pdb

-  module's set_trace() function when this expression is about to be

-  parsed.

-

-- Fixed bug in StringEnd in which reading off the end of the input

-  string raises an exception - should match.  Resolved while

-  answering a question for Shawn on the pyparsing wiki.

-

-

-Version 1.4.6 - April, 2007

----------------------------

-- Simplified constructor for ParseFatalException, to support common

-  exception construction idiom:

-    raise ParseFatalException, "unexpected text: 'Spanish Inquisition'"

-

-- Added method getTokensEndLoc(), to be called from within a parse action,

-  for those parse actions that need both the starting *and* ending

-  location of the parsed tokens within the input text.

-

-- Enhanced behavior of keepOriginalText so that named parse fields are

-  preserved, even though tokens are replaced with the original input

-  text matched by the current expression.  Also, cleaned up the stack

-  traversal to be more robust.  Suggested by Tim Arnold - thanks, Tim!

-

-- Fixed subtle bug in which countedArray (and similar dynamic

-  expressions configured in parse actions) failed to match within Or,

-  Each, FollowedBy, or NotAny.  Reported by Ralf Vosseler, thanks for

-  your patience, Ralf!

-

-- Fixed Unicode bug in upcaseTokens and downcaseTokens parse actions,

-  scanString, and default debugging actions; reported (and patch submitted)

-  by Nikolai Zamkovoi, spasibo!

-

-- Fixed bug when saving a tuple as a named result.  The returned

-  token list gave the proper tuple value, but accessing the result by

-  name only gave the first element of the tuple.  Reported by

-  Poromenos, nice catch!

-

-- Fixed bug in makeHTMLTags/makeXMLTags, which failed to match tag

-  attributes with namespaces.

-

-- Fixed bug in SkipTo when setting include=True, to have the skipped-to

-  tokens correctly included in the returned data.  Reported by gunars on

-  the pyparsing wiki, thanks!

-

-- Fixed typobug in OnceOnly.reset method, omitted self argument.

-  Submitted by eike welk, thanks for the lint-picking!

-

-- Added performance enhancement to Forward class, suggested by

-  akkartik on the pyparsing Wiki discussion, nice work!

-

-- Added optional asKeyword to Word constructor, to indicate that the

-  given word pattern should be matched only as a keyword, that is, it

-  should only match if it is within word boundaries.

-

-- Added S-expression parser to examples directory.

-

-- Added macro substitution example to examples directory.

-

-- Added holaMundo.py example, excerpted from Marco Alfonso's blog -

-  muchas gracias, Marco!

-

-- Modified internal cyclic references in ParseResults to use weakrefs;

-  this should help reduce the memory footprint of large parsing

-  programs, at some cost to performance (3-5%). Suggested by bca48150 on

-  the pyparsing wiki, thanks!

-

-- Enhanced the documentation describing the vagaries and idiosyncracies

-  of parsing strings with embedded tabs, and the impact on:

-  . parse actions

-  . scanString

-  . col and line helper functions

-  (Suggested by eike welk in response to some unexplained inconsistencies

-  between parsed location and offsets in the input string.)

-

-- Cleaned up internal decorators to preserve function names,

-  docstrings, etc.

-

-

-Version 1.4.5 - December, 2006

-------------------------------

-- Removed debugging print statement from QuotedString class.  Sorry

-  for not stripping this out before the 1.4.4 release!

-

-- A significant performance improvement, the first one in a while!

-  For my Verilog parser, this version of pyparsing is about double the

-  speed - YMMV.

-

-- Added support for pickling of ParseResults objects.  (Reported by

-  Jeff Poole, thanks Jeff!)

-

-- Fixed minor bug in makeHTMLTags that did not recognize tag attributes

-  with embedded '-' or '_' characters.  Also, added support for

-  passing expressions to makeHTMLTags and makeXMLTags, and used this

-  feature to define the globals anyOpenTag and anyCloseTag.

-

-- Fixed error in alphas8bit, I had omitted the y-with-umlaut character.

-

-- Added punc8bit string to complement alphas8bit - it contains all the

-  non-alphabetic, non-blank 8-bit characters.

-

-- Added commonHTMLEntity expression, to match common HTML "ampersand"

-  codes, such as "&lt;", "&gt;", "&amp;", "&nbsp;", and "&quot;".  This

-  expression also defines a results name 'entity', which can be used

-  to extract the entity field (that is, "lt", "gt", etc.).  Also added

-  built-in parse action replaceHTMLEntity, which can be attached to

-  commonHTMLEntity to translate "&lt;", "&gt;", "&amp;", "&nbsp;", and

-  "&quot;" to "<", ">", "&", " ", and "'".

-

-- Added example, htmlStripper.py, that strips HTML tags and scripts

-  from HTML pages.  It also translates common HTML entities to their

-  respective characters.

-

-

-Version 1.4.4 - October, 2006

--------------------------------

-- Fixed traceParseAction decorator to also trap and record exception

-  returns from parse actions, and to handle parse actions with 0,

-  1, 2, or 3 arguments.

-

-- Enhanced parse action normalization to support using classes as

-  parse actions; that is, the class constructor is called at parse

-  time and the __init__ function is called with 0, 1, 2, or 3

-  arguments.  If passing a class as a parse action, the __init__

-  method must use one  of the valid parse action parameter list

-  formats. (This technique is useful when using pyparsing to compile

-  parsed text into a series of application objects - see the new

-  example simpleBool.py.)

-

-- Fixed bug in ParseResults when setting an item using an integer

-  index. (Reported by Christopher Lambacher, thanks!)

-

-- Fixed whitespace-skipping bug, patch submitted by Paolo Losi -

-  grazie, Paolo!

-

-- Fixed bug when a Combine contained an embedded Forward expression,

-  reported by cie on the pyparsing wiki - good catch!

-

-- Fixed listAllMatches bug, when a listAllMatches result was

-  nested within another result. (Reported by don pasquale on

-  comp.lang.python, well done!)

-

-- Fixed bug in ParseResults items() method, when returning an item

-  marked as listAllMatches=True

-

-- Fixed bug in definition of cppStyleComment (and javaStyleComment)

-  in which '//' line comments were not continued to the next line

-  if the line ends with a '\'.  (Reported by eagle-eyed Ralph

-  Corderoy!)

-

-- Optimized re's for cppStyleComment and quotedString for better

-  re performance - also provided by Ralph Corderoy, thanks!

-

-- Added new example, indentedGrammarExample.py, showing how to

-  define a grammar using indentation to show grouping (as Python

-  does for defining statement nesting).  Instigated by an e-mail

-  discussion with Andrew Dalke, thanks Andrew!

-

-- Added new helper operatorPrecedence (based on e-mail list discussion

-  with Ralph Corderoy and Paolo Losi), to facilitate definition of

-  grammars for expressions with unary and binary operators.  For

-  instance, this grammar defines a 6-function arithmetic expression

-  grammar, with unary plus and minus, proper operator precedence,and

-  right- and left-associativity:

-

-    expr = operatorPrecedence( operand,

-        [("!", 1, opAssoc.LEFT),

-         ("^", 2, opAssoc.RIGHT),

-         (oneOf("+ -"), 1, opAssoc.RIGHT),

-         (oneOf("* /"), 2, opAssoc.LEFT),

-         (oneOf("+ -"), 2, opAssoc.LEFT),]

-        )

-

-  Also added example simpleArith.py and simpleBool.py to provide

-  more detailed code samples using this new helper method.

-

-- Added new helpers matchPreviousLiteral and matchPreviousExpr, for

-  creating adaptive parsing expressions that match the same content

-  as was parsed in a previous parse expression.  For instance:

-

-        first = Word(nums)

-        matchExpr = first + ":" + matchPreviousLiteral(first)

-

-  will match "1:1", but not "1:2".  Since this matches at the literal

-  level, this will also match the leading "1:1" in "1:10".

-

-  In contrast:

-

-        first = Word(nums)

-        matchExpr = first + ":" + matchPreviousExpr(first)

-

-  will *not* match the leading "1:1" in "1:10"; the expressions are

-  evaluated first, and then compared, so "1" is compared with "10".

-

-- Added keepOriginalText parse action.  Sometimes pyparsing's

-  whitespace-skipping leaves out too much whitespace.  Adding this

-  parse action will restore any internal whitespace for a parse

-  expression.  This is especially useful when defining expressions

-  for scanString or transformString applications.

-

-- Added __add__ method for ParseResults class, to better support

-  using Python sum built-in for summing ParseResults objects returned

-  from scanString.

-

-- Added reset method for the new OnlyOnce class wrapper for parse

-  actions (to allow a grammar to be used multiple times).

-

-- Added optional maxMatches argument to scanString and searchString,

-  to short-circuit scanning after 'n' expression matches are found.

-

-

-Version 1.4.3 - July, 2006

-------------------------------

-- Fixed implementation of multiple parse actions for an expression

-  (added in 1.4.2).

-  . setParseAction() reverts to its previous behavior, setting

-    one (or more) actions for an expression, overwriting any

-    action or actions previously defined

-  . new method addParseAction() appends one or more parse actions

-    to the list of parse actions attached to an expression

-  Now it is harder to accidentally append parse actions to an

-  expression, when what you wanted to do was overwrite whatever had

-  been defined before.  (Thanks, Jean-Paul Calderone!)

-

-- Simplified interface to parse actions that do not require all 3

-  parse action arguments.  Very rarely do parse actions require more

-  than just the parsed tokens, yet parse actions still require all

-  3 arguments including the string being parsed and the location

-  within the string where the parse expression was matched.  With this

-  release, parse actions may now be defined to be called as:

-  . fn(string,locn,tokens)  (the current form)

-  . fn(locn,tokens)

-  . fn(tokens)

-  . fn()

-  The setParseAction and addParseAction methods will internally decorate

-  the provided parse actions with compatible wrappers to conform to

-  the full (string,locn,tokens) argument sequence.

-

-- REMOVED SUPPORT FOR RETURNING PARSE LOCATION FROM A PARSE ACTION.

-  I announced this in March, 2004, and gave a final warning in the last

-  release.  Now you can return a tuple from a parse action, and it will

-  be treated like any other return value (i.e., the tuple will be

-  substituted for the incoming tokens passed to the parse action,

-  which is useful when trying to parse strings into tuples).

-

-- Added setFailAction method, taking a callable function fn that

-  takes the arguments fn(s,loc,expr,err) where:

-  . s - string being parsed

-  . loc - location where expression match was attempted and failed

-  . expr - the parse expression that failed

-  . err - the exception thrown

-  The function returns no values.  It may throw ParseFatalException

-  if it is desired to stop parsing immediately.

-  (Suggested by peter21081944 on wikispaces.com)

-

-- Added class OnlyOnce as helper wrapper for parse actions.  OnlyOnce

-  only permits a parse action to be called one time, after which

-  all subsequent calls throw a ParseException.

-

-- Added traceParseAction decorator to help debug parse actions.

-  Simply insert "@traceParseAction" ahead of the definition of your

-  parse action, and each invocation will be displayed, along with

-  incoming arguments, and returned value.

-

-- Fixed bug when copying ParserElements using copy() or

-  setResultsName().  (Reported by Dan Thill, great catch!)

-

-- Fixed bug in asXML() where token text contains <, >, and &

-  characters - generated XML now escapes these as &lt;, &gt; and

-  &amp;.  (Reported by Jacek Sieka, thanks!)

-

-- Fixed bug in SkipTo() when searching for a StringEnd(). (Reported

-  by Pete McEvoy, thanks Pete!)

-

-- Fixed "except Exception" statements, the most critical added as part

-  of the packrat parsing enhancement.  (Thanks, Erick Tryzelaar!)

-

-- Fixed end-of-string infinite looping on LineEnd and StringEnd

-  expressions.  (Thanks again to Erick Tryzelaar.)

-

-- Modified setWhitespaceChars to return self, to be consistent with

-  other ParserElement modifiers. (Suggested by Erick Tryzelaar.)

-

-- Fixed bug/typo in new ParseResults.dump() method.

-

-- Fixed bug in searchString() method, in which only the first token of

-  an expression was returned.  searchString() now returns a

-  ParseResults collection of all search matches.

-

-- Added example program removeLineBreaks.py, a string transformer that

-  converts text files with hard line-breaks into one with line breaks

-  only between paragraphs.

-

-- Added example program listAllMatches.py, to illustrate using the

-  listAllMatches option when specifying results names (also shows new

-  support for passing lists to oneOf).

-

-- Added example program linenoExample.py, to illustrate using the

-  helper methods lineno, line, and col, and returning objects from a

-  parse action.

-

-- Added example program parseListString.py, to which can parse the

-  string representation of a Python list back into a true list.  Taken

-  mostly from my PyCon presentation examples, but now with support

-  for tuple elements, too!

-

-

-

-Version 1.4.2 - April 1, 2006 (No foolin'!)

--------------------------------------------

-- Significant speedup from memoizing nested expressions (a technique

-  known as "packrat parsing"), thanks to Chris Lesniewski-Laas!  Your

-  mileage may vary, but my Verilog parser almost doubled in speed to

-  over 600 lines/sec!

-

-  This speedup may break existing programs that use parse actions that

-  have side-effects.  For this reason, packrat parsing is disabled when

-  you first import pyparsing.  To activate the packrat feature, your

-  program must call the class method ParserElement.enablePackrat().  If

-  your program uses psyco to "compile as you go", you must call

-  enablePackrat before calling psyco.full().  If you do not do this,

-  Python will crash.  For best results, call enablePackrat() immediately

-  after importing pyparsing.

-

-- Added new helper method countedArray(expr), for defining patterns that

-  start with a leading integer to indicate the number of array elements,

-  followed by that many elements, matching the given expr parse

-  expression.  For instance, this two-liner:

-    wordArray = countedArray(Word(alphas))

-    print wordArray.parseString("3 Practicality beats purity")[0]

-  returns the parsed array of words:

-    ['Practicality', 'beats', 'purity']

-  The leading token '3' is suppressed, although it is easily obtained

-  from the length of the returned array.

-  (Inspired by e-mail discussion with Ralf Vosseler.)

-

-- Added support for attaching multiple parse actions to a single

-  ParserElement. (Suggested by Dan "Dang" Griffith - nice idea, Dan!)

-

-- Added support for asymmetric quoting characters in the recently-added

-  QuotedString class.  Now you can define your own quoted string syntax

-  like "<<This is a string in double angle brackets.>>".  To define

-  this custom form of QuotedString, your code would define:

-    dblAngleQuotedString = QuotedString('<<',endQuoteChar='>>')

-  QuotedString also supports escaped quotes, escape character other

-  than '\', and multiline.

-

-- Changed the default value returned internally by Optional, so that

-  None can be used as a default value.  (Suggested by Steven Bethard -

-  I finally saw the light!)

-

-- Added dump() method to ParseResults, to make it easier to list out

-  and diagnose values returned from calling parseString.

-

-- A new example, a search query string parser, submitted by Steven

-  Mooij and Rudolph Froger - a very interesting application, thanks!

-

-- Added an example that parses the BNF in Python's Grammar file, in

-  support of generating Python grammar documentation. (Suggested by

-  J H Stovall.)

-

-- A new example, submitted by Tim Cera, of a flexible parser module,

-  using a simple config variable to adjust parsing for input formats

-  that have slight variations - thanks, Tim!

-

-- Added an example for parsing Roman numerals, showing the capability

-  of parse actions to "compile" Roman numerals into their integer

-  values during parsing.

-

-- Added a new docs directory, for additional documentation or help.

-  Currently, this includes the text and examples from my recent

-  presentation at PyCon.

-

-- Fixed another typo in CaselessKeyword, thanks Stefan Behnel.

-

-- Expanded oneOf to also accept tuples, not just lists.  This really

-  should be sufficient...

-

-- Added deprecation warnings when tuple is returned from a parse action.

-  Looking back, I see that I originally deprecated this feature in March,

-  2004, so I'm guessing people really shouldn't have been using this

-  feature - I'll drop it altogether in the next release, which will

-  allow users to return a tuple from a parse action (which is really

-  handy when trying to reconstuct tuples from a tuple string

-  representation!).

-

-

-Version 1.4.1 - February, 2006

-------------------------------

-- Converted generator expression in QuotedString class to list

-  comprehension, to retain compatibility with Python 2.3. (Thanks, Titus

-  Brown for the heads-up!)

-

-- Added searchString() method to ParserElement, as an alternative to

-  using "scanString(instring).next()[0][0]" to search through a string

-  looking for a substring matching a given parse expression. (Inspired by

-  e-mail conversation with Dave Feustel.)

-

-- Modified oneOf to accept lists of strings as well as a single string

-  of space-delimited literals.  (Suggested by Jacek Sieka - thanks!)

-

-- Removed deprecated use of Upcase in pyparsing test code. (Also caught by

-  Titus Brown.)

-

-- Removed lstrip() call from Literal - too aggressive in stripping

-  whitespace which may be valid for some grammars.  (Point raised by Jacek

-  Sieka).  Also, made Literal more robust in the event of passing an empty

-  string.

-

-- Fixed bug in replaceWith when returning None.

-

-- Added cautionary documentation for Forward class when assigning a

-  MatchFirst expression, as in:

-    fwdExpr << a | b | c

-  Precedence of operators causes this to be evaluated as:

-    (fwdExpr << a) | b | c

-  thereby leaving b and c out as parseable alternatives.  Users must

-  explicitly group the values inserted into the Forward:

-    fwdExpr << (a | b | c)

-  (Suggested by Scot Wilcoxon - thanks, Scot!)

-

-

-Version 1.4 - January 18, 2006

-------------------------------

-- Added Regex class, to permit definition of complex embedded expressions

-  using regular expressions. (Enhancement provided by John Beisley, great

-  job!)

-

-- Converted implementations of Word, oneOf, quoted string, and comment

-  helpers to utilize regular expression matching.  Performance improvements

-  in the 20-40% range.

-

-- Added QuotedString class, to support definition of non-standard quoted

-  strings (Suggested by Guillaume Proulx, thanks!)

-

-- Added CaselessKeyword class, to streamline grammars with, well, caseless

-  keywords (Proposed by Stefan Behnel, thanks!)

-

-- Fixed bug in SkipTo, when using an ignoreable expression. (Patch provided

-  by Anonymous, thanks, whoever-you-are!)

-

-- Fixed typo in NoMatch class. (Good catch, Stefan Behnel!)

-

-- Fixed minor bug in _makeTags(), using string.printables instead of

-  pyparsing.printables.

-

-- Cleaned up some of the expressions created by makeXXXTags helpers, to

-  suppress extraneous <> characters.

-

-- Added some grammar definition-time checking to verify that a grammar is

-  being built using proper ParserElements.

-

-- Added examples:

-  . LAparser.py - linear algebra C preprocessor (submitted by Mike Ellis,

-    thanks Mike!)

-  . wordsToNum.py - converts word description of a number back to

-    the original number (such as 'one hundred and twenty three' -> 123)

-  . updated fourFn.py to support unary minus, added BNF comments

-

-

-Version 1.3.3 - September 12, 2005

-----------------------------------

-- Improved support for Unicode strings that would be returned using

-  srange.  Added greetingInKorean.py example, for a Korean version of

-  "Hello, World!" using Unicode. (Thanks, June Kim!)

-

-- Added 'hexnums' string constant (nums+"ABCDEFabcdef") for defining

-  hexadecimal value expressions.

-

-- NOTE: ===THIS CHANGE MAY BREAK EXISTING CODE===

-  Modified tag and results definitions returned by makeHTMLTags(),

-  to better support the looseness of HTML parsing.  Tags to be

-  parsed are now caseless, and keys generated for tag attributes are

-  now converted to lower case.

-

-  Formerly, makeXMLTags("XYZ") would return a tag with results

-  name of "startXYZ", this has been changed to "startXyz".  If this

-  tag is matched against '<XYZ Abc="1" DEF="2" ghi="3">', the

-  matched keys formerly would be "Abc", "DEF", and "ghi"; keys are

-  now converted to lower case, giving keys of "abc", "def", and

-  "ghi".  These changes were made to try to address the lax

-  case sensitivity agreement between start and end tags in many

-  HTML pages.

-

-  No changes were made to makeXMLTags(), which assumes more rigorous

-  parsing rules.

-

-  Also, cleaned up case-sensitivity bugs in closing tags, and

-  switched to using Keyword instead of Literal class for tags.

-  (Thanks, Steve Young, for getting me to look at these in more

-  detail!)

-

-- Added two helper parse actions, upcaseTokens and downcaseTokens,

-  which will convert matched text to all uppercase or lowercase,

-  respectively.

-

-- Deprecated Upcase class, to be replaced by upcaseTokens parse

-  action.

-

-- Converted messages sent to stderr to use warnings module, such as

-  when constructing a Literal with an empty string, one should use

-  the Empty() class or the empty helper instead.

-

-- Added ' ' (space) as an escapable character within a quoted

-  string.

-

-- Added helper expressions for common comment types, in addition

-  to the existing cStyleComment (/*...*/) and htmlStyleComment

-  (<!-- ... -->)

-  . dblSlashComment = // ... (to end of line)

-  . cppStyleComment = cStyleComment or dblSlashComment

-  . javaStyleComment = cppStyleComment

-  . pythonStyleComment = # ... (to end of line)

-

-

-

-Version 1.3.2 - July 24, 2005

------------------------------

-- Added Each class as an enhanced version of And.  'Each' requires

-  that all given expressions be present, but may occur in any order.

-  Special handling is provided to group ZeroOrMore and OneOrMore

-  elements that occur out-of-order in the input string.  You can also

-  construct 'Each' objects by joining expressions with the '&'

-  operator.  When using the Each class, results names are strongly

-  recommended for accessing the matched tokens. (Suggested by Pradam

-  Amini - thanks, Pradam!)

-

-- Stricter interpretation of 'max' qualifier on Word elements.  If the

-  'max' attribute is specified, matching will fail if an input field

-  contains more than 'max' consecutive body characters.  For example,

-  previously, Word(nums,max=3) would match the first three characters

-  of '0123456', returning '012' and continuing parsing at '3'.  Now,

-  when constructed using the max attribute, Word will raise an

-  exception with this string.

-

-- Cleaner handling of nested dictionaries returned by Dict.  No

-  longer necessary to dereference sub-dictionaries as element [0] of

-  their parents.

-  === NOTE: THIS CHANGE MAY BREAK SOME EXISTING CODE, BUT ONLY IF

-  PARSING NESTED DICTIONARIES USING THE LITTLE-USED DICT CLASS ===

-  (Prompted by discussion thread on the Python Tutor list, with

-  contributions from Danny Yoo, Kent Johnson, and original post by

-  Liam Clarke - thanks all!)

-

-

-

-Version 1.3.1 - June, 2005

-----------------------------------

-- Added markInputline() method to ParseException, to display the input

-  text line location of the parsing exception. (Thanks, Stefan Behnel!)

-

-- Added setDefaultKeywordChars(), so that Keyword definitions using a

-  custom keyword character set do not all need to add the keywordChars

-  constructor argument (similar to setDefaultWhitespaceChars()).

-  (suggested by rzhanka on the SourceForge pyparsing forum.)

-

-- Simplified passing debug actions to setDebugAction().  You can now

-  pass 'None' for a debug action if you want to take the default

-  debug behavior.  To suppress a particular debug action, you can pass

-  the pyparsing method nullDebugAction.

-

-- Refactored parse exception classes, moved all behavior to

-  ParseBaseException, and the former ParseException is now a subclass of

-  ParseBaseException.  Added a second subclass, ParseFatalException, as

-  a subclass of ParseBaseException.  User-defined parse actions can raise

-  ParseFatalException if a data inconsistency is detected (such as a

-  begin-tag/end-tag mismatch), and this will stop all parsing immediately.

-  (Inspired by e-mail thread with Michele Petrazzo - thanks, Michelle!)

-

-- Added helper methods makeXMLTags and makeHTMLTags, that simplify the

-  definition of XML or HTML tag parse expressions for a given tagname.

-  Both functions return a pair of parse expressions, one for the opening

-  tag (that is, '<tagname>') and one for the closing tag ('</tagname>').

-  The opening tagame also recognizes any attribute definitions that have

-  been included in the opening tag, as well as an empty tag (one with a

-  trailing '/', as in '<BODY/>' which is equivalent to '<BODY></BODY>').

-  makeXMLTags uses stricter XML syntax for attributes, requiring that they

-  be enclosed in double quote characters - makeHTMLTags is more lenient,

-  and accepts single-quoted strings or any contiguous string of characters

-  up to the next whitespace character or '>' character.  Attributes can

-  be retrieved as dictionary or attribute values of the returned results

-  from the opening tag.

-

-- Added example minimath2.py, a refinement on fourFn.py that adds

-  an interactive session and support for variables.  (Thanks, Steven Siew!)

-

-- Added performance improvement, up to 20% reduction!  (Found while working

-  with Wolfgang Borgert on performance tuning of his TTCN3 parser.)

-

-- And another performance improvement, up to 25%, when using scanString!

-  (Found while working with Henrik Westlund on his C header file scanner.)

-

-- Updated UML diagrams to reflect latest class/method changes.

-

-

-Version 1.3 - March, 2005

-----------------------------------

-- Added new Keyword class, as a special form of Literal.  Keywords

-  must be followed by whitespace or other non-keyword characters, to

-  distinguish them from variables or other identifiers that just

-  happen to start with the same characters as a keyword.  For instance,

-  the input string containing "ifOnlyIfOnly" will match a Literal("if")

-  at the beginning and in the middle, but will fail to match a

-  Keyword("if").  Keyword("if") will match only strings such as "if only"

-  or "if(only)". (Proposed by Wolfgang Borgert, and Berteun Damman

-  separately requested this on comp.lang.python - great idea!)

-

-- Added setWhitespaceChars() method to override the characters to be

-  skipped as whitespace before matching a particular ParseElement.  Also

-  added the class-level method setDefaultWhitespaceChars(), to allow

-  users to override the default set of whitespace characters (space,

-  tab, newline, and return) for all subsequently defined ParseElements.

-  (Inspired by Klaas Hofstra's inquiry on the Sourceforge pyparsing

-  forum.)

-

-- Added helper parse actions to support some very common parse

-  action use cases:

-  . replaceWith(replStr) - replaces the matching tokens with the

-    provided replStr replacement string; especially useful with

-    transformString()

-  . removeQuotes - removes first and last character from string enclosed

-    in quotes (note - NOT the same as the string strip() method, as only

-    a single character is removed at each end)

-

-- Added copy() method to ParseElement, to make it easier to define

-  different parse actions for the same basic parse expression.  (Note, copy

-  is implicitly called when using setResultsName().)

-

-

-  (The following changes were posted to CVS as Version 1.2.3 -

-  October-December, 2004)

-

-- Added support for Unicode strings in creating grammar definitions.

-  (Big thanks to Gavin Panella!)

-

-- Added constant alphas8bit to include the following 8-bit characters:

-    ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ

-

-- Added srange() function to simplify definition of Word elements, using

-  regexp-like '[A-Za-z0-9]' syntax.  This also simplifies referencing

-  common 8-bit characters.

-

-- Fixed bug in Dict when a single element Dict was embedded within another

-  Dict. (Thanks Andy Yates for catching this one!)

-

-- Added 'formatted' argument to ParseResults.asXML().  If set to False,

-  suppresses insertion of whitespace for pretty-print formatting.  Default

-  equals True for backward compatibility.

-

-- Added setDebugActions() function to ParserElement, to allow user-defined

-  debugging actions.

-

-- Added support for escaped quotes (either in \', \", or doubled quote

-  form) to the predefined expressions for quoted strings. (Thanks, Ero

-  Carrera!)

-

-- Minor performance improvement (~5%) converting "char in string" tests

-  to "char in dict". (Suggested by Gavin Panella, cool idea!)

-

-

-Version 1.2.2 - September 27, 2004

-----------------------------------

-- Modified delimitedList to accept an expression as the delimiter, instead

-  of only accepting strings.

-

-- Modified ParseResults, to convert integer field keys to strings (to

-  avoid confusion with list access).

-

-- Modified Combine, to convert all embedded tokens to strings before

-  combining.

-

-- Fixed bug in MatchFirst in which parse actions would be called for

-  expressions that only partially match. (Thanks, John Hunter!)

-

-- Fixed bug in fourFn.py example that fixes right-associativity of ^

-  operator. (Thanks, Andrea Griffini!)

-

-- Added class FollowedBy(expression), to look ahead in the input string

-  without consuming tokens.

-

-- Added class NoMatch that never matches any input. Can be useful in

-  debugging, and in very specialized grammars.

-

-- Added example pgn.py, for parsing chess game files stored in Portable

-  Game Notation. (Thanks, Alberto Santini!)

-

-

-Version 1.2.1 - August 19, 2004

--------------------------------

-- Added SkipTo(expression) token type, simplifying grammars that only

-  want to specify delimiting expressions, and want to match any characters

-  between them.

-

-- Added helper method dictOf(key,value), making it easier to work with

-  the Dict class. (Inspired by Pavel Volkovitskiy, thanks!).

-

-- Added optional argument listAllMatches (default=False) to

-  setResultsName().  Setting listAllMatches to True overrides the default

-  modal setting of tokens to results names; instead, the results name

-  acts as an accumulator for all matching tokens within the local

-  repetition group. (Suggested by Amaury Le Leyzour - thanks!)

-

-- Fixed bug in ParseResults, throwing exception when trying to extract

-  slice, or make a copy using [:]. (Thanks, Wilson Fowlie!)

-

-- Fixed bug in transformString() when the input string contains <TAB>'s

-  (Thanks, Rick Walia!).

-

-- Fixed bug in returning tokens from un-Grouped And's, Or's and

-  MatchFirst's, where too many tokens would be included in the results,

-  confounding parse actions and returned results.

-

-- Fixed bug in naming ParseResults returned by And's, Or's, and Match

-  First's.

-

-- Fixed bug in LineEnd() - matching this token now correctly consumes

-  and returns the end of line "\n".

-

-- Added a beautiful example for parsing Mozilla calendar files (Thanks,

-  Petri Savolainen!).

-

-- Added support for dynamically modifying Forward expressions during

-  parsing.

-

-

-Version 1.2 - 20 June 2004

---------------------------

-- Added definition for htmlComment to help support HTML scanning and

-  parsing.

-

-- Fixed bug in generating XML for Dict classes, in which trailing item was

-  duplicated in the output XML.

-

-- Fixed release bug in which scanExamples.py was omitted from release

-  files.

-

-- Fixed bug in transformString() when parse actions are not defined on the

-  outermost parser element.

-

-- Added example urlExtractor.py, as another example of using scanString

-  and parse actions.

-

-

-Version 1.2beta3 - 4 June 2004

-------------------------------

-- Added White() token type, analogous to Word, to match on whitespace

-  characters.  Use White in parsers with significant whitespace (such as

-  configuration file parsers that use indentation to indicate grouping).

-  Construct White with a string containing the whitespace characters to be

-  matched.  Similar to Word, White also takes optional min, max, and exact

-  parameters.

-

-- As part of supporting whitespace-signficant parsing, added parseWithTabs()

-  method to ParserElement, to override the default behavior in parseString

-  of automatically expanding tabs to spaces.  To retain tabs during

-  parsing, call parseWithTabs() before calling parseString(), parseFile() or

-  scanString(). (Thanks, Jean-Guillaume Paradis for catching this, and for

-  your suggestions on whitespace-significant parsing.)

-

-- Added transformString() method to ParseElement, as a complement to

-  scanString().  To use transformString, define a grammar and attach a parse

-  action to the overall grammar that modifies the returned token list.

-  Invoking transformString() on a target string will then scan for matches,

-  and replace the matched text patterns according to the logic in the parse

-  action.  transformString() returns the resulting transformed string.

-  (Note: transformString() does *not* automatically expand tabs to spaces.)

-  Also added scanExamples.py to the examples directory to show sample uses of

-  scanString() and transformString().

-

-- Removed group() method that was introduced in beta2.  This turns out NOT to

-  be equivalent to nesting within a Group() object, and I'd prefer not to sow

-  more seeds of confusion.

-

-- Fixed behavior of asXML() where tags for groups were incorrectly duplicated.

-  (Thanks, Brad Clements!)

-

-- Changed beta version message to display to stderr instead of stdout, to

-  make asXML() easier to use.  (Thanks again, Brad.)

-

-

-Version 1.2beta2 - 19 May 2004

-------------------------------

-- *** SIMPLIFIED API *** - Parse actions that do not modify the list of tokens

-  no longer need to return a value.  This simplifies those parse actions that

-  use the list of tokens to update a counter or record or display some of the

-  token content; these parse actions can simply end without having to specify

-  'return toks'.

-

-- *** POSSIBLE API INCOMPATIBILITY *** - Fixed CaselessLiteral bug, where the

-  returned token text was not the original string (as stated in the docs),

-  but the original string converted to upper case.  (Thanks, Dang Griffith!)

-  **NOTE: this may break some code that relied on this erroneous behavior.

-  Users should scan their code for uses of CaselessLiteral.**

-

-- *** POSSIBLE CODE INCOMPATIBILITY *** - I have renamed the internal

-  attributes on ParseResults from 'dict' and 'list' to '__tokdict' and

-  '__toklist', to avoid collisions with user-defined data fields named 'dict'

-  and 'list'.  Any client code that accesses these attributes directly will

-  need to be modified.  Hopefully the implementation of methods such as keys(),

-  items(), len(), etc. on ParseResults will make such direct attribute

-  accessess unnecessary.

-

-- Added asXML() method to ParseResults.  This greatly simplifies the process

-  of parsing an input data file and generating XML-structured data.

-

-- Added getName() method to ParseResults.  This method is helpful when

-  a grammar specifies ZeroOrMore or OneOrMore of a MatchFirst or Or

-  expression, and the parsing code needs to know which expression matched.

-  (Thanks, Eric van der Vlist, for this idea!)

-

-- Added items() and values() methods to ParseResults, to better support using

-  ParseResults as a Dictionary.

-

-- Added parseFile() as a convenience function to parse the contents of an

-  entire text file.  Accepts either a file name or a file object.  (Thanks

-  again, Dang!)

-

-- Added group() method to And, Or, and MatchFirst, as a short-cut alternative

-  to enclosing a construct inside a Group object.

-

-- Extended fourFn.py to support exponentiation, and simple built-in functions.

-

-- Added EBNF parser to examples, including a demo where it parses its own

-  EBNF!  (Thanks to Seo Sanghyeon!)

-

-- Added Delphi Form parser to examples, dfmparse.py, plus a couple of

-  sample Delphi forms as tests.  (Well done, Dang!)

-

-- Another performance speedup, 5-10%, inspired by Dang!  Plus about a 20%

-  speedup, by pre-constructing and cacheing exception objects instead of

-  constructing them on the fly.

-

-- Fixed minor bug when specifying oneOf() with 'caseless=True'.

-

-- Cleaned up and added a few more docstrings, to improve the generated docs.

-

-

-Version 1.1.2 - 21 Mar 2004

----------------------------

-- Fixed minor bug in scanString(), so that start location is at the start of

-  the matched tokens, not at the start of the whitespace before the matched

-  tokens.

-

-- Inclusion of HTML documentation, generated using Epydoc.  Reformatted some

-  doc strings to better generate readable docs. (Beautiful work, Ed Loper,

-  thanks for Epydoc!)

-

-- Minor performance speedup, 5-15%

-

-- And on a process note, I've used the unittest module to define a series of

-  unit tests, to help avoid the embarrassment of the version 1.1 snafu.

-

-

-Version 1.1.1 - 6 Mar 2004

---------------------------

-- Fixed critical bug introduced in 1.1, which broke MatchFirst(!) token

-  matching.

-  **THANK YOU, SEO SANGHYEON!!!**

-

-- Added "from future import __generators__" to permit running under

-  pre-Python 2.3.

-

-- Added example getNTPservers.py, showing how to use pyparsing to extract

-  a text pattern from the HTML of a web page.

-

-

-Version 1.1 - 3 Mar 2004

--------------------------

-- ***Changed API*** - While testing out parse actions, I found that the value

-  of loc passed in was not the starting location of the matched tokens, but

-  the location of the next token in the list.  With this version, the location

-  passed to the parse action is now the starting location of the tokens that

-  matched.

-

-  A second part of this change is that the return value of parse actions no

-  longer needs to return a tuple containing both the location and the parsed

-  tokens (which may optionally be modified); parse actions only need to return

-  the list of tokens.  Parse actions that return a tuple are deprecated; they

-  will still work properly for conversion/compatibility, but this behavior will

-  be removed in a future version.

-

-- Added validate() method, to help diagnose infinite recursion in a grammar tree.

-  validate() is not 100% fool-proof, but it can help track down nasty infinite

-  looping due to recursively referencing the same grammar construct without some

-  intervening characters.

-

-- Cleaned up default listing of some parse element types, to more closely match

-  ordinary BNF.  Instead of the form <classname>:[contents-list], some changes

-  are:

-  . And(token1,token2,token3) is "{ token1 token2 token3 }"

-  . Or(token1,token2,token3) is "{ token1 ^ token2 ^ token3 }"

-  . MatchFirst(token1,token2,token3) is "{ token1 | token2 | token3 }"

-  . Optional(token) is "[ token ]"

-  . OneOrMore(token) is "{ token }..."

-  . ZeroOrMore(token) is "[ token ]..."

-

-- Fixed an infinite loop in oneOf if the input string contains a duplicated

-  option. (Thanks Brad Clements)

-

-- Fixed a bug when specifying a results name on an Optional token. (Thanks

-  again, Brad Clements)

-

-- Fixed a bug introduced in 1.0.6 when I converted quotedString to use

-  CharsNotIn; I accidentally permitted quoted strings to span newlines.  I have

-  fixed this in this version to go back to the original behavior, in which

-  quoted strings do *not* span newlines.

-

-- Fixed minor bug in HTTP server log parser. (Thanks Jim Richardson)

-

-

-Version 1.0.6 -  13 Feb 2004

-----------------------------

-- Added CharsNotIn class (Thanks, Lee SangYeong).  This is the opposite of

-  Word, in that it is constructed with a set of characters *not* to be matched.

-  (This enhancement also allowed me to clean up and simplify some of the

-  definitions for quoted strings, cStyleComment, and restOfLine.)

-

-- **MINOR API CHANGE** - Added joinString argument to the __init__ method of

-  Combine (Thanks, Thomas Kalka).  joinString defaults to "", but some

-  applications might choose some other string to use instead, such as a blank

-  or newline.  joinString was inserted as the second argument to __init__,

-  so if you have code that specifies an adjacent value, without using

-  'adjacent=', this code will break.

-

-- Modified LineStart to recognize the start of an empty line.

-

-- Added optional caseless flag to oneOf(), to create a list of CaselessLiteral

-  tokens instead of Literal tokens.

-

-- Added some enhancements to the SQL example:

-  . Oracle-style comments (Thanks to Harald Armin Massa)

-  . simple WHERE clause

-

-- Minor performance speedup - 5-15%

-

-

-Version 1.0.5 -  19 Jan 2004

-----------------------------

-- Added scanString() generator method to ParseElement, to support regex-like

-  pattern-searching

-

-- Added items() list to ParseResults, to return named results as a

-  list of (key,value) pairs

-

-- Fixed memory overflow in asList() for deeply nested ParseResults (Thanks,

-  Sverrir Valgeirsson)

-

-- Minor performance speedup - 10-15%

-

-

-Version 1.0.4 -  8 Jan 2004

----------------------------

-- Added positional tokens StringStart, StringEnd, LineStart, and LineEnd

-

-- Added commaSeparatedList to pre-defined global token definitions; also added

-  commasep.py to the examples directory, to demonstrate the differences between

-  parsing comma-separated data and simple line-splitting at commas

-

-- Minor API change: delimitedList does not automatically enclose the

-  list elements in a Group, but makes this the responsibility of the caller;

-  also, if invoked using 'combine=True', the list delimiters are also included

-  in the returned text (good for scoped variables, such as a.b.c or a::b::c, or

-  for directory paths such as a/b/c)

-

-- Performance speed-up again, 30-40%

-

-- Added httpServerLogParser.py to examples directory, as this is

-  a common parsing task

-

-

-Version 1.0.3 - 23 Dec 2003

----------------------------

-- Performance speed-up again, 20-40%

-

-- Added Python distutils installation setup.py, etc. (thanks, Dave Kuhlman)

-

-

-Version 1.0.2 - 18 Dec 2003

----------------------------

-- **NOTE: Changed API again!!!** (for the last time, I hope)

-

-  + Renamed module from parsing to pyparsing, to better reflect Python

-    linkage.

-

-- Also added dictExample.py to examples directory, to illustrate

-  usage of the Dict class.

-

-

-Version 1.0.1 - 17 Dec 2003

----------------------------

-- **NOTE:  Changed API!**

-

-  + Renamed 'len' argument on Word.__init__() to 'exact'

-

-- Performance speed-up, 10-30%

-

-

-Version 1.0.0 - 15 Dec 2003

----------------------------

-- Initial public release

-

-Version 0.1.1 thru 0.1.17 - October-November, 2003

---------------------------------------------------

-- initial development iterations:

-    - added Dict, Group

-    - added helper methods oneOf, delimitedList

-    - added helpers quotedString (and double and single), restOfLine, cStyleComment

-    - added MatchFirst as an alternative to the slower Or

-    - added UML class diagram

-    - fixed various logic bugs