2a3f31e387e7b41c1856ff79a47ad5bfebdea5cc Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/37739ef6e867fa53cb039c707bf15d4e1affd1ba 37739ef6e867fa53cb039c707bf15d4e1affd1ba 2008-08-30T13:50:01-07:00 2008-08-30T13:47:18-07:00 Flattening the Expression type Before, we had separate datatypes for each “class” of expression; for instance, a Number type for any expression that always evaluates to a number. The Expression type was then defined as a sum type across all of these subtypes. This patch flattens things so that there's only a single Expression type. This simplifies things by removing a level of indirection in the type definitions, and also will make it easier to define “bound expressions” as we implement static-scoped environments. Lighthouse: [#11] bd66e4392f5dfff3c5111189e23ac2cde766155b Douglas Creager dcreager@alum.mit.edu eefa050ea24b224a956ca442752678d9a23c441c Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/2a3f31e387e7b41c1856ff79a47ad5bfebdea5cc 2a3f31e387e7b41c1856ff79a47ad5bfebdea5cc 2008-08-30T13:42:50-07:00 2008-08-30T13:04:21-07:00 CSPM environments An environment is the symbol table that hold CSPM definitions. They provide a standard mapping between identifiers and the expressions that define them. Environments can also have an optional parent, which allows nested scoping; if an identifier is not found in the current environment, we then proceed to look for it in the containing environment. This patch introduces the basic API for creating and using environments, but does not extend the evaluation rules to use them. Lighthouse: [#11] d8fb5b18d814a7e331d40eae76b846b903ee0479 Douglas Creager dcreager@alum.mit.edu 6c92ff8cd645665253dc5604ed9aa4cd1ba43967 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/eefa050ea24b224a956ca442752678d9a23c441c eefa050ea24b224a956ca442752678d9a23c441c 2008-08-26T20:41:14-07:00 2008-08-26T20:41:14-07:00 Adding more test cases for booleans This patch expands the test suite with some tests for basic boolean expressions. Not all of them are covered yet, though. 71b0c87e94b05ff9ffe1fed229909fe474abd5fa Douglas Creager dcreager@alum.mit.edu 015d87c470e1e67cba3de830767d2413aa3f78a7 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/6c92ff8cd645665253dc5604ed9aa4cd1ba43967 6c92ff8cd645665253dc5604ed9aa4cd1ba43967 2008-08-26T20:24:12-07:00 2008-08-26T20:04:51-07:00 Adding more test cases for sets This patch expands the test suite with some tests for basic set expressions. Not all of them are covered yet, though. 7cfedc3b67174f303a22252bd241fe9476f0e0f9 Douglas Creager dcreager@alum.mit.edu 2b108c39f9179982b3d2447a980928aeb81e99d5 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/015d87c470e1e67cba3de830767d2413aa3f78a7 015d87c470e1e67cba3de830767d2413aa3f78a7 2008-08-25T20:55:55-07:00 2008-08-25T20:54:53-07:00 Cabal build infrastructure This patch introduces a Cabal package description for the current HST library. This includes a hook to call the QuickCheck test suite. To build and test the Haskell code, simply run the following from the cspm directory: ./Setup.lhs configure ./Setup.lhs build ./Setup.lhs test Lighthouse: [#10 state:resolved] 3b3ba82703670aab583ea8972fa7b794efd49f85 Douglas Creager dcreager@alum.mit.edu 8317134761619c5c0b768c2c2d0493936913e5db Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/2b108c39f9179982b3d2447a980928aeb81e99d5 2b108c39f9179982b3d2447a980928aeb81e99d5 2008-08-25T16:09:38-07:00 2008-08-25T16:06:46-07:00 Initial Haskell CSPM implementation This is an initial patch implementing the CSPM language in Haskell. I've chosen Haskell since, like CSPM, it's a lazy functional language. This means we don't have to “implement” any of the functional features of CSPM; rather, we can just call the appropriate Haskell functions. This patch includes a basic implementation of the simple non-process expressions in CSPM. It does not yet include variable references, ‘let’ bindings, or functions, since they'll all require static-scoped environments. There is a basic test suite, based on QuickCheck. I also still need to wrap everything up in a Cabal package. Lighthouse: [#2] 6885da7d3739eba5f1778947b5db1fc5f4bda2b5 Douglas Creager dcreager@alum.mit.edu d9c7dc294b48e2f3a5009e26a27a96b33f562db8 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/8317134761619c5c0b768c2c2d0493936913e5db 8317134761619c5c0b768c2c2d0493936913e5db 2008-07-06T10:30:56-07:00 2008-07-06T10:30:56-07:00 Adding failures refinement option to csp0 script A previous patch added support for failures refinement, but I hadn't yet made this functionality available in the csp0 command-line script. This patch does so. Lighthouse: [#3 state:resolved] 9614134343319783de0fe4c885a0c7451cf291ea Douglas Creager dcreager@alum.mit.edu 4754d168e43124cb467c6c82b6333905bd208a7c Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/d9c7dc294b48e2f3a5009e26a27a96b33f562db8 d9c7dc294b48e2f3a5009e26a27a96b33f562db8 2008-06-23T18:02:23-07:00 2008-06-23T15:25:32-07:00 Fixed superset proof for integer sets The is_superset_with_proof method would return incorrect proof in certain situations. When testing A >= B, it's supposed to return an element of B that's not in A. Since our method works on sorted sets, it will return the least such element, though this is not a required part of the method's contract. When A contained an element that was greater than the least element of B not in A, our method would return the A element, not the B element. This would cause downstream errors in the refinement code, in that the wrong counterexample could be returned in certain situations. Lighthouse: [#9 state:resolved] 1c2a527ad4b2f4f8c77bfa91ede011f33878f853 Douglas Creager dcreager@alum.mit.edu fb172a05812c6f2ed5ffa44f088c5ab0f822a41a Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/4754d168e43124cb467c6c82b6333905bd208a7c 4754d168e43124cb467c6c82b6333905bd208a7c 2008-05-31T15:47:26-07:00 2008-05-31T15:47:26-07:00 Failures refinement This patch adds support for checking failures refinement. The Refiner class checks that each (SPEC, IMPL) pair satisfies the following condition: ∀ α: accs(IMPL) • ∃ β: accs(SPEC) • α ⊇ β An acceptance is the complement of a refusal, so this is equivalent to: ∀ α: refs(IMPL) • ∃ β: refs(SPEC) • α ⊆ β The refs() function only represents the maximal refusals that are actually stored in the LTS. This corresponds to an allrefs() function that contains all of refusals, which are subset closed. Thus, the condition also ensures that ∀ α: allrefs(IMPL) • ∃ β: allrefs(SPEC) • α = β or, in other words, that allrefs(IMPL) ⊆ allrefs(SPEC) Lighthouse: [#3 state:resolved] 59642ade03c96d586c6587f019e57d5df4e671cd Douglas Creager dcreager@alum.mit.edu de0feac4e64d84398444568d99918fa8d9f6cdde Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/fb172a05812c6f2ed5ffa44f088c5ab0f822a41a fb172a05812c6f2ed5ffa44f088c5ab0f822a41a 2008-05-31T10:28:51-07:00 2008-05-31T10:23:54-07:00 Refactoring refinement code to support multiple semantic models As another step towards implementing failures refinement, this patch refactors the refinement code to have better support for different semantic models. Part of the refinement code is identical regardless of semantic model. Mostly, this is the scaffolding of the breadth-first search, where we examine each pair of (SPEC, IMPL) states from the original processes. The only model-specific code is the part that checks whether a particular (SPEC, IMPL) pair is part of a valid refinement, and that constructs a counterexample object if it's not. This new design has the model-independent code as a templated function. There are two template parameters: Refiner and Counterexample. Counterexample is the type of the counterexample object that's created if the refinement fails. The refine function does not need to know any details of this type. The Refiner type contains the model-specific code for checking a pair of states and constructing a Counterexample object if needed. The API of the Refiner object is described in the refine.cc file. With this modification, we should be able to implement failures refinement simply by defining a new Refiner class. Lighthouse: [#3] 6d369d6072145d41e2a9abb3f6b9826e2e87d83a Douglas Creager dcreager@alum.mit.edu 0c111239b97698f412c09a3cbbd78ffcbba43257 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/de0feac4e64d84398444568d99918fa8d9f6cdde de0feac4e64d84398444568d99918fa8d9f6cdde 2008-05-31T10:28:51-07:00 2008-05-30T21:10:07-07:00 Using new superset algorithm in traces refinement This patch rewrites the traces refinement code to use the new superset algorithm. We'll also use this superset algorithm to check the acceptances during a failures refinement. eccaf64ef0e6f6014114f3cf298c01b654ed2878 Douglas Creager dcreager@alum.mit.edu aa82cf80491c76c99e24d03d775f73340f3f07d8 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/0c111239b97698f412c09a3cbbd78ffcbba43257 0c111239b97698f412c09a3cbbd78ffcbba43257 2008-05-31T10:25:02-07:00 2008-05-30T19:42:55-07:00 Replacing custom proxy_iterator with Boost's transform_iterator The Boost library already has a more robust implementation of our “proxy iterator”, so this patch changes our code to use Boost's. 7d649a05ba665473a82f86a44a45a383b8a7f763 Douglas Creager dcreager@alum.mit.edu 272fa182e899bc777bf57e13e9c53257c549f608 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/aa82cf80491c76c99e24d03d775f73340f3f07d8 aa82cf80491c76c99e24d03d775f73340f3f07d8 2008-05-30T20:43:36-07:00 2008-05-29T19:18:47-07:00 Better equality and superset comparisons for intsets This patch introduces a better algorithm for comparing two sets for equality or containment. Before, we would check S1 ⊇ S2 by looping through all of the elements of S2, ensuring that each was in S1. Since intset::contains isn't constant-time, this superset algorithm isn't linear. Now, we exploit the fact that intset's iterators return their elements in sorted order. We loop through the elements of S1 and S2 at the same time. If S1's iterator ever “passes” S2's, then we've found an element of S2 that's not in S1, meaning that S1 ⊉ S2. This algorithm is linear in the maximum of #S1 and #S2. We can use a similar algorithm for equality. Before, we checked S1 == S2 by checking S1 ⊇ S2 and S2 ⊇ S1. Now, we have a similar loop as with the superset test, but we abort the loop if either iterator passes the other. Finally, the new algorithms are implemented as standalone functions that take iterators as parameters, rather than directly taking intsets. This makes them more flexible. The >= and == operators in intset have been redefined to use the new functions. 47d399b82a45c8642bd74207206b65d993ca0d18 Douglas Creager dcreager@alum.mit.edu 61b37e197ef47a91949befb3fc773ee79ce9a31d Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/272fa182e899bc777bf57e13e9c53257c549f608 272fa182e899bc777bf57e13e9c53257c549f608 2008-05-24T15:05:39-07:00 2008-05-24T15:05:39-07:00 Replicated external choice This patch introduces the “replicated external choice” operator. This has the same semantics as the standard external choice, but it works on a set containing any number of processes. (The standard external choice operator takes exactly two operands.) The replicated version is well-defined since the binary version is associative; this means that it doesn't matter which order we apply the binary version to the elements of the set. Since the unit of binary external choice is STOP, we also get STOP if we apply the replicated version to the empty set. Lighthouse: [#8] fce357544b830f8a7ce8301acf5899daa0b21686 Douglas Creager dcreager@alum.mit.edu 35472266389a85d5aef424ec8e4b804d7dce659f Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/61b37e197ef47a91949befb3fc773ee79ce9a31d 61b37e197ef47a91949befb3fc773ee79ce9a31d 2008-04-28T15:10:44-07:00 2008-04-28T15:10:44-07:00 CSP₀ can now contain internal underscores The CSP₀ parser was only accepting underscores in an identifier name if they were the first character in the identifier. This patch corrects the parser so that underscores can occur anywhere in an identifier. Lighthouse: [#7 state:resolved] e1c91f85c82441b07037cdeec8b4c83a1fdc7b55 Douglas Creager dcreager@alum.mit.edu c07efc77da81821cbca65c1df3aba7959bba2e1e Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/35472266389a85d5aef424ec8e4b804d7dce659f 35472266389a85d5aef424ec8e4b804d7dce659f 2008-04-28T13:02:08-07:00 2008-04-28T13:02:08-07:00 Failures normalization With this patch, the normalization code now works in the failures model as well as the traces model. The normalization code now takes as a parameter which semantic model to use. Currently, failures and failures-divergences are treated the same, and do not consider divergence information. The tests/csp/80-roscoe-02 test case is one example where the normalization is different in the two models. The interface to this code could probably use some cleaning up, but it's also probably not worth doing this until the failures-divergences code is added. Lighthouse: [#3] b2c18508da31b55b9375dcedf0d0b920f9cf3543 Douglas Creager dcreager@alum.mit.edu b692420844370837a19641f3b29f71bad483b21a Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/c07efc77da81821cbca65c1df3aba7959bba2e1e c07efc77da81821cbca65c1df3aba7959bba2e1e 2008-04-28T10:46:02-07:00 2008-04-28T10:46:02-07:00 Interleave now synchronizes on ✓ The ✓ event must always be part of the synchronization alphabet for any parallel composition, including interleaving. The interface parallel operator was already correctly synchronizing on ✓, so I've refactored the interleaving code to simply call the interface parallel code with an empty synchronization alphabet. (This is similar to alphabetized parallel, which is also implemented as a call to interface parallel.) This eliminates some redundant code, and ensures that all of the parallel composition operators will now have the same behavior. Lighthouse: [#6 state:resolved] d1e708f405afd0771c8be0aa2c146e469c31492e Douglas Creager dcreager@alum.mit.edu 58e5a3a4444fde5983b86b446359223f2ca9d598 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/b692420844370837a19641f3b29f71bad483b21a b692420844370837a19641f3b29f71bad483b21a 2008-04-28T09:32:45-07:00 2008-04-28T09:32:45-07:00 Adding acceptance sets for LTSs This patch adds support for acceptance sets in an LTS. Each stable node in an LTS (i.e., those with no outgoing τ edges) now has an acceptance set, which is the complement of the refusal set more often seen in the literature. If a state has some acceptance set that does not contain event ‘a’, then there is some situation in which the state can refuse to perform ‘a’. These acceptance sets are needed to implement the failures and failures-divergences semantic models in CSP. In this patch, LTSs can now store acceptance information. As with LTS edges, acceptances can only be added to a state that has not yet been finalized. The CSP operators add acceptances to the underlying LTS. However, the normalization and refinement checking code does not yet do anything with this information. Lighthouse: [#3] 9ded79da914a93a128a75c999efb49a4b9ebe699 Douglas Creager dcreager@alum.mit.edu 7c29484dc2c66b9afc90f23782049eacf5e1c6ec Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/58e5a3a4444fde5983b86b446359223f2ca9d598 58e5a3a4444fde5983b86b446359223f2ca9d598 2008-04-27T16:38:47-07:00 2008-04-27T16:38:07-07:00 Current “interrupt” operator is actually “timeout” The operator that's currently called “interrupt” is actually the CSP “timeout” operator. All of the semantics are correct; it's just the name of the operator that's wrong. This patch corrects this, in the code, test cases, and all documentation. Lighthouse: [#4 state:resolved] 5c64cd421558b3845d96756588b1ddcdb67673fe Douglas Creager dcreager@alum.mit.edu 04ffccc1b5572d80415bac200d0544576e8078b9 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/7c29484dc2c66b9afc90f23782049eacf5e1c6ec 7c29484dc2c66b9afc90f23782049eacf5e1c6ec 2008-04-25T21:00:53-07:00 2008-04-25T20:20:39-07:00 Adding comments to CSP₀ scripts This patch adds support for comments in CSP₀ scripts. They use the same syntax as in Perl or Python; they start with a “#” and continue to the end of the line. I've also added comments to many of the existing test cases. Lighthouse: [#1 state:resolved] 052e5bdf9ee03992760422ee1f845d4a6dedc6a9 Douglas Creager dcreager@alum.mit.edu a76db666456ad02eca2c961df5bf914c78aed135 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/04ffccc1b5572d80415bac200d0544576e8078b9 04ffccc1b5572d80415bac200d0544576e8078b9 2008-04-15T19:09:33-07:00 2008-03-21T13:10:38-07:00 Adding counterexamples to the traces refinement check Instead of just giving a yes/no answer for a traces refinement, we now provide a counterexample when the refinement fails. The counterexample consists of a trace of visible events, after which the IMPL process can perform some event that SPEC cannot perform. (This event is provided in the counterexample, as well.) There will often me many possible counterexamples for a particular failed refinement; the current implementation uses a breadth-first search, so we know that the returned counterexample will be one with the smallest trace. If there are many counterexamples of this length, an arbitrary one will be returned. The csp0 utility has also been modified to display this counterexample, as have the traces refinement test cases. As currently defined, the counterexample might not be especially useful, since it only includes visible events. If the high-level SPEC and IMPL processes involve a lot of hiding, then you won't actually be able to see any useful detail in the counterexample trace. We'll need to add some logic for drilling down into the syntax tree of a CSP process to fix this. afb449e6ba061168c494d9f53366dd62a9ccfead Douglas Creager dcreager@alum.mit.edu dfb1e4759e2f4a652a78c8cec1d0879cfe3a8b4c Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/a76db666456ad02eca2c961df5bf914c78aed135 a76db666456ad02eca2c961df5bf914c78aed135 2008-02-23T14:11:52-08:00 2008-02-23T13:47:46-08:00 Updated copyright notices I've updated all of the copyright notices to contain 2008 as an additional copyright year. f0dd640464d258608a1b9c1ada691300103fba58 Douglas Creager dcreager@alum.mit.edu 4107273a02d97eae36825e9b5674454f1d1c8a22 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/dfb1e4759e2f4a652a78c8cec1d0879cfe3a8b4c dfb1e4759e2f4a652a78c8cec1d0879cfe3a8b4c 2008-02-23T14:11:47-08:00 2008-02-23T13:44:35-08:00 Fixes to basic documentation set I've made some final changes to the README, INSTALL, and TODO files in preparation for the 1.0-α1 release. I've also fixed the COPYING file so it contains the correct license (LGPL 2.1). Finally, I've removed the empty ChangeLog file, since instead I will be placing git shortlogs into the doc/changelog directory for each release. fa7cde5a7b9d3aa47f14a0059558c89965f16ccb Douglas Creager dcreager@alum.mit.edu 7d2338e7489d617f5c14dd196d63f6fc236c64b2 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/4107273a02d97eae36825e9b5674454f1d1c8a22 4107273a02d97eae36825e9b5674454f1d1c8a22 2008-02-23T13:11:54-08:00 2008-02-23T13:11:54-08:00 Adding description of $ identifiers to CSP₀ reference This patch describes the intention of $ identifiers as temporary processes needed while compiling high-level languages into CSP₀. f9a757a5fa4b2b476ed552ca9212b07716ceba98 Douglas Creager dcreager@alum.mit.edu f98fba8374d44174f5a03cb851b63bf95dcd16c2 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/7d2338e7489d617f5c14dd196d63f6fc236c64b2 7d2338e7489d617f5c14dd196d63f6fc236c64b2 2008-02-23T13:10:38-08:00 2008-02-23T12:34:17-08:00 Adding technical overview article This patch adds an article giving an overview of the design and implementation of the library. 0100b5f82e32c987570f769665c0e56e9dbf4d95 Douglas Creager dcreager@alum.mit.edu a8391d97b67980a173eaab4c6ef6b3bdb081f726 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/f98fba8374d44174f5a03cb851b63bf95dcd16c2 f98fba8374d44174f5a03cb851b63bf95dcd16c2 2008-02-23T09:25:37-08:00 2008-02-23T09:24:41-08:00 Renaming TAU and TICK so that they are hidden Previously, the τ and ✓ methods were given the names “TAU” and “TICK” when created during the initialization of a csp_t object. However, these names mean that the events were unintentionally visible to a CSP₀ script. This made it possible to, for instance, use a prefix statement to explicitly add a τ or ✓ to a CSP LTS, instead of only being able to introduce them using the CSP operators. I've renamed them to “%TAU” and “%TICK”; since the percent character isn't a valid identifier character in CSP₀, they are now correctly hidden in the script. It's now possible to define your own events called “TAU” and “TICK”; however, these user-defined events won't actually have the semantics of τ and ✓, so you shouldn't do that. 7d36479da8d3eb758c89913239d51e68e682cf25 Douglas Creager dcreager@alum.mit.edu 47bd1e6212e510df940dc701455a60e9e000ee7f Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/a8391d97b67980a173eaab4c6ef6b3bdb081f726 a8391d97b67980a173eaab4c6ef6b3bdb081f726 2008-02-20T16:50:29-08:00 2008-02-20T16:43:21-08:00 Initial documentation This patch adds a simple manpage for the csp0 utility that simply redirects the user to “csp0 help”, and an article describing the CSP₀ file format. We use asciidoc for all of the documentation (both articles and manpages), and the documentation targets are installed during “make install”. 346dd001fd9a3b786d2fe3e6919cd2036683cd3f Douglas Creager dcreager@alum.mit.edu 66280415c9dfea5e2c32bc817fdafd7ee0be92fe Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/47bd1e6212e510df940dc701455a60e9e000ee7f 47bd1e6212e510df940dc701455a60e9e000ee7f 2008-02-20T16:41:13-08:00 2008-02-18T20:38:59-08:00 Improvements to build infrastructure The build infrastructure now adds a version tag to the libhst library (currently 0.0.0), and I've added a script that creates a source tarball using git-archive. 340266dc551cdbe3a4c616f6e739bdd2e78fd9dd Douglas Creager dcreager@alum.mit.edu 513004b8f7ea870d8932d46cf7f5123b26ff220b Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/66280415c9dfea5e2c32bc817fdafd7ee0be92fe 66280415c9dfea5e2c32bc817fdafd7ee0be92fe 2008-02-18T21:03:20-08:00 2008-02-18T19:15:00-08:00 CSP₀ command-line utility Added an installed command-line utility for processing CSP₀ scripts. Initially it has “help”, “lts”, and “assert” commands. If many more commands are added it might be worth refactoring it a bit, but for now it's fine as it is. dd3f26569342c94db326516a46a1554051e1989e Douglas Creager dcreager@alum.mit.edu f91b2f590b4a6445b4e04bae5e36a075aab2cc27 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/513004b8f7ea870d8932d46cf7f5123b26ff220b 513004b8f7ea870d8932d46cf7f5123b26ff220b 2008-02-17T11:59:41-08:00 2008-02-17T11:59:41-08:00 Fixed strict-aliasing warning in release builds The release builds, which turn on compiler optimatizations, generate a strict aliasing warning when compiling the parser files. This is because the scanner is written in terms of a “least common denominator” Bison semantic type. We are careful to define all of the Bison semantic types so that they begin with the same elements as the one used by the scanner. However, the typecase that we use when calling the lexer violates the strict aliasing constraints, which don't allow you to perform type punning using pointer casts. To get around this, I've turned off the strict aliasing optimizations for these compilation units. 4572ff737d44b72ef6fab5823e42820906bdd739 Douglas Creager dcreager@alum.mit.edu