coala-1.0.1_src/COPYING 000644 001750 001750 00000104374 11477164507 015243 0 ustar 00tovok7 tovok7 000000 000000
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
coala-1.0.1_src/bin/coala 000755 001750 001750 00000032153 11477164507 015760 0 ustar 00tovok7 tovok7 000000 000000 #!/usr/bin/python
#########################################################################
# Copyright 2010 Torsten Grote
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
##########################################################################
from __future__ import with_statement
import sys
import os
import re
import subprocess
import tempfile
from optparse import OptionParser, OptionGroup
if sys.version.rsplit()[0] < '2.5':
print 'You need at least python 2.5 to run coala'
sys.exit(1)
# defined that early to extract coala version from binary
def checkProgram(prog):
try:
(result, error) = subprocess.Popen([prog, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
except OSError, err:
print err
return False
if result != '':
return result.splitlines()[0]
else:
return False
version = checkProgram("coala.bin")
if not version:
print "There is a problem with the coala binary file. Is it in your $PATH, is it executable, is it compiled for your architecture?"
sys.exit(1)
# Parse Command Line Options
description = version+" Copyright (C) 2007-2010 Torsten Grote This program comes with ABSOLUTELY NO WARRANTY. It is free software, and you are welcome to redistribute it under certain conditions."
usage = "%prog [options] file [number]"
parser = OptionParser(usage=usage, description=description, add_help_option=False, version="%prog " + version, conflict_handler="resolve")
parser.add_option("-l", "--language", dest="language", choices=["c","b","al","m","c_taid"], help="the action language (c, c_taid, b, al or m) to be used as input (default: %default)",
action="store", metavar="LANG")
parser.add_option("-s", "--static-file", dest="static_files", help="file containing static information such as variable types.", action="append", metavar="FILE")
parser.add_option("-c", "--const", dest="const", help="replaces constant t with value v", metavar="t=v")
parser.add_option("-d", "--debug", dest="debug", help="show debugging output", action="store_true")
parser.add_option("", "--version", help="show program's version number and exit", action="version")
parser.add_option("-h", "--help", help="show this help message and exit", action="help")
encoding_group = OptionGroup(parser, "Encoding Options")
encoding_group.add_option("-i", "--incremental", dest="incremental", choices=["yes","no","backwards"], help="use incremental encoding. INC can be yes, no or backwards. Default: %default",
action="store", metavar="INC")
encoding_group.add_option("-e", "--meta-encoding", dest="meta_encoding", help="use meta-encoding", action="store_true")
encoding_group.add_option("-n", "--negation", dest="negation", help="simulate classical negation instead of using the built-in one", action="store_true")
parser.add_option_group(encoding_group)
solver_group = OptionGroup(parser, "Solver Options")
solver_group.add_option("", "--max-sol", dest="max_sol", help="Compute [number] solutions. Default: %default", type="int", action="store", metavar="NUM")
solver_group.add_option("", "--imax", dest="imax", help="Perform at most NUM incremental steps. Default: %default", type="int", action="store", metavar="NUM")
solver_group.add_option("-t", "--text", dest="text", help="show only coala output and don't look for solutions", action="store_true")
solver_group.add_option("-g", "--ground", dest="ground", help="show only grounded coala output and don't look for solutions", action="store_true")
parser.add_option_group(solver_group)
output_group = OptionGroup(parser, "Output Options")
output_group.add_option("-o", "--output", dest="output", help="change the way the solutions are presented, long, compact or raw. Default: %default",
action="store", choices=['long','compact', 'raw'], metavar="OUTPUT")
output_group.add_option("-f", "--show-fluents", dest="show_fluents", help="show not only actions, but also fluents in solution", action="store_true")
#output_group.add_option("", "--hide", dest="hide", help="Hide this action or fluent name from output", action="append", metavar="NAME")
parser.add_option_group(output_group)
parser.set_defaults(
language = "c",
incremental = "yes",
meta_encoding = False,
show_fluents = False,
negation = False,
output = "compact",
text = False,
ground = False,
max_sol = 1,
imax = 99,
debug = False
)
(opt, args) = parser.parse_args()
if opt.meta_encoding:
ACTION = re.compile("^occ\((.*?),?(\d+)\)$")
FLUENT = re.compile("^hol\((.*?),?(\d+)\)$")
elif opt.language == 'b':
ACTION = re.compile("^occ\((.*?),?(\d+)\)$")
FLUENT = re.compile("^holds\((.*?),?(\d+)\)$")
else:
ACTION = re.compile("^-?action_([a-zA-Z0-9_]*\(.*?),? *(\d+) *\)\.?$")
FLUENT = re.compile("^-?fluent_([a-zA-Z0-9_]*\(.*?),? *(\d+) *\)\.?$")
PARSER = [
re.compile("^Answer:\ (\d+)$"),
re.compile("^(-?[a-z_][a-zA-Z0-9_]*(\(.+\))?\ *)+$"),
re.compile("^SATISFIABLE$"),
re.compile("^UNSATISFIABLE$"),
re.compile("^Error: (?P.+)$"),
]
def main():
checkOptions()
lp = callCoala("coala.bin")
if opt.text:
print lp
else:
output = callClingo(lp)
if opt.ground or opt.output == 'raw':
print output
else:
answer_sets = getAnswerSets(output)
printAnswerSets(answer_sets)
return 0
def checkOptions():
# get last positional argument and check if its a number
try:
int(args[len(args)-1])
opt.max_sol = args.pop(len(args)-1)
except IndexError:
print "coala needs at least one file as argument. Run `coala --help` for more information."
print
parser.print_usage()
sys.exit(0)
except ValueError:
opt.max_sol = '1'
if(opt.language == "c_taid" and (opt.incremental == "yes" or opt.incremental == "backwards" or opt.meta_encoding)):
raise RuntimeError("Action Language c_taid does not support these options.")
if((opt.language == "b" or opt.language == "al") and opt.meta_encoding):
raise RuntimeWarning("Action Language "+opt.language+" does only support one encoding.")
if(opt.text and opt.ground):
raise RuntimeError("The options -g and -t can not be used together.")
def callCoala(coala_binary):
coala_options = getCoalaOptions()
if(opt.debug):
print "Calling Coala with:"
print " " + subprocess.list2cmdline([coala_binary] + coala_options)
(result, error) = subprocess.Popen([coala_binary] + coala_options, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
if error != "":
print error
return result
def getCoalaOptions():
result = ['-l']
result.append(opt.language)
if(opt.meta_encoding):
result.append('-e')
elif(opt.incremental == "yes" or opt.incremental == "backward"):
result.append('-n')
if(opt.incremental == "yes"):
result.append('-i')
elif(opt.incremental == "backward"):
result.append('-ir')
elif(opt.negation):
result.append('-n')
opt.negation = True
if(opt.debug):
result.extend(['-d','99'])
elif(opt.show_fluents):
result.extend(['-d','1'])
for file in args:
if os.path.exists(file):
result.append(file)
else:
raise RuntimeError("Input file %s does not exist." % file)
return result
def callClingo(lp):
iclingo_options = ['--imax='+str(opt.imax), opt.max_sol]
iclingo = checkProgram("iclingo")
if(not iclingo and opt.incremental != "no"):
raise RuntimeError("Could not find iclingo binary which is needed to process the incremental encoding.")
elif(not iclingo):
iclingo = checkProgram("clingo")
if(not clingo):
raise RuntimeError("Could not find an iclingo or clingo binary. At least one of them is needed to compute solutions.")
else:
iclingo = "clingo"
else:
iclingo = "iclingo"
if(opt.incremental == "no"):
iclingo_options.append('--clingo')
if(opt.const):
iclingo_options.extend(['-c', opt.const])
if(opt.ground):
iclingo_options.append('-t')
if(opt.const):
iclingo_options.append('--ifixed=' + opt.const.rsplit('=',1)[1])
# create tmp file for input
tmp = tempfile.NamedTemporaryFile()
tmp.write(lp)
if opt.static_files:
for file in opt.static_files:
if(os.path.exists(file)):
if(opt.incremental != "no"):
tmp.write("#base.\n")
with open(file, 'r') as f:
for line in f:
tmp.write(line)
else:
raise RuntimeError("Static file '%s' could not be found." % file)
tmp.seek(0)
if opt.debug:
print "Calling iClingo with:"
print " " + subprocess.list2cmdline([iclingo] + iclingo_options)
iclingo_options.append('--istats')
(result, error) = subprocess.Popen([iclingo] + iclingo_options, stdin=tmp, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
if error != "":
print error
return result
def getAnswerSets(output):
answer_sets = []
for line in output.splitlines():
matched = False
for i in range(len(PARSER)):
match = PARSER[i].match(line)
if match != None:
matched = True
if i == 0 and opt.debug:
print "Found %s. Answer Set." % match.group(1)
elif i == 1:
answer_sets.append(line.split())
elif i == 2:
return answer_sets
elif i == 3:
raise RuntimeError("The problem doesn't have any solutions. Try to comment out some constraints or queries. " +
"In case of an LTL query, this message means that no counter examples have been found.")
elif i == 4:
raise RuntimeError(line)
if not matched:
if opt.debug:
print line
#raise SyntaxError("Unkown clasp output read: %s" % line)
return answer_sets
def printAnswerSets(answer_sets):
i = 1
for answer_set in answer_sets:
if opt.output == "long":
print "\nAnswer: %d" % i
print '-' * 78
else:
print "Answer: %d" % i
printAnswerSet(answer_set)
i += 1
if i-1 >= int(opt.max_sol) and opt.max_sol != '0':
print "There might be more solutions. Find out by adding the maximal [number] of"
print "solutions as a parameter. Use 0 for all."
def printAnswerSet(answer_set):
"""prints the answer set"""
times = []
actions = {}
fluents = {}
# stores all actions and fluents in two dictionaries
for predicate in answer_set:
for (parser, plan) in [(ACTION, actions), (FLUENT, fluents)]:
match = parser.match(predicate)
if match != None:
t = int(match.group(2))
if t in plan:
plan[t].append(predicate)
else:
plan[t] = [predicate]
if not t in times:
times.append(t)
times.sort()
if opt.output == "compact":
# append fluents to actions and sort both
for time in times:
if not time in actions:
actions[time] = []
else:
actions[time].sort()
if time in fluents:
fluents[time].sort()
actions[time].extend(fluents[time])
# prints predicates in rows
row_len = getPredicateLength(actions, fluents)
for time in actions:
printRow(actions, row_len, time)
else:
# append actions to fluents and sort both
for time in times:
if not time in fluents:
fluents[time] = []
else:
fluents[time].sort()
if time in actions:
actions[time].sort()
fluents[time].extend(actions[time])
# print one predicate per row
for predicate in fluents[time]:
printPredicate(time, predicate)
print '-' * 78
def getPredicateLength(actions, fluents):
row_len = {}
for plan in [actions, fluents]:
for time in plan:
plan[time].sort()
row = 0
for predicate in plan[time]:
predicate = formatPredicate(predicate)[0]
if row in row_len:
if len(predicate) > row_len[row]:
row_len[row] = len(predicate)
else:
row_len[row] = len(predicate)
row += 1
return row_len
def formatPredicate(predicate):
pred = ''
match = ACTION.match(predicate)
if match == None:
match = FLUENT.match(predicate)
if match == None:
pred = predicate
else:
pred = match.group(1)
pred_type = "fluent"
else:
pred = match.group(1)
pred_type = "action"
if not opt.language == 'b' and not opt.meta_encoding:
# remove opening bracket if time was only argument
new_pred = pred.rstrip('(')
# close bracket if needed
if new_pred == pred:
new_pred += ')'
pred = new_pred
if opt.output == "compact":
if pred_type == "action":
pred = "A " + pred
elif pred_type == "fluent":
pred = "F " + pred
elif opt.output == "long":
pred = pred.replace(',', ', ')
return (pred, pred_type)
def printRow(plan, row_len, time):
time_str = str(time).rjust(len(str(len(plan))))
print " %s. " % time_str,
row = 0
for predicate in plan[time]:
print formatPredicate(predicate)[0].ljust(row_len[row]+1),
row += 1
print ""
def printPredicate(time, predicate):
(pred, pred_type) = formatPredicate(predicate)
print str(time).rjust(3) + " ",
if pred_type == "action":
print "A",
elif pred_type == "fluent":
print "F",
else:
print " ",
print " " + pred
if __name__ == '__main__':
if opt.debug:
sys.exit(main())
else:
try:
sys.exit(main())
except Warning, warn:
sys.stderr.write('WARNING: %s\n' % str(warn))
except Exception, err:
sys.stderr.write('ERROR: %s\n' % str(err))
sys.exit(1)
coala-1.0.1_src/src/lib/options.h 000644 001750 001750 00000004060 11477164507 017400 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/options.h - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#ifndef OPTIONS_H
#define OPTIONS_H
#include
#include
using namespace std;
namespace Coala {
class CompilerOptions {
public:
CompilerOptions();
virtual ~CompilerOptions();
bool checkOptions();
void setLanguage(string);
string getLanguage();
void setInputStream(istream&);
istream* getInputStream();
void setOutputStream(ostream&);
ostream* getOutputStream();
void setFakeClassicalNegation(bool);
bool getFakeClassicalNegation();
void setDebug(int);
int getDebug();
void setDirectEncoding(bool);
bool getDirectEncoding();
void setIncremental(bool);
bool getIncremental();
void setReverseIncremental(bool);
bool getReverseIncremental();
void setWhereCheck(bool);
bool getWhereCheck();
private:
string language_;
istream* inputStream_;
ostream* outputStream_;
bool fakeClassicalNegation_;
int debug_;
bool directEncoding_;
bool incremental_;
bool reverseIncremental_;
bool whereCheck_;
};
};
#endif // OPTIONS_H
coala-1.0.1_src/src/lib/main.cpp 000644 001750 001750 00000006610 11477164507 017167 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/main.cpp - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#include "main.h"
#include "c/Compiler.h"
#include "b/Compiler.h"
#include "c_taid/compiler.h"
namespace Coala {
Compiler::Compiler() {
options_ = new CompilerOptions();
}
Compiler::~Compiler() {
delete options_;
//delete compiler_; // segfault with from options
}
int Compiler::compile() {
if(!options_->checkOptions()) {
throw std::runtime_error("Invalid combination of options set.");
}
if(options_->getLanguage() == "c" || options_->getLanguage() == "m") {
compiler_ = new C::Compiler(options_);
}
else if(options_->getLanguage() == "b") {
compiler_ = new B::Compiler(options_);
}
else if(options_->getLanguage() == "c_taid") {
compiler_ = new C_taid::Compiler(options_);
}
else {
throw std::runtime_error("Unknown input language to compile.");
}
if(options_->getDebug() > 99) {
cout << "% Options\n";
cout << "% \n";
cout << "% Language: " << options_->getLanguage() << "\n";
cout << "% Debug Level: " << options_->getDebug() << "\n";
cout << "% Simulated Classical Negation: " << (options_->getFakeClassicalNegation() ? "true" : "false") << "\n";
cout << "% Direct Encoding: " << (options_->getDirectEncoding() ? "true" : "false") << "\n";
cout << "% Incremental: " << (options_->getIncremental() ? "true" : "false") << "\n";
cout << "% Reverse Incremental: " << (options_->getReverseIncremental() ? "true" : "false") << "\n";
cout << "% Where Check: " << (options_->getWhereCheck() ? "true" : "false") << "\n";
}
return compiler_->compile();
}
void Compiler::setLanguage(string language) {
options_->setLanguage(language);
}
void Compiler::setInputStream(istream& inputStream) {
options_->setInputStream(inputStream);
}
void Compiler::setOutputStream(ostream& outputStream) {
options_->setOutputStream(outputStream);
}
void Compiler::setFakeClassicalNegation(bool fakeClassicalNegation) {
options_->setFakeClassicalNegation(fakeClassicalNegation);
}
void Compiler::setDebug(int debug) {
options_->setDebug(debug);
}
void Compiler::setDirectEncoding(bool directEncoding) {
options_->setDirectEncoding(directEncoding);
}
void Compiler::setIncremental(bool incremental) {
options_->setIncremental(incremental);
}
void Compiler::setReverseIncremental(bool reverseIncremental) {
options_->setReverseIncremental(reverseIncremental);
}
void Compiler::setWhereCheck(bool whereCheck) {
options_->setWhereCheck(whereCheck);
}
};
coala-1.0.1_src/src/lib/c_taid/scanner.cpp 000644 001750 001750 00000142533 11477164507 021124 0 ustar 00tovok7 tovok7 000000 000000 #line 2 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.cpp"
#line 4 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.cpp"
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5
#define YY_FLEX_SUBMINOR_VERSION 35
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
/* The c++ scanner is a mess. The FlexLexer.h header file relies on the
* following macro. This is required in order to pass the c++-multiple-scanners
* test in the regression suite. We get reports that it breaks inheritance.
* We will address this in a future release of flex, or omit the C++ scanner
* altogether.
*/
#define yyFlexLexer ctaidFlexLexer
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */
/* end standard C headers. */
/* flex integer type definitions */
#ifndef FLEXINT_H
#define FLEXINT_H
/* C99 systems have . Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
* if you want the limit (max/min) macros for int types.
*/
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif
#include
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (4294967295U)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
/* begin standard C++ headers. */
#include
#include
#include
#include
#include
/* end standard C++ headers. */
#ifdef __cplusplus
/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST
#else /* ! __cplusplus */
/* C99 requires __STDC__ to be defined as 1. */
#if defined (__STDC__)
#define YY_USE_CONST
#endif /* defined (__STDC__) */
#endif /* ! __cplusplus */
#ifdef YY_USE_CONST
#define yyconst const
#else
#define yyconst
#endif
/* Returned upon end-of-file. */
#define YY_NULL 0
/* Promotes a possibly negative, possibly signed char to an unsigned
* integer for use as an array index. If the signed char is negative,
* we want to instead treat it as an 8-bit unsigned char, hence the
* double cast.
*/
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
/* Enter a start condition. This macro really ought to take a parameter,
* but we do it the disgusting crufty way forced on us by the ()-less
* definition of BEGIN.
*/
#define BEGIN (yy_start) = 1 + 2 *
/* Translate the current start state into a value that can be later handed
* to BEGIN to return to the state. The YYSTATE alias is for lex
* compatibility.
*/
#define YY_START (((yy_start) - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin )
#define YY_END_OF_BUFFER_CHAR 0
/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
* Ditto for the __ia64__ case accordingly.
*/
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif
/* The state buf must be large enough to hold one state per character in the main buffer.
*/
#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
extern int yyleng;
#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
/* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
* access to the local variable yy_act. Since yyless() is a macro, it would break
* existing scanners that call yyless() from OUTSIDE yylex.
* One obvious solution it to make yy_act a global. I tried that, and saw
* a 5% performance hit in a non-yylineno scanner, because yy_act is
* normally declared as a register variable-- so it is not worth it.
*/
#define YY_LESS_LINENO(n) \
do { \
int yyl;\
for ( yyl = n; yyl < yyleng; ++yyl )\
if ( yytext[yyl] == '\n' )\
--yylineno;\
}while(0)
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
*yy_cp = (yy_hold_char); \
YY_RESTORE_YY_MORE_OFFSET \
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \
while ( 0 )
#define unput(c) yyunput( c, (yytext_ptr) )
#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
{
std::istream* yy_input_file;
char *yy_ch_buf; /* input buffer */
char *yy_buf_pos; /* current position in input buffer */
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
yy_size_t yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
* delete it.
*/
int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and
* if we're using stdio for input, then we want to use getc()
* instead of fread(), to make sure we stop fetching input after
* each newline.
*/
int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line.
* If so, '^' rules will be active on the next match, otherwise
* not.
*/
int yy_at_bol;
int yy_bs_lineno; /**< The line count. */
int yy_bs_column; /**< The column count. */
/* Whether to try to fill the input buffer when we reach the
* end of it.
*/
int yy_fill_buffer;
int yy_buffer_status;
#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
/* When an EOF's been seen but there's still some text to process
* then we mark the buffer as YY_EOF_PENDING, to indicate that we
* shouldn't try reading from the input source any more. We might
* still have a bunch of tokens to match, though, because of
* possible backing-up.
*
* When we actually see the EOF, we change the status to "new"
* (via yyrestart()), so that the user can continue scanning by
* just pointing yyin at a new input file.
*/
#define YY_BUFFER_EOF_PENDING 2
};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
/* We provide macros for accessing buffer states in case in the
* future we want to put the buffer states in a more general
* "scanner state".
*
* Returns the top of the stack, or NULL.
*/
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
? (yy_buffer_stack)[(yy_buffer_stack_top)] \
: NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
* NULL or when we need an lvalue. For internal use only.
*/
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
void *ctaidalloc (yy_size_t );
void *ctaidrealloc (void *,yy_size_t );
void ctaidfree (void * );
#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
{ \
if ( ! YY_CURRENT_BUFFER ){ \
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer( yyin, YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
#define yy_set_bol(at_bol) \
{ \
if ( ! YY_CURRENT_BUFFER ){\
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer( yyin, YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
/* Begin user sect3 */
#define YY_SKIP_YYWRAP
typedef unsigned char YY_CHAR;
#define yytext_ptr yytext
#define YY_INTERACTIVE
#include
int yyFlexLexer::yywrap() { return 1; }
/* Done after the current pattern has been matched and before the
* corresponding action - sets up yytext.
*/
#define YY_DO_BEFORE_ACTION \
(yytext_ptr) = yy_bp; \
yyleng = (size_t) (yy_cp - yy_bp); \
(yy_hold_char) = *yy_cp; \
*yy_cp = '\0'; \
(yy_c_buf_p) = yy_cp;
#define YY_NUM_RULES 23
#define YY_END_OF_BUFFER 24
/* This struct is not used in this scanner,
but its presence is necessary. */
struct yy_trans_info
{
flex_int32_t yy_verify;
flex_int32_t yy_nxt;
};
static yyconst flex_int16_t yy_accept[122] =
{ 0,
0, 0, 24, 22, 1, 1, 22, 19, 22, 20,
18, 22, 16, 1, 0, 21, 17, 18, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 11, 0, 0, 0, 0,
6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 14, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 2, 8, 5, 0, 0, 3, 0, 0,
0, 0, 0, 4, 13, 0, 0, 0, 15, 0,
9, 0, 0, 7, 0, 12, 0, 0, 0, 10,
0
} ;
static yyconst flex_int32_t yy_ec[256] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 2, 1, 1, 1, 1, 4, 1, 1, 1,
1, 1, 1, 5, 6, 7, 1, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 1, 1, 9,
1, 10, 1, 1, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1, 1, 1, 1, 12, 1, 13, 14, 15, 16,
17, 18, 19, 20, 21, 11, 11, 22, 11, 23,
24, 25, 11, 26, 27, 28, 29, 11, 30, 31,
32, 11, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1
} ;
static yyconst flex_int32_t yy_meta[33] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2
} ;
static yyconst flex_int16_t yy_base[126] =
{ 0,
0, 12, 140, 141, 23, 25, 136, 141, 0, 141,
130, 16, 0, 33, 134, 141, 0, 128, 23, 122,
117, 102, 110, 24, 107, 115, 24, 103, 0, 100,
105, 116, 96, 106, 98, 93, 111, 100, 104, 103,
104, 99, 94, 93, 89, 141, 85, 98, 88, 92,
141, 87, 83, 77, 82, 88, 84, 78, 71, 83,
70, 85, 74, 82, 72, 68, 83, 71, 72, 67,
62, 61, 65, 65, 57, 63, 68, 55, 141, 66,
63, 69, 68, 67, 48, 52, 64, 45, 43, 59,
42, 43, 141, 141, 141, 58, 57, 141, 39, 39,
51, 53, 35, 141, 141, 51, 34, 31, 141, 48,
141, 40, 46, 141, 26, 141, 33, 11, 20, 141,
141, 51, 53, 21, 9
} ;
static yyconst flex_int16_t yy_def[126] =
{ 0,
122, 122, 121, 121, 121, 121, 123, 121, 124, 121,
121, 121, 125, 121, 123, 121, 124, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 125, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
0, 121, 121, 121, 121
} ;
static yyconst flex_int16_t yy_nxt[174] =
{ 0,
4, 5, 6, 7, 8, 9, 10, 11, 12, 4,
29, 4, 4, 5, 6, 7, 8, 9, 10, 11,
12, 4, 17, 4, 14, 14, 14, 14, 19, 120,
20, 21, 22, 23, 14, 14, 24, 30, 25, 26,
27, 37, 119, 28, 31, 41, 38, 118, 117, 42,
32, 13, 13, 15, 15, 116, 115, 114, 113, 112,
111, 110, 109, 108, 107, 106, 105, 104, 103, 102,
101, 100, 99, 98, 97, 96, 95, 94, 93, 92,
91, 90, 89, 88, 87, 86, 85, 84, 83, 82,
81, 80, 79, 78, 77, 76, 75, 74, 73, 72,
71, 70, 69, 68, 67, 66, 65, 64, 63, 62,
61, 60, 59, 58, 57, 56, 55, 54, 53, 52,
51, 50, 49, 48, 47, 46, 45, 44, 43, 40,
39, 36, 35, 34, 33, 18, 16, 18, 16, 121,
3, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121
} ;
static yyconst flex_int16_t yy_chk[174] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
125, 1, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 124, 2, 5, 5, 6, 6, 12, 119,
12, 12, 12, 12, 14, 14, 12, 19, 12, 12,
12, 24, 118, 12, 19, 27, 24, 117, 115, 27,
19, 122, 122, 123, 123, 113, 112, 110, 108, 107,
106, 103, 102, 101, 100, 99, 97, 96, 92, 91,
90, 89, 88, 87, 86, 85, 84, 83, 82, 81,
80, 78, 77, 76, 75, 74, 73, 72, 71, 70,
69, 68, 67, 66, 65, 64, 63, 62, 61, 60,
59, 58, 57, 56, 55, 54, 53, 52, 50, 49,
48, 47, 45, 44, 43, 42, 41, 40, 39, 38,
37, 36, 35, 34, 33, 32, 31, 30, 28, 26,
25, 23, 22, 21, 20, 18, 15, 11, 7, 3,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
121, 121, 121
} ;
/* Table of booleans, true if rule could match eol. */
static yyconst flex_int32_t yy_rule_can_match_eol[24] =
{ 0,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, };
/* The intent behind this definition is that it'll catch
* any uses of REJECT which flex missed.
*/
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
#line 1 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
/****************************************************************************
* lib/c_taid/scanner.l - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#line 21 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
#include "parser.h"
#include
bool second_part = false;
bool asked_query = false;
void printPartError(const string, const int);
void printQueryError(const string, const int);
#line 542 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.cpp"
#define INITIAL 0
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
* down here because we want the user's section 1 to have been scanned first.
* The user has a chance to override it with an option.
*/
#include
#endif
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
#ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int );
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * );
#endif
#ifndef YY_NO_INPUT
#endif
/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif
/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
#define ECHO LexerOutput( yytext, yyleng )
#endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
* is returned in "result".
*/
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
\
if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
YY_FATAL_ERROR( "input in flex scanner failed" );
#endif
/* No semi-colon after return; correct usage is to write "yyterminate();" -
* we don't want an extra ';' after the "return" because that will cause
* some compilers to complain about unreachable statements.
*/
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif
/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif
/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) LexerError( msg )
#endif
/* end tables serialization structures and prototypes */
/* Default declaration of generated scanner - a define so the user can
* easily add parameters.
*/
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1
#define YY_DECL int yyFlexLexer::yylex()
#endif /* !YY_DECL */
/* Code executed at the beginning of each rule, after yytext and yyleng
* have been set up.
*/
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif
/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#endif
#define YY_RULE_SETUP \
YY_USER_ACTION
/** The main scanner function which does all the work.
*/
YY_DECL
{
register yy_state_type yy_current_state;
register char *yy_cp, *yy_bp;
register int yy_act;
#line 53 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
#line 649 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.cpp"
if ( !(yy_init) )
{
(yy_init) = 1;
#ifdef YY_USER_INIT
YY_USER_INIT;
#endif
if ( ! (yy_start) )
(yy_start) = 1; /* first start state */
if ( ! yyin )
yyin = & std::cin;
if ( ! yyout )
yyout = & std::cout;
if ( ! YY_CURRENT_BUFFER ) {
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer( yyin, YY_BUF_SIZE );
}
yy_load_buffer_state( );
}
while ( 1 ) /* loops until end-of-file is reached */
{
yy_cp = (yy_c_buf_p);
/* Support of yytext. */
*yy_cp = (yy_hold_char);
/* yy_bp points to the position in yy_ch_buf of the start of
* the current run.
*/
yy_bp = yy_cp;
yy_current_state = (yy_start);
yy_match:
do
{
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 122 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp;
}
while ( yy_base[yy_current_state] != 141 );
yy_find_action:
yy_act = yy_accept[yy_current_state];
if ( yy_act == 0 )
{ /* have to back up */
yy_cp = (yy_last_accepting_cpos);
yy_current_state = (yy_last_accepting_state);
yy_act = yy_accept[yy_current_state];
}
YY_DO_BEFORE_ACTION;
if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
{
int yyl;
for ( yyl = 0; yyl < yyleng; ++yyl )
if ( yytext[yyl] == '\n' )
yylineno++;
;
}
do_action: /* This label is used only to access EOF actions. */
switch ( yy_act )
{ /* beginning of action switch */
case 0: /* must back up */
/* undo the effects of YY_DO_BEFORE_ACTION */
*yy_cp = (yy_hold_char);
yy_cp = (yy_last_accepting_cpos);
yy_current_state = (yy_last_accepting_state);
goto yy_find_action;
case 1:
/* rule 1 can match eol */
YY_RULE_SETUP
#line 54 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
// ignore white space.
YY_BREAK
case 2:
YY_RULE_SETUP
#line 55 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ if(second_part) printPartError(yytext, lineno()); else return CtaidParser::ACT; }
YY_BREAK
case 3:
YY_RULE_SETUP
#line 56 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::FLU; }
YY_BREAK
case 4:
YY_RULE_SETUP
#line 57 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::DEF; }
YY_BREAK
case 5:
YY_RULE_SETUP
#line 58 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::CAUS; }
YY_BREAK
case 6:
YY_RULE_SETUP
#line 59 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::IF; }
YY_BREAK
case 7:
YY_RULE_SETUP
#line 60 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ if(second_part) printPartError(yytext, lineno()); else return CtaidParser::TRIG; }
YY_BREAK
case 8:
YY_RULE_SETUP
#line 61 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ if(second_part) printPartError(yytext, lineno()); else return CtaidParser::ALLOW; }
YY_BREAK
case 9:
YY_RULE_SETUP
#line 62 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::INHIB; }
YY_BREAK
case 10:
YY_RULE_SETUP
#line 63 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::NCONC; }
YY_BREAK
case 11:
YY_RULE_SETUP
#line 64 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::AT; }
YY_BREAK
case 12:
YY_RULE_SETUP
#line 65 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ second_part = true; return CtaidParser::OC_AT; }
YY_BREAK
case 13:
YY_RULE_SETUP
#line 66 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ if(asked_query) printQueryError(yytext, lineno());
else {
asked_query = true;
return CtaidParser::EXP;
}
}
YY_BREAK
case 14:
YY_RULE_SETUP
#line 72 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ if(asked_query) printQueryError(yytext, lineno());
else {
asked_query = true;
return CtaidParser::PLAN;
}
}
YY_BREAK
case 15:
YY_RULE_SETUP
#line 78 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ if(asked_query) printQueryError(yytext, lineno());
else {
asked_query = true;
return CtaidParser::PRED;
}
}
YY_BREAK
case 16:
YY_RULE_SETUP
#line 84 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::IDENTIFIER; }
YY_BREAK
case 17:
YY_RULE_SETUP
#line 85 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::NEG_IDENTI; }
YY_BREAK
case 18:
YY_RULE_SETUP
#line 86 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::NUMBER; }
YY_BREAK
case 19:
YY_RULE_SETUP
#line 87 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::COMMA; }
YY_BREAK
case 20:
YY_RULE_SETUP
#line 88 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ return CtaidParser::DOT; }
YY_BREAK
case 21:
/* rule 21 can match eol */
YY_RULE_SETUP
#line 89 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ /* comment */ }
YY_BREAK
case YY_STATE_EOF(INITIAL):
#line 90 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ yyterminate(); }
YY_BREAK
case 22:
YY_RULE_SETUP
#line 91 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
{ cerr << "\n\nError: Unknown keyword '"+string(yytext)+"' found at line "<yy_buffer_status == YY_BUFFER_NEW )
{
/* We're scanning a new file or input source. It's
* possible that this happened because the user
* just pointed yyin at a new source and called
* yylex(). If so, then we have to assure
* consistency between YY_CURRENT_BUFFER and our
* globals. Here is the right place to do so, because
* this is the first action (other than possibly a
* back-up) that will match for the new input source.
*/
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
}
/* Note that here we test for yy_c_buf_p "<=" to the position
* of the first EOB in the buffer, since yy_c_buf_p will
* already have been incremented past the NUL character
* (since all states make transitions on EOB to the
* end-of-buffer state). Contrast this with the test
* in input().
*/
if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
{ /* This was really a NUL. */
yy_state_type yy_next_state;
(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
/* Okay, we're now positioned to make the NUL
* transition. We couldn't have
* yy_get_previous_state() go ahead and do it
* for us because it doesn't know how to deal
* with the possibility of jamming (and we don't
* want to build jamming into it because then it
* will run more slowly).
*/
yy_next_state = yy_try_NUL_trans( yy_current_state );
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
if ( yy_next_state )
{
/* Consume the NUL. */
yy_cp = ++(yy_c_buf_p);
yy_current_state = yy_next_state;
goto yy_match;
}
else
{
yy_cp = (yy_c_buf_p);
goto yy_find_action;
}
}
else switch ( yy_get_next_buffer( ) )
{
case EOB_ACT_END_OF_FILE:
{
(yy_did_buffer_switch_on_eof) = 0;
if ( yywrap( ) )
{
/* Note: because we've taken care in
* yy_get_next_buffer() to have set up
* yytext, we can now set up
* yy_c_buf_p so that if some total
* hoser (like flex itself) wants to
* call the scanner after we return the
* YY_NULL, it'll still work - another
* YY_NULL will get returned.
*/
(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
yy_act = YY_STATE_EOF(YY_START);
goto do_action;
}
else
{
if ( ! (yy_did_buffer_switch_on_eof) )
YY_NEW_FILE;
}
break;
}
case EOB_ACT_CONTINUE_SCAN:
(yy_c_buf_p) =
(yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p);
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
goto yy_match;
case EOB_ACT_LAST_MATCH:
(yy_c_buf_p) =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p);
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
goto yy_find_action;
}
break;
}
default:
YY_FATAL_ERROR(
"fatal flex scanner internal error--no action found" );
} /* end of action switch */
} /* end of scanning one token */
} /* end of yylex */
/* The contents of this function are C++ specific, so the () macro is not used.
*/
yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
{
yyin = arg_yyin;
yyout = arg_yyout;
yy_c_buf_p = 0;
yy_init = 0;
yy_start = 0;
yy_flex_debug = 0;
yylineno = 1; // this will only get updated if %option yylineno
yy_did_buffer_switch_on_eof = 0;
yy_looking_for_trail_begin = 0;
yy_more_flag = 0;
yy_more_len = 0;
yy_more_offset = yy_prev_more_offset = 0;
yy_start_stack_ptr = yy_start_stack_depth = 0;
yy_start_stack = NULL;
yy_buffer_stack = 0;
yy_buffer_stack_top = 0;
yy_buffer_stack_max = 0;
yy_state_buf = 0;
}
/* The contents of this function are C++ specific, so the () macro is not used.
*/
yyFlexLexer::~yyFlexLexer()
{
delete [] yy_state_buf;
ctaidfree(yy_start_stack );
yy_delete_buffer( YY_CURRENT_BUFFER );
ctaidfree(yy_buffer_stack );
}
/* The contents of this function are C++ specific, so the () macro is not used.
*/
void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
{
if ( new_in )
{
yy_delete_buffer( YY_CURRENT_BUFFER );
yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
}
if ( new_out )
yyout = new_out;
}
#ifdef YY_INTERACTIVE
int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
#else
int yyFlexLexer::LexerInput( char* buf, int max_size )
#endif
{
if ( yyin->eof() || yyin->fail() )
return 0;
#ifdef YY_INTERACTIVE
yyin->get( buf[0] );
if ( yyin->eof() )
return 0;
if ( yyin->bad() )
return -1;
return 1;
#else
(void) yyin->read( buf, max_size );
if ( yyin->bad() )
return -1;
else
return yyin->gcount();
#endif
}
void yyFlexLexer::LexerOutput( const char* buf, int size )
{
(void) yyout->write( buf, size );
}
/* yy_get_next_buffer - try to read in a new buffer
*
* Returns a code representing an action:
* EOB_ACT_LAST_MATCH -
* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
* EOB_ACT_END_OF_FILE - end of file
*/
int yyFlexLexer::yy_get_next_buffer()
{
register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
register char *source = (yytext_ptr);
register int number_to_move, i;
int ret_val;
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
YY_FATAL_ERROR(
"fatal flex scanner internal error--end of buffer missed" );
if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
{ /* Don't try to fill the buffer, so this is an EOF. */
if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
{
/* We matched a single character, the EOB, so
* treat this as a final EOF.
*/
return EOB_ACT_END_OF_FILE;
}
else
{
/* We matched some text prior to the EOB, first
* process it.
*/
return EOB_ACT_LAST_MATCH;
}
}
/* Try to read more data. */
/* First move last chars to start of buffer. */
number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
/* don't do the read, it's not guaranteed to return an EOF,
* just force an EOF
*/
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
else
{
int num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
{ /* Not enough room in the buffer - grow it. */
/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
int yy_c_buf_p_offset =
(int) ((yy_c_buf_p) - b->yy_ch_buf);
if ( b->yy_is_our_buffer )
{
int new_size = b->yy_buf_size * 2;
if ( new_size <= 0 )
b->yy_buf_size += b->yy_buf_size / 8;
else
b->yy_buf_size *= 2;
b->yy_ch_buf = (char *)
/* Include room in for 2 EOB chars. */
ctaidrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
}
else
/* Can't grow it, we don't own it. */
b->yy_ch_buf = 0;
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(
"fatal error - scanner input buffer overflow" );
(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
number_to_move - 1;
}
if ( num_to_read > YY_READ_BUF_SIZE )
num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
(yy_n_chars), (size_t) num_to_read );
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
if ( (yy_n_chars) == 0 )
{
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
yyrestart( yyin );
}
else
{
ret_val = EOB_ACT_LAST_MATCH;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
YY_BUFFER_EOF_PENDING;
}
}
else
ret_val = EOB_ACT_CONTINUE_SCAN;
if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
/* Extend the array by 50%, plus the number we really need. */
yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) ctaidrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
}
(yy_n_chars) += number_to_move;
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
return ret_val;
}
/* yy_get_previous_state - get the state just before the EOB char was reached */
yy_state_type yyFlexLexer::yy_get_previous_state()
{
register yy_state_type yy_current_state;
register char *yy_cp;
yy_current_state = (yy_start);
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
{
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 122 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
}
return yy_current_state;
}
/* yy_try_NUL_trans - try to make a transition on the NUL character
*
* synopsis
* next_state = yy_try_NUL_trans( current_state );
*/
yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
{
register int yy_is_jam;
register char *yy_cp = (yy_c_buf_p);
register YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 122 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_is_jam = (yy_current_state == 121);
return yy_is_jam ? 0 : yy_current_state;
}
void yyFlexLexer::yyunput( int c, register char* yy_bp)
{
register char *yy_cp;
yy_cp = (yy_c_buf_p);
/* undo effects of setting up yytext */
*yy_cp = (yy_hold_char);
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
register int number_to_move = (yy_n_chars) + 2;
register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
register char *source =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
*--dest = *--source;
yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
}
*--yy_cp = (char) c;
if ( c == '\n' ){
--yylineno;
}
(yytext_ptr) = yy_bp;
(yy_hold_char) = *yy_cp;
(yy_c_buf_p) = yy_cp;
}
int yyFlexLexer::yyinput()
{
int c;
*(yy_c_buf_p) = (yy_hold_char);
if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
{
/* yy_c_buf_p now points to the character we want to return.
* If this occurs *before* the EOB characters, then it's a
* valid NUL; if not, then we've hit the end of the buffer.
*/
if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
/* This was really a NUL. */
*(yy_c_buf_p) = '\0';
else
{ /* need more input */
int offset = (yy_c_buf_p) - (yytext_ptr);
++(yy_c_buf_p);
switch ( yy_get_next_buffer( ) )
{
case EOB_ACT_LAST_MATCH:
/* This happens because yy_g_n_b()
* sees that we've accumulated a
* token and flags that we need to
* try matching the token before
* proceeding. But for input(),
* there's no matching to consider.
* So convert the EOB_ACT_LAST_MATCH
* to EOB_ACT_END_OF_FILE.
*/
/* Reset buffer status. */
yyrestart( yyin );
/*FALLTHROUGH*/
case EOB_ACT_END_OF_FILE:
{
if ( yywrap( ) )
return EOF;
if ( ! (yy_did_buffer_switch_on_eof) )
YY_NEW_FILE;
#ifdef __cplusplus
return yyinput();
#else
return input();
#endif
}
case EOB_ACT_CONTINUE_SCAN:
(yy_c_buf_p) = (yytext_ptr) + offset;
break;
}
}
}
c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
*(yy_c_buf_p) = '\0'; /* preserve yytext */
(yy_hold_char) = *++(yy_c_buf_p);
if ( c == '\n' )
yylineno++;
;
return c;
}
/** Immediately switch to a different input stream.
* @param input_file A readable stream.
*
* @note This function does not reset the start condition to @c INITIAL .
*/
void yyFlexLexer::yyrestart( std::istream* input_file )
{
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer( yyin, YY_BUF_SIZE );
}
yy_init_buffer( YY_CURRENT_BUFFER, input_file );
yy_load_buffer_state( );
}
/** Switch to a different input buffer.
* @param new_buffer The new input buffer.
*
*/
void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
{
/* TODO. We should be able to replace this entire function body
* with
* yypop_buffer_state();
* yypush_buffer_state(new_buffer);
*/
yyensure_buffer_stack ();
if ( YY_CURRENT_BUFFER == new_buffer )
return;
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
YY_CURRENT_BUFFER_LVALUE = new_buffer;
yy_load_buffer_state( );
/* We don't actually know whether we did this switch during
* EOF (yywrap()) processing, but the only time this flag
* is looked at is after yywrap() is called, so it's safe
* to go ahead and always set it.
*/
(yy_did_buffer_switch_on_eof) = 1;
}
void yyFlexLexer::yy_load_buffer_state()
{
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
(yy_hold_char) = *(yy_c_buf_p);
}
/** Allocate and initialize an input buffer state.
* @param file A readable stream.
* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
*
* @return the allocated buffer state.
*/
YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) ctaidalloc(sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size given because
* we need to put in 2 end-of-buffer characters.
*/
b->yy_ch_buf = (char *) ctaidalloc(b->yy_buf_size + 2 );
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_is_our_buffer = 1;
yy_init_buffer( b, file );
return b;
}
/** Destroy the buffer.
* @param b a buffer created with yy_create_buffer()
*
*/
void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
{
if ( ! b )
return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
ctaidfree((void *) b->yy_ch_buf );
ctaidfree((void *) b );
}
extern "C" int isatty (int );
/* Initializes or reinitializes a buffer.
* This function is sometimes called more than once on the same buffer,
* such as during a yyrestart() or at EOF.
*/
void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
{
int oerrno = errno;
yy_flush_buffer( b );
b->yy_input_file = file;
b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_
* called from yyrestart() or through yy_get_next_buffer.
* In that case, we don't want to reset the lineno or column.
*/
if (b != YY_CURRENT_BUFFER){
b->yy_bs_lineno = 1;
b->yy_bs_column = 0;
}
b->yy_is_interactive = 0;
errno = oerrno;
}
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
*
*/
void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
{
if ( ! b )
return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes
* a transition to the end-of-buffer state. The second causes
* a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
yy_load_buffer_state( );
}
/** Pushes the new state onto the stack. The new state becomes
* the current state. This function will allocate the stack
* if necessary.
* @param new_buffer The new state.
*
*/
void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
{
if (new_buffer == NULL)
return;
yyensure_buffer_stack();
/* This block is copied from yy_switch_to_buffer. */
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
/* Only push if top exists. Otherwise, replace top. */
if (YY_CURRENT_BUFFER)
(yy_buffer_stack_top)++;
YY_CURRENT_BUFFER_LVALUE = new_buffer;
/* copied from yy_switch_to_buffer. */
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
/** Removes and deletes the top of the stack, if present.
* The next element becomes the new top.
*
*/
void yyFlexLexer::yypop_buffer_state (void)
{
if (!YY_CURRENT_BUFFER)
return;
yy_delete_buffer(YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;
if ((yy_buffer_stack_top) > 0)
--(yy_buffer_stack_top);
if (YY_CURRENT_BUFFER) {
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
}
/* Allocates the stack if it does not exist.
* Guarantees space for at least one push.
*/
void yyFlexLexer::yyensure_buffer_stack(void)
{
int num_to_alloc;
if (!(yy_buffer_stack)) {
/* First allocation is just for 2 elements, since we don't know if this
* scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call.
*/
num_to_alloc = 1;
(yy_buffer_stack) = (struct yy_buffer_state**)ctaidalloc
(num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
(yy_buffer_stack_max) = num_to_alloc;
(yy_buffer_stack_top) = 0;
return;
}
if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
/* Increase the buffer to prepare for a possible push. */
int grow_size = 8 /* arbitrary grow size */;
num_to_alloc = (yy_buffer_stack_max) + grow_size;
(yy_buffer_stack) = (struct yy_buffer_state**)ctaidrealloc
((yy_buffer_stack),
num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
/* zero only the new slots.*/
memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
(yy_buffer_stack_max) = num_to_alloc;
}
}
void yyFlexLexer::yy_push_state( int new_state )
{
if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
{
yy_size_t new_size;
(yy_start_stack_depth) += YY_START_STACK_INCR;
new_size = (yy_start_stack_depth) * sizeof( int );
if ( ! (yy_start_stack) )
(yy_start_stack) = (int *) ctaidalloc(new_size );
else
(yy_start_stack) = (int *) ctaidrealloc((void *) (yy_start_stack),new_size );
if ( ! (yy_start_stack) )
YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
}
(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
BEGIN(new_state);
}
void yyFlexLexer::yy_pop_state()
{
if ( --(yy_start_stack_ptr) < 0 )
YY_FATAL_ERROR( "start-condition stack underflow" );
BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
}
int yyFlexLexer::yy_top_state()
{
return (yy_start_stack)[(yy_start_stack_ptr) - 1];
}
#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif
void yyFlexLexer::LexerError( yyconst char msg[] )
{
std::cerr << msg << std::endl;
exit( YY_EXIT_FAILURE );
}
/* Redefine yyless() so it works in section 3 code. */
#undef yyless
#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
yytext[yyleng] = (yy_hold_char); \
(yy_c_buf_p) = yytext + yyless_macro_arg; \
(yy_hold_char) = *(yy_c_buf_p); \
*(yy_c_buf_p) = '\0'; \
yyleng = yyless_macro_arg; \
} \
while ( 0 )
/* Accessor methods (get/set functions) to struct members. */
/*
* Internal utility routines.
*/
#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
{
register int i;
for ( i = 0; i < n; ++i )
s1[i] = s2[i];
}
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * s )
{
register int n;
for ( n = 0; s[n]; ++n )
;
return n;
}
#endif
void *ctaidalloc (yy_size_t size )
{
return (void *) malloc( size );
}
void *ctaidrealloc (void * ptr, yy_size_t size )
{
/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latter
* because both ANSI C and C++ allow castless assignment from
* any pointer type to void*, and deal with argument conversions
* as though doing an assignment.
*/
return (void *) realloc( (char *) ptr, size );
}
void ctaidfree (void * ptr )
{
free( (char *) ptr ); /* see ctaidrealloc() for (char *) cast */
}
#define YYTABLES_NAME "yytables"
#line 94 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/scanner.l"
void printPartError(const string etext, const int line) {
cerr << "\n\nError: Keyword '"+etext+"' may only appear in description part, but found at line "<getDebug(); neg=options->getFakeClassicalNegation()?"neg_":"-";}
%define MEMBERS void postProcessing(); bool cout_neg(bool); int debug; string neg; virtual ~CtaidParser(){}\
private:\
typedef set > StringSet;\
StringSet all_fluents;\
StringSet default_fluents;\
StringSet inertial_fluents;\
StringSet all_actions;\
StringSet triggered_actions;\
StringSet allowed_actions;\
StringSet exogenous_actions;
// TODO
// - adapt debug value
// - get the end time right
// - action rules for prediction only for non-triggered ones
// - check whether fluents and actions are defined
%header{
#include
#include
#include
#include
#include
#include
#include "../options.h"
using namespace std;
//using namespace C_taid;
%}
%{
typedef list > ListPair;
int latest_obs = 0;
%}
%union {
int number;
const string *istring;
list > *ilist;
}
%token IDENTIFIER
%token NEG_IDENTI
%token NUMBER
%token ACT // action
%token FLU // fluent
%token DEF // default
%token CAUS // causes
%token IF // if
%token TRIG // triggers
%token ALLOW // allows
%token INHIB // inhibits
%token NCONC // noconcurrency
%token AT // at
%token OC_AT // occurs_at
%token EXP // explain
%token PLAN // plan
%token PRED // predict
%token COMMA // ,
%token DOT // .
%type fluent_list
%start program
%%
program: /* empty */ | program rule DOT;
rule: desc_rule | obs_rule | query_rule;
desc_rule: fact | static_rule | dyn_rule | trig_rule | allow_rule | inhib_rule | nconc_rule;
obs_rule: flu_obs | act_obs;
query_rule: exp_rule | plan_rule | pred_rule;
fact: act_fact | flu_fact | def_fact;
// (action a_1,...,a_n)
act_fact: ACT fluent_list { // not really a fluent_list, but I still use it for actions
for(ListPair::iterator n = $2->begin(); n != $2->end(); ++n) {
if(neg == "neg_") {
cout << ":- action_"+n->first+"(T), neg_action_"+n->first+"(T), time(T).\n";
// hides every neg_action
if(debug < 2) cout << "#hide neg_action_"+n->first+"(T).\n";
}
all_actions.insert(n->first);
}
delete $2;
}
// (fluent f_1,...,f_n)
flu_fact: FLU fluent_list {
for(ListPair::iterator n = $2->begin(); n != $2->end(); ++n) {
all_fluents.insert(n->first);
}
delete $2;
}
// (default f_1,...,f_n)
def_fact: DEF fluent_list {
for(ListPair::iterator n = $2->begin(); n != $2->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T) :- not ";
cout_neg(!n->second);
cout << "fluent_"+n->first+"(T), time(T).\n";
if(neg == "neg_") {
// relationship between fluent and its negation
cout << ":- fluent_"+n->first+"(T), neg_fluent_"+n->first+"(T), time(T).\n";
// hides neg_fluent for every default fluent
if(debug < 2) {
cout << "#hide neg_fluent_"+n->first+"(T).\n";
}
}
if(debug < 1) cout << "#hide fluent_"+n->first+"(T).\n";
default_fluents.insert(n->first);
}
delete $2;
}
// (a causes f_1,...,f_n if g_1,...,g_m)
dyn_rule: IDENTIFIER CAUS fluent_list IF fluent_list {
for(ListPair::iterator n = $3->begin(); n != $3->end(); ++n) {
// f_1,...,f_n
cout_neg(n->second);
cout << "fluent_"+n->first+"(T+1) :- action_"+*$1+"(T), ";
for(ListPair::iterator m = $5->begin(); m != $5->end(); ++m) {
// g_1,...,g_m
cout_neg(m->second);
cout << "fluent_"+m->first+"(T), ";
}
cout << "time(T; T+1).\n";
}
delete $1;
delete $3;
delete $5;
}
// (a causes f_1,...,f_n)
| IDENTIFIER CAUS fluent_list {
for(ListPair::iterator n = $3->begin(); n != $3->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T+1) :- action_"+*$1+"(T), time(T; T+1).\n";
}
delete $1;
delete $3;
}
// (f_1,...,f_n if g_1,...,g_m)
static_rule: fluent_list IF fluent_list {
for(ListPair::iterator n = $1->begin(); n != $1->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T) :- ";
for(ListPair::iterator m = $3->begin(); m != $3->end(); ++m) {
cout_neg(m->second);
cout << "fluent_"+m->first+"(T), ";
}
cout << "time(T).\n";
}
delete $1;
delete $3;
}
// (f_1,...,f_n triggers a)
trig_rule: fluent_list TRIG IDENTIFIER {
cout << "trig_action_"+*$3+"(T) :- ";
for(ListPair::iterator n = $1->begin(); n != $1->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T), ";
}
cout << "time(T).\n";
// trigger only when not inhibited
cout << "action_"+*$3+"(T) :- trig_action_"+*$3+"(T), not "+neg+"action_"+*$3+"(T), time(T).\n";
// hides every trig_action
if(debug < 2) cout << "#hide trig_action_"+*$3+"(T).\n";
triggered_actions.insert(*$3);
delete $1;
delete $3;
}
// (f_1,...,f_n allows a)
allow_rule: fluent_list ALLOW IDENTIFIER {
cout << "allow_action_"+*$3+"(T) :- ";
for(ListPair::iterator n = $1->begin(); n != $1->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T), ";
}
cout << "time(T).\n";
// hides allow_action for every allowed action
if(debug < 2) cout << "#hide allow_action_"+*$3+"(T).\n";
allowed_actions.insert(*$3);
delete $1;
delete $3;
}
// (f_1,...,f_n inhibits a)
inhib_rule: fluent_list INHIB IDENTIFIER {
cout << neg+"action_"+*$3+"(T) :- ";
for(ListPair::iterator n = $1->begin(); n != $1->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T), ";
}
cout << "time(T).\n";
delete $1;
delete $3;
}
// (noconcurrency a_1,...,a_n)
nconc_rule: NCONC fluent_list { // not really a fluent_list, but I still use it for actions
cout << ":- 2 {";
for(ListPair::iterator n = $2->begin(); n != $2->end(); ++n) {
if(n != $2->begin()) cout << ", ";
cout << "action_"+n->first+"(T)";
}
cout << "}, time(T).\n";
delete $2;
}
// f at t_i
flu_obs: fluent_list AT NUMBER {
for(ListPair::iterator n = $1->begin(); n != $1->end(); ++n) {
if($3 == 0) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(0).\n";
}
else {
cout << ":- not ";
cout_neg(n->second);
cout << "fluent_"+n->first+"("<<$3<<"), time("<<$3<<").\n";
}
}
// remember a later observation time
latest_obs = ($3 > latest_obs) ? $3 : latest_obs ;
delete $1;
}
// a occurs_at t_i
act_obs: fluent_list OC_AT NUMBER {
for(ListPair::iterator n = $1->begin(); n != $1->end(); ++n) {
// for non-exogenous actions (not triggered or allowed)
if(triggered_actions.find(n->first) != triggered_actions.end() || allowed_actions.find(n->first) != allowed_actions.end()) {
cout << ":- ";
cout_neg(!n->second);
cout << "action_"+n->first+"("<<$3<<"), time("<<$3<<").\n";
}
// for exogenous actions
else {
cout_neg(n->second);
cout << "action_"+n->first+"("<<$3<<").\n";
}
}
// remember a later observation time
latest_obs = ($3 > latest_obs) ? $3 : latest_obs ;
delete $1;
}
// explain n
exp_rule: EXP {
// rules for generating all possible initial states
for(StringSet::iterator n = all_fluents.begin(); n != all_fluents.end(); ++n) {
cout << "fluent_"+*n+"(0) :- not "+neg+"fluent_"+*n+"(0).\n";
cout << neg+"fluent_"+*n+"(0) :- not fluent_"+*n+"(0).\n";
}
// all exogenous and allowed actions in one set: all - triggered
StringSet exoallow_actions;
set_difference(all_actions.begin(), all_actions.end(), triggered_actions.begin(), triggered_actions.end(),
insert_iterator(exoallow_actions, exoallow_actions.begin()) );
for(StringSet::iterator n = exoallow_actions.begin(); n != exoallow_actions.end(); ++n) {
cout << "action_"+*n+"(T) :- allow_action_"+*n+"(T), not "+neg+"action_"+*n+"(T), time(T), T(exoallow_actions, exoallow_actions.begin()) );
for(StringSet::iterator n = exoallow_actions.begin(); n != exoallow_actions.end(); ++n) {
cout << "action_"+*n+"(T) :- allow_action_"+*n+"(T), not "+neg+"action_"+*n+"(T), not achieved(T), time(T).\n";
cout << neg+"action_"+*n+"(T) :- not action_"+*n+"(T), time(T).\n";
}
cout << ":- not achieved.\n";
cout << "achieved :- achieved(0).\n";
cout << "achieved :- achieved(T+1), not achieved(T), time(T;T+1).\n";
cout << "achieved(T) :- ";
for(ListPair::iterator n = $2->begin(); n != $2->end(); ++n) {
if(n != $2->begin()) cout << ", ";
cout_neg(n->second);
cout << "fluent_"+n->first+"(T)";
}
cout << ", T=n.\n";
cout << "achieved(T) :- achieved(T+1), ";
for(ListPair::iterator n = $2->begin(); n != $2->end(); ++n) {
if(n != $2->begin()) cout << ", ";
cout_neg(n->second);
cout << "fluent_"+n->first+"(T)";
}
cout << ", time(T;T+1).\n";
// hides the achieve predicates
if(debug < 2) cout << "#hide achieved.\n";
if(debug < 2) cout << "#hide achieved(T).\n";
delete $2;
}
// predict f_1,...,f_n
pred_rule: PRED fluent_list {
// rules for generating all possible initial states
for(StringSet::iterator n = all_fluents.begin(); n != all_fluents.end(); ++n) {
cout << "fluent_"+*n+"(0) :- not "+neg+"fluent_"+*n+"(0).\n";
cout << neg+"fluent_"+*n+"(0) :- not fluent_"+*n+"(0).\n";
}
// justify the observations by including for every action:
for(StringSet::iterator n = all_actions.begin(); n != all_actions.end(); ++n) {
cout << "action_"+*n+"(T) :- allow_action_"+*n+"(T), not "+neg+"action_"+*n+"(T), time(T), Tbegin(); n != $2->end(); ++n) {
if(n != $2->begin()) cout << ", ";
cout_neg(n->second);
cout << "fluent_"+n->first+"(T)";
}
cout << ", time(T), T>="<push_back(pair(*$1, true));
delete $1;
}
| NEG_IDENTI {
$$ = new ListPair();
$$->push_back(pair(*$1, false));
delete $1;
}
| fluent_list COMMA IDENTIFIER {
$1->push_back(pair(*$3, true));
$$ = $1;
delete $3;
}
| fluent_list COMMA NEG_IDENTI {
$1->push_back(pair(*$3, false));
$$ = $1;
delete $3;
}
%%
void CtaidParser::postProcessing() {
// trig_allow_actions = triggered_actions + allowed_actions
StringSet trig_allow_actions;
set_union(triggered_actions.begin(), triggered_actions.end(), allowed_actions.begin(), allowed_actions.end(),
insert_iterator(trig_allow_actions, trig_allow_actions.begin()) );
// exogenous_actions = all_actions - trig_allow_actions
set_difference(all_actions.begin(), all_actions.end(), trig_allow_actions.begin(), trig_allow_actions.end(),
insert_iterator(exogenous_actions, exogenous_actions.begin()) );
// add rules for EXOGENOUS actions (not triggered or allowed)
cout << "\n% exogenous actions\n";
for(StringSet::iterator n = exogenous_actions.begin(); n != exogenous_actions.end(); ++n) {
cout << "allow_action_"+*n+"(T) :- time(T).\n";
// hides allow_action for every exogenous action
if(debug < 2) cout << "#hide allow_action_"+*n+"(T).\n";
}
// inertial_fluents = all_fluents - default_fluents
set_difference(all_fluents.begin(), all_fluents.end(), default_fluents.begin(), default_fluents.end(),
insert_iterator(inertial_fluents, inertial_fluents.begin()) );
// add rules for INERTIAL fluents (not default)
cout << "\n% inertial fluents\n";
for(StringSet::iterator n = inertial_fluents.begin(); n != inertial_fluents.end(); ++n) {
cout << "fluent_"+*n+"(T+1) :- fluent_"+*n+"(T), not "+neg+"fluent_"+*n+"(T+1), time(T;T+1).\n";
cout << neg+"fluent_"+*n+"(T+1) :- "+neg+"fluent_"+*n+"(T), not fluent_"+*n+"(T+1), time(T;T+1).\n";
if(neg == "neg_") {
// relationship between fluent and its negation
cout << ":- fluent_"+*n+"(T), neg_fluent_"+*n+"(T), time(T).\n";
// hides neg_fluent for every inertial fluent
if(debug < 2) {
cout << "#hide neg_fluent_"+*n+"(T).\n";
}
}
if(debug < 1) cout << "#hide fluent_"+*n+"(T).\n";
}
// add time
cout << "\n% time facts\n";
cout << "time(0..n).\n";
if(debug < 2) cout << "#hide time(N).\n";
}
bool CtaidParser::cout_neg(bool not_neg) {
if(not_neg) return true;
else {
cout << neg;
return false;
}
}
coala-1.0.1_src/src/lib/c_taid/parser.h 000644 001750 001750 00000021232 11477164507 020424 0 ustar 00tovok7 tovok7 000000 000000 #ifndef YY_CtaidParser_h_included
#define YY_CtaidParser_h_included
#define YY_USE_CLASS
#line 1 "/usr/share/bison++/bison.h"
/* before anything */
#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#endif
#endif
#line 8 "/usr/share/bison++/bison.h"
#define YY_CtaidParser_LSP_NEEDED
#define YY_CtaidParser_ERROR_BODY = 0
#define YY_CtaidParser_LEX_BODY = 0
#define YY_CtaidParser_CONSTRUCTOR_PARAM Coala::CompilerOptions* options
#define YY_CtaidParser_CONSTRUCTOR_CODE {debug=options->getDebug(); neg=options->getFakeClassicalNegation()?"neg_":"-";}
#define YY_CtaidParser_MEMBERS void postProcessing(); bool cout_neg(bool); int debug; string neg; virtual ~CtaidParser(){}\
private:\
typedef set > StringSet;\
StringSet all_fluents;\
StringSet default_fluents;\
StringSet inertial_fluents;\
StringSet all_actions;\
StringSet triggered_actions;\
StringSet allowed_actions;\
StringSet exogenous_actions;
#line 44 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
#include
#include
#include
#include
#include
#include
#include "../options.h"
using namespace std;
//using namespace C_taid;
#line 64 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
typedef union {
int number;
const string *istring;
list > *ilist;
} yy_CtaidParser_stype;
#define YY_CtaidParser_STYPE yy_CtaidParser_stype
#line 21 "/usr/share/bison++/bison.h"
/* %{ and %header{ and %union, during decl */
#ifndef YY_CtaidParser_COMPATIBILITY
#ifndef YY_USE_CLASS
#define YY_CtaidParser_COMPATIBILITY 1
#else
#define YY_CtaidParser_COMPATIBILITY 0
#endif
#endif
#if YY_CtaidParser_COMPATIBILITY != 0
/* backward compatibility */
#ifdef YYLTYPE
#ifndef YY_CtaidParser_LTYPE
#define YY_CtaidParser_LTYPE YYLTYPE
/* WARNING obsolete !!! user defined YYLTYPE not reported into generated header */
/* use %define LTYPE */
#endif
#endif
/*#ifdef YYSTYPE*/
#ifndef YY_CtaidParser_STYPE
#define YY_CtaidParser_STYPE YYSTYPE
/* WARNING obsolete !!! user defined YYSTYPE not reported into generated header */
/* use %define STYPE */
#endif
/*#endif*/
#ifdef YYDEBUG
#ifndef YY_CtaidParser_DEBUG
#define YY_CtaidParser_DEBUG YYDEBUG
/* WARNING obsolete !!! user defined YYDEBUG not reported into generated header */
/* use %define DEBUG */
#endif
#endif
/* use goto to be compatible */
#ifndef YY_CtaidParser_USE_GOTO
#define YY_CtaidParser_USE_GOTO 1
#endif
#endif
/* use no goto to be clean in C++ */
#ifndef YY_CtaidParser_USE_GOTO
#define YY_CtaidParser_USE_GOTO 0
#endif
#ifndef YY_CtaidParser_PURE
#line 65 "/usr/share/bison++/bison.h"
#line 65 "/usr/share/bison++/bison.h"
/* YY_CtaidParser_PURE */
#endif
#line 68 "/usr/share/bison++/bison.h"
#line 68 "/usr/share/bison++/bison.h"
/* prefix */
#ifndef YY_CtaidParser_DEBUG
#line 71 "/usr/share/bison++/bison.h"
#line 71 "/usr/share/bison++/bison.h"
/* YY_CtaidParser_DEBUG */
#endif
#ifndef YY_CtaidParser_LSP_NEEDED
#line 75 "/usr/share/bison++/bison.h"
#line 75 "/usr/share/bison++/bison.h"
/* YY_CtaidParser_LSP_NEEDED*/
#endif
/* DEFAULT LTYPE*/
#ifdef YY_CtaidParser_LSP_NEEDED
#ifndef YY_CtaidParser_LTYPE
#ifndef BISON_YYLTYPE_ISDECLARED
#define BISON_YYLTYPE_ISDECLARED
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;
#endif
#define YY_CtaidParser_LTYPE yyltype
#endif
#endif
/* DEFAULT STYPE*/
#ifndef YY_CtaidParser_STYPE
#define YY_CtaidParser_STYPE int
#endif
/* DEFAULT MISCELANEOUS */
#ifndef YY_CtaidParser_PARSE
#define YY_CtaidParser_PARSE yyparse
#endif
#ifndef YY_CtaidParser_LEX
#define YY_CtaidParser_LEX yylex
#endif
#ifndef YY_CtaidParser_LVAL
#define YY_CtaidParser_LVAL yylval
#endif
#ifndef YY_CtaidParser_LLOC
#define YY_CtaidParser_LLOC yylloc
#endif
#ifndef YY_CtaidParser_CHAR
#define YY_CtaidParser_CHAR yychar
#endif
#ifndef YY_CtaidParser_NERRS
#define YY_CtaidParser_NERRS yynerrs
#endif
#ifndef YY_CtaidParser_DEBUG_FLAG
#define YY_CtaidParser_DEBUG_FLAG yydebug
#endif
#ifndef YY_CtaidParser_ERROR
#define YY_CtaidParser_ERROR yyerror
#endif
#ifndef YY_CtaidParser_PARSE_PARAM
#ifndef __STDC__
#ifndef __cplusplus
#ifndef YY_USE_CLASS
#define YY_CtaidParser_PARSE_PARAM
#ifndef YY_CtaidParser_PARSE_PARAM_DEF
#define YY_CtaidParser_PARSE_PARAM_DEF
#endif
#endif
#endif
#endif
#ifndef YY_CtaidParser_PARSE_PARAM
#define YY_CtaidParser_PARSE_PARAM void
#endif
#endif
/* TOKEN C */
#ifndef YY_USE_CLASS
#ifndef YY_CtaidParser_PURE
#ifndef yylval
extern YY_CtaidParser_STYPE YY_CtaidParser_LVAL;
#else
#if yylval != YY_CtaidParser_LVAL
extern YY_CtaidParser_STYPE YY_CtaidParser_LVAL;
#else
#warning "Namespace conflict, disabling some functionality (bison++ only)"
#endif
#endif
#endif
#line 169 "/usr/share/bison++/bison.h"
#define IDENTIFIER 258
#define NEG_IDENTI 259
#define NUMBER 260
#define ACT 261
#define FLU 262
#define DEF 263
#define CAUS 264
#define IF 265
#define TRIG 266
#define ALLOW 267
#define INHIB 268
#define NCONC 269
#define AT 270
#define OC_AT 271
#define EXP 272
#define PLAN 273
#define PRED 274
#define COMMA 275
#define DOT 276
#line 169 "/usr/share/bison++/bison.h"
/* #defines token */
/* after #define tokens, before const tokens S5*/
#else
#ifndef YY_CtaidParser_CLASS
#define YY_CtaidParser_CLASS CtaidParser
#endif
#ifndef YY_CtaidParser_INHERIT
#define YY_CtaidParser_INHERIT
#endif
#ifndef YY_CtaidParser_MEMBERS
#define YY_CtaidParser_MEMBERS
#endif
#ifndef YY_CtaidParser_LEX_BODY
#define YY_CtaidParser_LEX_BODY
#endif
#ifndef YY_CtaidParser_ERROR_BODY
#define YY_CtaidParser_ERROR_BODY
#endif
#ifndef YY_CtaidParser_CONSTRUCTOR_PARAM
#define YY_CtaidParser_CONSTRUCTOR_PARAM
#endif
/* choose between enum and const */
#ifndef YY_CtaidParser_USE_CONST_TOKEN
#define YY_CtaidParser_USE_CONST_TOKEN 0
/* yes enum is more compatible with flex, */
/* so by default we use it */
#endif
#if YY_CtaidParser_USE_CONST_TOKEN != 0
#ifndef YY_CtaidParser_ENUM_TOKEN
#define YY_CtaidParser_ENUM_TOKEN yy_CtaidParser_enum_token
#endif
#endif
class YY_CtaidParser_CLASS YY_CtaidParser_INHERIT
{
public:
#if YY_CtaidParser_USE_CONST_TOKEN != 0
/* static const int token ... */
#line 212 "/usr/share/bison++/bison.h"
static const int IDENTIFIER;
static const int NEG_IDENTI;
static const int NUMBER;
static const int ACT;
static const int FLU;
static const int DEF;
static const int CAUS;
static const int IF;
static const int TRIG;
static const int ALLOW;
static const int INHIB;
static const int NCONC;
static const int AT;
static const int OC_AT;
static const int EXP;
static const int PLAN;
static const int PRED;
static const int COMMA;
static const int DOT;
#line 212 "/usr/share/bison++/bison.h"
/* decl const */
#else
enum YY_CtaidParser_ENUM_TOKEN { YY_CtaidParser_NULL_TOKEN=0
#line 215 "/usr/share/bison++/bison.h"
,IDENTIFIER=258
,NEG_IDENTI=259
,NUMBER=260
,ACT=261
,FLU=262
,DEF=263
,CAUS=264
,IF=265
,TRIG=266
,ALLOW=267
,INHIB=268
,NCONC=269
,AT=270
,OC_AT=271
,EXP=272
,PLAN=273
,PRED=274
,COMMA=275
,DOT=276
#line 215 "/usr/share/bison++/bison.h"
/* enum token */
}; /* end of enum declaration */
#endif
public:
int YY_CtaidParser_PARSE(YY_CtaidParser_PARSE_PARAM);
virtual void YY_CtaidParser_ERROR(char *msg) YY_CtaidParser_ERROR_BODY;
#ifdef YY_CtaidParser_PURE
#ifdef YY_CtaidParser_LSP_NEEDED
virtual int YY_CtaidParser_LEX(YY_CtaidParser_STYPE *YY_CtaidParser_LVAL,YY_CtaidParser_LTYPE *YY_CtaidParser_LLOC) YY_CtaidParser_LEX_BODY;
#else
virtual int YY_CtaidParser_LEX(YY_CtaidParser_STYPE *YY_CtaidParser_LVAL) YY_CtaidParser_LEX_BODY;
#endif
#else
virtual int YY_CtaidParser_LEX() YY_CtaidParser_LEX_BODY;
YY_CtaidParser_STYPE YY_CtaidParser_LVAL;
#ifdef YY_CtaidParser_LSP_NEEDED
YY_CtaidParser_LTYPE YY_CtaidParser_LLOC;
#endif
int YY_CtaidParser_NERRS;
int YY_CtaidParser_CHAR;
#endif
#if YY_CtaidParser_DEBUG != 0
public:
int YY_CtaidParser_DEBUG_FLAG; /* nonzero means print parse trace */
#endif
public:
YY_CtaidParser_CLASS(YY_CtaidParser_CONSTRUCTOR_PARAM);
public:
YY_CtaidParser_MEMBERS
};
/* other declare folow */
#endif
#if YY_CtaidParser_COMPATIBILITY != 0
/* backward compatibility */
/* Removed due to bison problems
/#ifndef YYSTYPE
/ #define YYSTYPE YY_CtaidParser_STYPE
/#endif*/
#ifndef YYLTYPE
#define YYLTYPE YY_CtaidParser_LTYPE
#endif
#ifndef YYDEBUG
#ifdef YY_CtaidParser_DEBUG
#define YYDEBUG YY_CtaidParser_DEBUG
#endif
#endif
#endif
/* END */
#line 267 "/usr/share/bison++/bison.h"
#endif
coala-1.0.1_src/src/lib/c_taid/parser.cpp 000644 001750 001750 00000147026 11477164507 020771 0 ustar 00tovok7 tovok7 000000 000000 #define YY_CtaidParser_h_included
#define YY_USE_CLASS
/* A Bison++ parser, made from /home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y */
/* with Bison++ version bison++ Version 1.21.9-1, adapted from GNU bison by coetmeur@icdc.fr
Maintained by Magnus Ekdahl
*/
#define YY_USE_CLASS
#line 1 "/usr/share/bison++/bison.cc"
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
As a special exception, when this file is copied by Bison++ into a
Bison++ output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison, and has been in Bison++ since 1.21.9.
*/
/* HEADER SECTION */
#if defined( _MSDOS ) || defined(MSDOS) || defined(__MSDOS__)
#define __MSDOS_AND_ALIKE
#endif
#if defined(_WINDOWS) && defined(_MSC_VER)
#define __HAVE_NO_ALLOCA
#define __MSDOS_AND_ALIKE
#endif
#ifndef alloca
#if defined( __GNUC__)
#define alloca __builtin_alloca
#elif (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include
#elif defined (__MSDOS_AND_ALIKE)
#include
#ifndef __TURBOC__
/* MS C runtime lib */
#define alloca _alloca
#endif
#elif defined(_AIX)
/* pragma must be put before any C/C++ instruction !! */
#pragma alloca
#include
#elif defined(__hpux)
#ifdef __cplusplus
extern "C" {
void *alloca (unsigned int);
};
#else /* not __cplusplus */
void *alloca ();
#endif /* not __cplusplus */
#endif /* not _AIX not MSDOS, or __TURBOC__ or _AIX, not sparc. */
#endif /* alloca not defined. */
#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#endif
#endif
#ifdef __cplusplus
#ifndef YY_USE_CLASS
/*#warning "For C++ its recomended to use bison++, otherwise classes won't be generated"*/
#endif
#else
#ifndef __STDC__
#define const
#endif
#ifdef YY_USE_CLASS
#error "This is a C++ header generated by bison++, please use a C++ compiler!"
#endif
#endif
#include
#define YYBISON 1
#line 88 "/usr/share/bison++/bison.cc"
#define YY_CtaidParser_LSP_NEEDED
#define YY_CtaidParser_ERROR_BODY = 0
#define YY_CtaidParser_LEX_BODY = 0
#define YY_CtaidParser_CONSTRUCTOR_PARAM Coala::CompilerOptions* options
#define YY_CtaidParser_CONSTRUCTOR_CODE {debug=options->getDebug(); neg=options->getFakeClassicalNegation()?"neg_":"-";}
#define YY_CtaidParser_MEMBERS void postProcessing(); bool cout_neg(bool); int debug; string neg; virtual ~CtaidParser(){}\
private:\
typedef set > StringSet;\
StringSet all_fluents;\
StringSet default_fluents;\
StringSet inertial_fluents;\
StringSet all_actions;\
StringSet triggered_actions;\
StringSet allowed_actions;\
StringSet exogenous_actions;
#line 44 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
#include
#include
#include
#include
#include
#include
#include "../options.h"
using namespace std;
//using namespace C_taid;
#line 58 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
typedef list > ListPair;
int latest_obs = 0;
#line 64 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
typedef union {
int number;
const string *istring;
list > *ilist;
} yy_CtaidParser_stype;
#define YY_CtaidParser_STYPE yy_CtaidParser_stype
#line 88 "/usr/share/bison++/bison.cc"
/* %{ and %header{ and %union, during decl */
#define YY_CtaidParser_BISON 1
#ifndef YY_CtaidParser_COMPATIBILITY
#ifndef YY_USE_CLASS
#define YY_CtaidParser_COMPATIBILITY 1
#else
#define YY_CtaidParser_COMPATIBILITY 0
#endif
#endif
#if YY_CtaidParser_COMPATIBILITY != 0
/* backward compatibility */
#ifdef YYLTYPE
#ifndef YY_CtaidParser_LTYPE
#define YY_CtaidParser_LTYPE YYLTYPE
#endif
#endif
/* Testing alternative bison solution
/#ifdef YYSTYPE*/
#ifndef YY_CtaidParser_STYPE
#define YY_CtaidParser_STYPE YYSTYPE
#endif
/*#endif*/
#ifdef YYDEBUG
#ifndef YY_CtaidParser_DEBUG
#define YY_CtaidParser_DEBUG YYDEBUG
#endif
#endif
/* use goto to be compatible */
#ifndef YY_CtaidParser_USE_GOTO
#define YY_CtaidParser_USE_GOTO 1
#endif
#endif
/* use no goto to be clean in C++ */
#ifndef YY_CtaidParser_USE_GOTO
#define YY_CtaidParser_USE_GOTO 0
#endif
#ifndef YY_CtaidParser_PURE
#line 130 "/usr/share/bison++/bison.cc"
#line 130 "/usr/share/bison++/bison.cc"
/* YY_CtaidParser_PURE */
#endif
/* section apres lecture def, avant lecture grammaire S2 */
#line 134 "/usr/share/bison++/bison.cc"
#line 134 "/usr/share/bison++/bison.cc"
/* prefix */
#ifndef YY_CtaidParser_DEBUG
#line 136 "/usr/share/bison++/bison.cc"
#line 136 "/usr/share/bison++/bison.cc"
/* YY_CtaidParser_DEBUG */
#endif
#ifndef YY_CtaidParser_LSP_NEEDED
#line 141 "/usr/share/bison++/bison.cc"
#line 141 "/usr/share/bison++/bison.cc"
/* YY_CtaidParser_LSP_NEEDED*/
#endif
/* DEFAULT LTYPE*/
#ifdef YY_CtaidParser_LSP_NEEDED
#ifndef YY_CtaidParser_LTYPE
#ifndef BISON_YYLTYPE_ISDECLARED
#define BISON_YYLTYPE_ISDECLARED
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;
#endif
#define YY_CtaidParser_LTYPE yyltype
#endif
#endif
/* DEFAULT STYPE*/
/* We used to use `unsigned long' as YY_CtaidParser_STYPE on MSDOS,
but it seems better to be consistent.
Most programs should declare their own type anyway. */
#ifndef YY_CtaidParser_STYPE
#define YY_CtaidParser_STYPE int
#endif
/* DEFAULT MISCELANEOUS */
#ifndef YY_CtaidParser_PARSE
#define YY_CtaidParser_PARSE yyparse
#endif
#ifndef YY_CtaidParser_LEX
#define YY_CtaidParser_LEX yylex
#endif
#ifndef YY_CtaidParser_LVAL
#define YY_CtaidParser_LVAL yylval
#endif
#ifndef YY_CtaidParser_LLOC
#define YY_CtaidParser_LLOC yylloc
#endif
#ifndef YY_CtaidParser_CHAR
#define YY_CtaidParser_CHAR yychar
#endif
#ifndef YY_CtaidParser_NERRS
#define YY_CtaidParser_NERRS yynerrs
#endif
#ifndef YY_CtaidParser_DEBUG_FLAG
#define YY_CtaidParser_DEBUG_FLAG yydebug
#endif
#ifndef YY_CtaidParser_ERROR
#define YY_CtaidParser_ERROR yyerror
#endif
#ifndef YY_CtaidParser_PARSE_PARAM
#ifndef YY_USE_CLASS
#ifdef YYPARSE_PARAM
#define YY_CtaidParser_PARSE_PARAM void* YYPARSE_PARAM
#else
#ifndef __STDC__
#ifndef __cplusplus
#define YY_CtaidParser_PARSE_PARAM
#endif
#endif
#endif
#endif
#ifndef YY_CtaidParser_PARSE_PARAM
#define YY_CtaidParser_PARSE_PARAM void
#endif
#endif
#if YY_CtaidParser_COMPATIBILITY != 0
/* backward compatibility */
#ifdef YY_CtaidParser_LTYPE
#ifndef YYLTYPE
#define YYLTYPE YY_CtaidParser_LTYPE
#else
/* WARNING obsolete !!! user defined YYLTYPE not reported into generated header */
#endif
#endif
/* Removed due to bison compabilityproblems
/#ifndef YYSTYPE
/#define YYSTYPE YY_CtaidParser_STYPE
/#else*/
/* WARNING obsolete !!! user defined YYSTYPE not reported into generated header */
/*#endif*/
#ifdef YY_CtaidParser_PURE
# ifndef YYPURE
# define YYPURE YY_CtaidParser_PURE
# endif
#endif
#ifdef YY_CtaidParser_DEBUG
# ifndef YYDEBUG
# define YYDEBUG YY_CtaidParser_DEBUG
# endif
#endif
#ifndef YY_CtaidParser_ERROR_VERBOSE
#ifdef YYERROR_VERBOSE
#define YY_CtaidParser_ERROR_VERBOSE YYERROR_VERBOSE
#endif
#endif
#ifndef YY_CtaidParser_LSP_NEEDED
# ifdef YYLSP_NEEDED
# define YY_CtaidParser_LSP_NEEDED YYLSP_NEEDED
# endif
#endif
#endif
#ifndef YY_USE_CLASS
/* TOKEN C */
#line 263 "/usr/share/bison++/bison.cc"
#define IDENTIFIER 258
#define NEG_IDENTI 259
#define NUMBER 260
#define ACT 261
#define FLU 262
#define DEF 263
#define CAUS 264
#define IF 265
#define TRIG 266
#define ALLOW 267
#define INHIB 268
#define NCONC 269
#define AT 270
#define OC_AT 271
#define EXP 272
#define PLAN 273
#define PRED 274
#define COMMA 275
#define DOT 276
#line 263 "/usr/share/bison++/bison.cc"
/* #defines tokens */
#else
/* CLASS */
#ifndef YY_CtaidParser_CLASS
#define YY_CtaidParser_CLASS CtaidParser
#endif
#ifndef YY_CtaidParser_INHERIT
#define YY_CtaidParser_INHERIT
#endif
#ifndef YY_CtaidParser_MEMBERS
#define YY_CtaidParser_MEMBERS
#endif
#ifndef YY_CtaidParser_LEX_BODY
#define YY_CtaidParser_LEX_BODY
#endif
#ifndef YY_CtaidParser_ERROR_BODY
#define YY_CtaidParser_ERROR_BODY
#endif
#ifndef YY_CtaidParser_CONSTRUCTOR_PARAM
#define YY_CtaidParser_CONSTRUCTOR_PARAM
#endif
#ifndef YY_CtaidParser_CONSTRUCTOR_CODE
#define YY_CtaidParser_CONSTRUCTOR_CODE
#endif
#ifndef YY_CtaidParser_CONSTRUCTOR_INIT
#define YY_CtaidParser_CONSTRUCTOR_INIT
#endif
/* choose between enum and const */
#ifndef YY_CtaidParser_USE_CONST_TOKEN
#define YY_CtaidParser_USE_CONST_TOKEN 0
/* yes enum is more compatible with flex, */
/* so by default we use it */
#endif
#if YY_CtaidParser_USE_CONST_TOKEN != 0
#ifndef YY_CtaidParser_ENUM_TOKEN
#define YY_CtaidParser_ENUM_TOKEN yy_CtaidParser_enum_token
#endif
#endif
class YY_CtaidParser_CLASS YY_CtaidParser_INHERIT
{
public:
#if YY_CtaidParser_USE_CONST_TOKEN != 0
/* static const int token ... */
#line 307 "/usr/share/bison++/bison.cc"
static const int IDENTIFIER;
static const int NEG_IDENTI;
static const int NUMBER;
static const int ACT;
static const int FLU;
static const int DEF;
static const int CAUS;
static const int IF;
static const int TRIG;
static const int ALLOW;
static const int INHIB;
static const int NCONC;
static const int AT;
static const int OC_AT;
static const int EXP;
static const int PLAN;
static const int PRED;
static const int COMMA;
static const int DOT;
#line 307 "/usr/share/bison++/bison.cc"
/* decl const */
#else
enum YY_CtaidParser_ENUM_TOKEN { YY_CtaidParser_NULL_TOKEN=0
#line 310 "/usr/share/bison++/bison.cc"
,IDENTIFIER=258
,NEG_IDENTI=259
,NUMBER=260
,ACT=261
,FLU=262
,DEF=263
,CAUS=264
,IF=265
,TRIG=266
,ALLOW=267
,INHIB=268
,NCONC=269
,AT=270
,OC_AT=271
,EXP=272
,PLAN=273
,PRED=274
,COMMA=275
,DOT=276
#line 310 "/usr/share/bison++/bison.cc"
/* enum token */
}; /* end of enum declaration */
#endif
public:
int YY_CtaidParser_PARSE (YY_CtaidParser_PARSE_PARAM);
virtual void YY_CtaidParser_ERROR(char *msg) YY_CtaidParser_ERROR_BODY;
#ifdef YY_CtaidParser_PURE
#ifdef YY_CtaidParser_LSP_NEEDED
virtual int YY_CtaidParser_LEX (YY_CtaidParser_STYPE *YY_CtaidParser_LVAL,YY_CtaidParser_LTYPE *YY_CtaidParser_LLOC) YY_CtaidParser_LEX_BODY;
#else
virtual int YY_CtaidParser_LEX (YY_CtaidParser_STYPE *YY_CtaidParser_LVAL) YY_CtaidParser_LEX_BODY;
#endif
#else
virtual int YY_CtaidParser_LEX() YY_CtaidParser_LEX_BODY;
YY_CtaidParser_STYPE YY_CtaidParser_LVAL;
#ifdef YY_CtaidParser_LSP_NEEDED
YY_CtaidParser_LTYPE YY_CtaidParser_LLOC;
#endif
int YY_CtaidParser_NERRS;
int YY_CtaidParser_CHAR;
#endif
#if YY_CtaidParser_DEBUG != 0
int YY_CtaidParser_DEBUG_FLAG; /* nonzero means print parse trace */
#endif
public:
YY_CtaidParser_CLASS(YY_CtaidParser_CONSTRUCTOR_PARAM);
public:
YY_CtaidParser_MEMBERS
};
/* other declare folow */
#if YY_CtaidParser_USE_CONST_TOKEN != 0
#line 341 "/usr/share/bison++/bison.cc"
const int YY_CtaidParser_CLASS::IDENTIFIER=258;
const int YY_CtaidParser_CLASS::NEG_IDENTI=259;
const int YY_CtaidParser_CLASS::NUMBER=260;
const int YY_CtaidParser_CLASS::ACT=261;
const int YY_CtaidParser_CLASS::FLU=262;
const int YY_CtaidParser_CLASS::DEF=263;
const int YY_CtaidParser_CLASS::CAUS=264;
const int YY_CtaidParser_CLASS::IF=265;
const int YY_CtaidParser_CLASS::TRIG=266;
const int YY_CtaidParser_CLASS::ALLOW=267;
const int YY_CtaidParser_CLASS::INHIB=268;
const int YY_CtaidParser_CLASS::NCONC=269;
const int YY_CtaidParser_CLASS::AT=270;
const int YY_CtaidParser_CLASS::OC_AT=271;
const int YY_CtaidParser_CLASS::EXP=272;
const int YY_CtaidParser_CLASS::PLAN=273;
const int YY_CtaidParser_CLASS::PRED=274;
const int YY_CtaidParser_CLASS::COMMA=275;
const int YY_CtaidParser_CLASS::DOT=276;
#line 341 "/usr/share/bison++/bison.cc"
/* const YY_CtaidParser_CLASS::token */
#endif
/*apres const */
YY_CtaidParser_CLASS::YY_CtaidParser_CLASS(YY_CtaidParser_CONSTRUCTOR_PARAM) YY_CtaidParser_CONSTRUCTOR_INIT
{
#if YY_CtaidParser_DEBUG != 0
YY_CtaidParser_DEBUG_FLAG=0;
#endif
YY_CtaidParser_CONSTRUCTOR_CODE;
};
#endif
#line 352 "/usr/share/bison++/bison.cc"
#define YYFINAL 59
#define YYFLAG -32768
#define YYNTBASE 22
#define YYTRANSLATE(x) ((unsigned)(x) <= 276 ? yytranslate[x] : 43)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21
};
#if YY_CtaidParser_DEBUG != 0
static const short yyprhs[] = { 0,
0, 1, 5, 7, 9, 11, 13, 15, 17, 19,
21, 23, 25, 27, 29, 31, 33, 35, 37, 39,
41, 44, 47, 50, 56, 60, 64, 68, 72, 76,
79, 83, 87, 89, 92, 95, 97, 99, 103
};
static const short yyrhs[] = { -1,
22, 23, 21, 0, 24, 0, 25, 0, 26, 0,
27, 0, 32, 0, 31, 0, 33, 0, 34, 0,
35, 0, 36, 0, 37, 0, 38, 0, 39, 0,
40, 0, 41, 0, 28, 0, 29, 0, 30, 0,
6, 42, 0, 7, 42, 0, 8, 42, 0, 3,
9, 42, 10, 42, 0, 3, 9, 42, 0, 42,
10, 42, 0, 42, 11, 3, 0, 42, 12, 3,
0, 42, 13, 3, 0, 14, 42, 0, 42, 15,
5, 0, 42, 16, 5, 0, 17, 0, 18, 42,
0, 19, 42, 0, 3, 0, 4, 0, 42, 20,
3, 0, 42, 20, 4, 0
};
#endif
#if (YY_CtaidParser_DEBUG != 0) || defined(YY_CtaidParser_ERROR_VERBOSE)
static const short yyrline[] = { 0,
96, 96, 98, 98, 98, 100, 100, 100, 100, 100,
100, 100, 102, 102, 104, 104, 104, 106, 106, 106,
109, 124, 132, 157, 175, 185, 201, 223, 242, 256,
269, 289, 311, 330, 374, 403, 408, 413, 418
};
static const char * const yytname[] = { "$","error","$illegal.","IDENTIFIER",
"NEG_IDENTI","NUMBER","ACT","FLU","DEF","CAUS","IF","TRIG","ALLOW","INHIB","NCONC",
"AT","OC_AT","EXP","PLAN","PRED","COMMA","DOT","program","rule","desc_rule",
"obs_rule","query_rule","fact","act_fact","flu_fact","def_fact","dyn_rule","static_rule",
"trig_rule","allow_rule","inhib_rule","nconc_rule","flu_obs","act_obs","exp_rule",
"plan_rule","pred_rule","fluent_list",""
};
#endif
static const short yyr1[] = { 0,
22, 22, 23, 23, 23, 24, 24, 24, 24, 24,
24, 24, 25, 25, 26, 26, 26, 27, 27, 27,
28, 29, 30, 31, 31, 32, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 42, 42, 42
};
static const short yyr2[] = { 0,
0, 3, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 5, 3, 3, 3, 3, 3, 2,
3, 3, 1, 2, 2, 1, 1, 3, 3
};
static const short yydefact[] = { 1,
0, 36, 37, 0, 0, 0, 0, 33, 0, 0,
0, 3, 4, 5, 6, 18, 19, 20, 8, 7,
9, 10, 11, 12, 13, 14, 15, 16, 17, 0,
0, 36, 21, 22, 23, 30, 34, 35, 2, 0,
0, 0, 0, 0, 0, 0, 25, 26, 27, 28,
29, 31, 32, 38, 39, 0, 24, 0, 0
};
static const short yydefgoto[] = { 1,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30
};
static const short yypact[] = {-32768,
4, 8,-32768, 10, 10, 10, 10,-32768, 10, 10,
3,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 18,
10,-32768, 0, 0, 0, 0, 0, 0,-32768, 10,
22, 23, 29, 30, 32, 12, -1, 0,-32768,-32768,
-32768,-32768,-32768,-32768,-32768, 10, 0, 39,-32768
};
static const short yypgoto[] = {-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -4
};
#define YYLAST 52
static const short yytable[] = { 33,
34, 35, 36, 58, 37, 38, 2, 3, 56, 4,
5, 6, 32, 3, 54, 55, 31, 7, 46, 46,
8, 9, 10, 39, 49, 50, 47, 40, 41, 42,
43, 51, 44, 45, 52, 48, 53, 46, 59, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 57
};
static const short yycheck[] = { 4,
5, 6, 7, 0, 9, 10, 3, 4, 10, 6,
7, 8, 3, 4, 3, 4, 9, 14, 20, 20,
17, 18, 19, 21, 3, 3, 31, 10, 11, 12,
13, 3, 15, 16, 5, 40, 5, 20, 0, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 56
};
#line 352 "/usr/share/bison++/bison.cc"
/* fattrs + tables */
/* parser code folow */
/* This is the parser code that is written into each bison parser
when the %semantic_parser declaration is not specified in the grammar.
It was written by Richard Stallman by simplifying the hairy parser
used when %semantic_parser is specified. */
/* Note: dollar marks section change
the next is replaced by the list of actions, each action
as one case of the switch. */
#if YY_CtaidParser_USE_GOTO != 0
/*
SUPRESSION OF GOTO : on some C++ compiler (sun c++)
the goto is strictly forbidden if any constructor/destructor
is used in the whole function (very stupid isn't it ?)
so goto are to be replaced with a 'while/switch/case construct'
here are the macro to keep some apparent compatibility
*/
#define YYGOTO(lb) {yy_gotostate=lb;continue;}
#define YYBEGINGOTO enum yy_labels yy_gotostate=yygotostart; \
for(;;) switch(yy_gotostate) { case yygotostart: {
#define YYLABEL(lb) } case lb: {
#define YYENDGOTO } }
#define YYBEGINDECLARELABEL enum yy_labels {yygotostart
#define YYDECLARELABEL(lb) ,lb
#define YYENDDECLARELABEL };
#else
/* macro to keep goto */
#define YYGOTO(lb) goto lb
#define YYBEGINGOTO
#define YYLABEL(lb) lb:
#define YYENDGOTO
#define YYBEGINDECLARELABEL
#define YYDECLARELABEL(lb)
#define YYENDDECLARELABEL
#endif
/* LABEL DECLARATION */
YYBEGINDECLARELABEL
YYDECLARELABEL(yynewstate)
YYDECLARELABEL(yybackup)
/* YYDECLARELABEL(yyresume) */
YYDECLARELABEL(yydefault)
YYDECLARELABEL(yyreduce)
YYDECLARELABEL(yyerrlab) /* here on detecting error */
YYDECLARELABEL(yyerrlab1) /* here on error raised explicitly by an action */
YYDECLARELABEL(yyerrdefault) /* current state does not do anything special for the error token. */
YYDECLARELABEL(yyerrpop) /* pop the current state because it cannot handle the error token */
YYDECLARELABEL(yyerrhandle)
YYENDDECLARELABEL
/* ALLOCA SIMULATION */
/* __HAVE_NO_ALLOCA */
#ifdef __HAVE_NO_ALLOCA
int __alloca_free_ptr(char *ptr,char *ref)
{if(ptr!=ref) free(ptr);
return 0;}
#define __ALLOCA_alloca(size) malloc(size)
#define __ALLOCA_free(ptr,ref) __alloca_free_ptr((char *)ptr,(char *)ref)
#ifdef YY_CtaidParser_LSP_NEEDED
#define __ALLOCA_return(num) \
do { return( __ALLOCA_free(yyss,yyssa)+\
__ALLOCA_free(yyvs,yyvsa)+\
__ALLOCA_free(yyls,yylsa)+\
(num)); } while(0)
#else
#define __ALLOCA_return(num) \
do { return( __ALLOCA_free(yyss,yyssa)+\
__ALLOCA_free(yyvs,yyvsa)+\
(num)); } while(0)
#endif
#else
#define __ALLOCA_return(num) do { return(num); } while(0)
#define __ALLOCA_alloca(size) alloca(size)
#define __ALLOCA_free(ptr,ref)
#endif
/* ENDALLOCA SIMULATION */
#define yyerrok (yyerrstatus = 0)
#define yyclearin (YY_CtaidParser_CHAR = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
#define YYACCEPT __ALLOCA_return(0)
#define YYABORT __ALLOCA_return(1)
#define YYERROR YYGOTO(yyerrlab1)
/* Like YYERROR except do call yyerror.
This remains here temporarily to ease the
transition to the new meaning of YYERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. */
#define YYFAIL YYGOTO(yyerrlab)
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(token, value) \
do \
if (YY_CtaidParser_CHAR == YYEMPTY && yylen == 1) \
{ YY_CtaidParser_CHAR = (token), YY_CtaidParser_LVAL = (value); \
yychar1 = YYTRANSLATE (YY_CtaidParser_CHAR); \
YYPOPSTACK; \
YYGOTO(yybackup); \
} \
else \
{ YY_CtaidParser_ERROR ("syntax error: cannot back up"); YYERROR; } \
while (0)
#define YYTERROR 1
#define YYERRCODE 256
#ifndef YY_CtaidParser_PURE
/* UNPURE */
#define YYLEX YY_CtaidParser_LEX()
#ifndef YY_USE_CLASS
/* If nonreentrant, and not class , generate the variables here */
int YY_CtaidParser_CHAR; /* the lookahead symbol */
YY_CtaidParser_STYPE YY_CtaidParser_LVAL; /* the semantic value of the */
/* lookahead symbol */
int YY_CtaidParser_NERRS; /* number of parse errors so far */
#ifdef YY_CtaidParser_LSP_NEEDED
YY_CtaidParser_LTYPE YY_CtaidParser_LLOC; /* location data for the lookahead */
/* symbol */
#endif
#endif
#else
/* PURE */
#ifdef YY_CtaidParser_LSP_NEEDED
#define YYLEX YY_CtaidParser_LEX(&YY_CtaidParser_LVAL, &YY_CtaidParser_LLOC)
#else
#define YYLEX YY_CtaidParser_LEX(&YY_CtaidParser_LVAL)
#endif
#endif
#ifndef YY_USE_CLASS
#if YY_CtaidParser_DEBUG != 0
int YY_CtaidParser_DEBUG_FLAG; /* nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
from coexisting. */
#endif
#endif
/* YYINITDEPTH indicates the initial size of the parser's stacks */
#ifndef YYINITDEPTH
#define YYINITDEPTH 200
#endif
/* YYMAXDEPTH is the maximum size the stacks can grow to
(effective only if the built-in stack extension method is used). */
#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __yy_bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
#ifdef __cplusplus
static void __yy_bcopy (char *from, char *to, int count)
#else
#ifdef __STDC__
static void __yy_bcopy (char *from, char *to, int count)
#else
static void __yy_bcopy (from, to, count)
char *from;
char *to;
int count;
#endif
#endif
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#endif
int
#ifdef YY_USE_CLASS
YY_CtaidParser_CLASS::
#endif
YY_CtaidParser_PARSE(YY_CtaidParser_PARSE_PARAM)
#ifndef __STDC__
#ifndef __cplusplus
#ifndef YY_USE_CLASS
/* parameter definition without protypes */
YY_CtaidParser_PARSE_PARAM_DEF
#endif
#endif
#endif
{
register int yystate;
register int yyn;
register short *yyssp;
register YY_CtaidParser_STYPE *yyvsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */
int yychar1=0; /* lookahead token as an internal (translated) token number */
short yyssa[YYINITDEPTH]; /* the state stack */
YY_CtaidParser_STYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
short *yyss = yyssa; /* refer to the stacks thru separate pointers */
YY_CtaidParser_STYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
#ifdef YY_CtaidParser_LSP_NEEDED
YY_CtaidParser_LTYPE yylsa[YYINITDEPTH]; /* the location stack */
YY_CtaidParser_LTYPE *yyls = yylsa;
YY_CtaidParser_LTYPE *yylsp;
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
#else
#define YYPOPSTACK (yyvsp--, yyssp--)
#endif
int yystacksize = YYINITDEPTH;
#ifdef YY_CtaidParser_PURE
int YY_CtaidParser_CHAR;
YY_CtaidParser_STYPE YY_CtaidParser_LVAL;
int YY_CtaidParser_NERRS;
#ifdef YY_CtaidParser_LSP_NEEDED
YY_CtaidParser_LTYPE YY_CtaidParser_LLOC;
#endif
#endif
YY_CtaidParser_STYPE yyval; /* the variable used to return */
/* semantic values from the action */
/* routines */
int yylen;
/* start loop, in which YYGOTO may be used. */
YYBEGINGOTO
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Starting parse\n");
#endif
yystate = 0;
yyerrstatus = 0;
YY_CtaidParser_NERRS = 0;
YY_CtaidParser_CHAR = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
yyssp = yyss - 1;
yyvsp = yyvs;
#ifdef YY_CtaidParser_LSP_NEEDED
yylsp = yyls;
#endif
/* Push a new state, which is found in yystate . */
/* In all cases, when you get here, the value and location stacks
have just been pushed. so pushing a state here evens the stacks. */
YYLABEL(yynewstate)
*++yyssp = yystate;
if (yyssp >= yyss + yystacksize - 1)
{
/* Give user a chance to reallocate the stack */
/* Use copies of these so that the &'s don't force the real ones into memory. */
YY_CtaidParser_STYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
#ifdef YY_CtaidParser_LSP_NEEDED
YY_CtaidParser_LTYPE *yyls1 = yyls;
#endif
/* Get the current used size of the three stacks, in elements. */
int size = yyssp - yyss + 1;
#ifdef yyoverflow
/* Each stack pointer address is followed by the size of
the data in use in that stack, in bytes. */
#ifdef YY_CtaidParser_LSP_NEEDED
/* This used to be a conditional around just the two extra args,
but that might be undefined if yyoverflow is a macro. */
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yyls1, size * sizeof (*yylsp),
&yystacksize);
#else
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yystacksize);
#endif
yyss = yyss1; yyvs = yyvs1;
#ifdef YY_CtaidParser_LSP_NEEDED
yyls = yyls1;
#endif
#else /* no yyoverflow */
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
{
YY_CtaidParser_ERROR("parser stack overflow");
__ALLOCA_return(2);
}
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
yyss = (short *) __ALLOCA_alloca (yystacksize * sizeof (*yyssp));
__yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
__ALLOCA_free(yyss1,yyssa);
yyvs = (YY_CtaidParser_STYPE *) __ALLOCA_alloca (yystacksize * sizeof (*yyvsp));
__yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
__ALLOCA_free(yyvs1,yyvsa);
#ifdef YY_CtaidParser_LSP_NEEDED
yyls = (YY_CtaidParser_LTYPE *) __ALLOCA_alloca (yystacksize * sizeof (*yylsp));
__yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
__ALLOCA_free(yyls1,yylsa);
#endif
#endif /* no yyoverflow */
yyssp = yyss + size - 1;
yyvsp = yyvs + size - 1;
#ifdef YY_CtaidParser_LSP_NEEDED
yylsp = yyls + size - 1;
#endif
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif
if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Entering state %d\n", yystate);
#endif
YYGOTO(yybackup);
YYLABEL(yybackup)
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* YYLABEL(yyresume) */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYFLAG)
YYGOTO(yydefault);
/* Not known => get a lookahead token if don't already have one. */
/* yychar is either YYEMPTY or YYEOF
or a valid token in external form. */
if (YY_CtaidParser_CHAR == YYEMPTY)
{
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Reading a token: ");
#endif
YY_CtaidParser_CHAR = YYLEX;
}
/* Convert token to internal form (in yychar1) for indexing tables with */
if (YY_CtaidParser_CHAR <= 0) /* This means end of input. */
{
yychar1 = 0;
YY_CtaidParser_CHAR = YYEOF; /* Don't call YYLEX any more */
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Now at end of input.\n");
#endif
}
else
{
yychar1 = YYTRANSLATE(YY_CtaidParser_CHAR);
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
{
fprintf (stderr, "Next token is %d (%s", YY_CtaidParser_CHAR, yytname[yychar1]);
/* Give the individual parser a way to print the precise meaning
of a token, for further debugging info. */
#ifdef YYPRINT
YYPRINT (stderr, YY_CtaidParser_CHAR, YY_CtaidParser_LVAL);
#endif
fprintf (stderr, ")\n");
}
#endif
}
yyn += yychar1;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
YYGOTO(yydefault);
yyn = yytable[yyn];
/* yyn is what to do for this token type in this state.
Negative => reduce, -yyn is rule number.
Positive => shift, yyn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */
if (yyn < 0)
{
if (yyn == YYFLAG)
YYGOTO(yyerrlab);
yyn = -yyn;
YYGOTO(yyreduce);
}
else if (yyn == 0)
YYGOTO(yyerrlab);
if (yyn == YYFINAL)
YYACCEPT;
/* Shift the lookahead token. */
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Shifting token %d (%s), ", YY_CtaidParser_CHAR, yytname[yychar1]);
#endif
/* Discard the token being shifted unless it is eof. */
if (YY_CtaidParser_CHAR != YYEOF)
YY_CtaidParser_CHAR = YYEMPTY;
*++yyvsp = YY_CtaidParser_LVAL;
#ifdef YY_CtaidParser_LSP_NEEDED
*++yylsp = YY_CtaidParser_LLOC;
#endif
/* count tokens shifted since error; after three, turn off error status. */
if (yyerrstatus) yyerrstatus--;
yystate = yyn;
YYGOTO(yynewstate);
/* Do the default action for the current state. */
YYLABEL(yydefault)
yyn = yydefact[yystate];
if (yyn == 0)
YYGOTO(yyerrlab);
/* Do a reduction. yyn is the number of a rule to reduce with. */
YYLABEL(yyreduce)
yylen = yyr2[yyn];
if (yylen > 0)
yyval = yyvsp[1-yylen]; /* implement default value of the action */
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
{
int i;
fprintf (stderr, "Reducing via rule %d (line %d), ",
yyn, yyrline[yyn]);
/* Print the symbols being reduced, and their result. */
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
fprintf (stderr, "%s ", yytname[yyrhs[i]]);
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif
#line 839 "/usr/share/bison++/bison.cc"
switch (yyn) {
case 21:
#line 109 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{ // not really a fluent_list, but I still use it for actions
for(ListPair::iterator n = yyvsp[0].ilist->begin(); n != yyvsp[0].ilist->end(); ++n) {
if(neg == "neg_") {
cout << ":- action_"+n->first+"(T), neg_action_"+n->first+"(T), time(T).\n";
// hides every neg_action
if(debug < 2) cout << "#hide neg_action_"+n->first+"(T).\n";
}
all_actions.insert(n->first);
}
delete yyvsp[0].ilist;
;
break;}
case 22:
#line 124 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
for(ListPair::iterator n = yyvsp[0].ilist->begin(); n != yyvsp[0].ilist->end(); ++n) {
all_fluents.insert(n->first);
}
delete yyvsp[0].ilist;
;
break;}
case 23:
#line 132 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
for(ListPair::iterator n = yyvsp[0].ilist->begin(); n != yyvsp[0].ilist->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T) :- not ";
cout_neg(!n->second);
cout << "fluent_"+n->first+"(T), time(T).\n";
if(neg == "neg_") {
// relationship between fluent and its negation
cout << ":- fluent_"+n->first+"(T), neg_fluent_"+n->first+"(T), time(T).\n";
// hides neg_fluent for every default fluent
if(debug < 2) {
cout << "#hide neg_fluent_"+n->first+"(T).\n";
}
}
if(debug < 1) cout << "#hide fluent_"+n->first+"(T).\n";
default_fluents.insert(n->first);
}
delete yyvsp[0].ilist;
;
break;}
case 24:
#line 157 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
for(ListPair::iterator n = yyvsp[-2].ilist->begin(); n != yyvsp[-2].ilist->end(); ++n) {
// f_1,...,f_n
cout_neg(n->second);
cout << "fluent_"+n->first+"(T+1) :- action_"+*yyvsp[-4].istring+"(T), ";
for(ListPair::iterator m = yyvsp[0].ilist->begin(); m != yyvsp[0].ilist->end(); ++m) {
// g_1,...,g_m
cout_neg(m->second);
cout << "fluent_"+m->first+"(T), ";
}
cout << "time(T; T+1).\n";
}
delete yyvsp[-4].istring;
delete yyvsp[-2].ilist;
delete yyvsp[0].ilist;
;
break;}
case 25:
#line 175 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
for(ListPair::iterator n = yyvsp[0].ilist->begin(); n != yyvsp[0].ilist->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T+1) :- action_"+*yyvsp[-2].istring+"(T), time(T; T+1).\n";
}
delete yyvsp[-2].istring;
delete yyvsp[0].ilist;
;
break;}
case 26:
#line 185 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
for(ListPair::iterator n = yyvsp[-2].ilist->begin(); n != yyvsp[-2].ilist->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T) :- ";
for(ListPair::iterator m = yyvsp[0].ilist->begin(); m != yyvsp[0].ilist->end(); ++m) {
cout_neg(m->second);
cout << "fluent_"+m->first+"(T), ";
}
cout << "time(T).\n";
}
delete yyvsp[-2].ilist;
delete yyvsp[0].ilist;
;
break;}
case 27:
#line 201 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
cout << "trig_action_"+*yyvsp[0].istring+"(T) :- ";
for(ListPair::iterator n = yyvsp[-2].ilist->begin(); n != yyvsp[-2].ilist->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T), ";
}
cout << "time(T).\n";
// trigger only when not inhibited
cout << "action_"+*yyvsp[0].istring+"(T) :- trig_action_"+*yyvsp[0].istring+"(T), not "+neg+"action_"+*yyvsp[0].istring+"(T), time(T).\n";
// hides every trig_action
if(debug < 2) cout << "#hide trig_action_"+*yyvsp[0].istring+"(T).\n";
triggered_actions.insert(*yyvsp[0].istring);
delete yyvsp[-2].ilist;
delete yyvsp[0].istring;
;
break;}
case 28:
#line 223 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
cout << "allow_action_"+*yyvsp[0].istring+"(T) :- ";
for(ListPair::iterator n = yyvsp[-2].ilist->begin(); n != yyvsp[-2].ilist->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T), ";
}
cout << "time(T).\n";
// hides allow_action for every allowed action
if(debug < 2) cout << "#hide allow_action_"+*yyvsp[0].istring+"(T).\n";
allowed_actions.insert(*yyvsp[0].istring);
delete yyvsp[-2].ilist;
delete yyvsp[0].istring;
;
break;}
case 29:
#line 242 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
cout << neg+"action_"+*yyvsp[0].istring+"(T) :- ";
for(ListPair::iterator n = yyvsp[-2].ilist->begin(); n != yyvsp[-2].ilist->end(); ++n) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(T), ";
}
cout << "time(T).\n";
delete yyvsp[-2].ilist;
delete yyvsp[0].istring;
;
break;}
case 30:
#line 256 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{ // not really a fluent_list, but I still use it for actions
cout << ":- 2 {";
for(ListPair::iterator n = yyvsp[0].ilist->begin(); n != yyvsp[0].ilist->end(); ++n) {
if(n != yyvsp[0].ilist->begin()) cout << ", ";
cout << "action_"+n->first+"(T)";
}
cout << "}, time(T).\n";
delete yyvsp[0].ilist;
;
break;}
case 31:
#line 269 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
for(ListPair::iterator n = yyvsp[-2].ilist->begin(); n != yyvsp[-2].ilist->end(); ++n) {
if(yyvsp[0].number == 0) {
cout_neg(n->second);
cout << "fluent_"+n->first+"(0).\n";
}
else {
cout << ":- not ";
cout_neg(n->second);
cout << "fluent_"+n->first+"("< latest_obs) ? yyvsp[0].number : latest_obs ;
delete yyvsp[-2].ilist;
;
break;}
case 32:
#line 289 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
for(ListPair::iterator n = yyvsp[-2].ilist->begin(); n != yyvsp[-2].ilist->end(); ++n) {
// for non-exogenous actions (not triggered or allowed)
if(triggered_actions.find(n->first) != triggered_actions.end() || allowed_actions.find(n->first) != allowed_actions.end()) {
cout << ":- ";
cout_neg(!n->second);
cout << "action_"+n->first+"("<second);
cout << "action_"+n->first+"("< latest_obs) ? yyvsp[0].number : latest_obs ;
delete yyvsp[-2].ilist;
;
break;}
case 33:
#line 311 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
// rules for generating all possible initial states
for(StringSet::iterator n = all_fluents.begin(); n != all_fluents.end(); ++n) {
cout << "fluent_"+*n+"(0) :- not "+neg+"fluent_"+*n+"(0).\n";
cout << neg+"fluent_"+*n+"(0) :- not fluent_"+*n+"(0).\n";
}
// all exogenous and allowed actions in one set: all - triggered
StringSet exoallow_actions;
set_difference(all_actions.begin(), all_actions.end(), triggered_actions.begin(), triggered_actions.end(),
insert_iterator(exoallow_actions, exoallow_actions.begin()) );
for(StringSet::iterator n = exoallow_actions.begin(); n != exoallow_actions.end(); ++n) {
cout << "action_"+*n+"(T) :- allow_action_"+*n+"(T), not "+neg+"action_"+*n+"(T), time(T), T(exoallow_actions, exoallow_actions.begin()) );
for(StringSet::iterator n = exoallow_actions.begin(); n != exoallow_actions.end(); ++n) {
cout << "action_"+*n+"(T) :- allow_action_"+*n+"(T), not "+neg+"action_"+*n+"(T), not achieved(T), time(T).\n";
cout << neg+"action_"+*n+"(T) :- not action_"+*n+"(T), time(T).\n";
}
cout << ":- not achieved.\n";
cout << "achieved :- achieved(0).\n";
cout << "achieved :- achieved(T+1), not achieved(T), time(T;T+1).\n";
cout << "achieved(T) :- ";
for(ListPair::iterator n = yyvsp[0].ilist->begin(); n != yyvsp[0].ilist->end(); ++n) {
if(n != yyvsp[0].ilist->begin()) cout << ", ";
cout_neg(n->second);
cout << "fluent_"+n->first+"(T)";
}
cout << ", T=n.\n";
cout << "achieved(T) :- achieved(T+1), ";
for(ListPair::iterator n = yyvsp[0].ilist->begin(); n != yyvsp[0].ilist->end(); ++n) {
if(n != yyvsp[0].ilist->begin()) cout << ", ";
cout_neg(n->second);
cout << "fluent_"+n->first+"(T)";
}
cout << ", time(T;T+1).\n";
// hides the achieve predicates
if(debug < 2) cout << "#hide achieved.\n";
if(debug < 2) cout << "#hide achieved(T).\n";
delete yyvsp[0].ilist;
;
break;}
case 35:
#line 374 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
// rules for generating all possible initial states
for(StringSet::iterator n = all_fluents.begin(); n != all_fluents.end(); ++n) {
cout << "fluent_"+*n+"(0) :- not "+neg+"fluent_"+*n+"(0).\n";
cout << neg+"fluent_"+*n+"(0) :- not fluent_"+*n+"(0).\n";
}
// justify the observations by including for every action:
for(StringSet::iterator n = all_actions.begin(); n != all_actions.end(); ++n) {
cout << "action_"+*n+"(T) :- allow_action_"+*n+"(T), not "+neg+"action_"+*n+"(T), time(T), Tbegin(); n != yyvsp[0].ilist->end(); ++n) {
if(n != yyvsp[0].ilist->begin()) cout << ", ";
cout_neg(n->second);
cout << "fluent_"+n->first+"(T)";
}
cout << ", time(T), T>="<push_back(pair(*yyvsp[0].istring, true));
delete yyvsp[0].istring;
;
break;}
case 37:
#line 408 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
yyval.ilist = new ListPair();
yyval.ilist->push_back(pair(*yyvsp[0].istring, false));
delete yyvsp[0].istring;
;
break;}
case 38:
#line 413 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
yyvsp[-2].ilist->push_back(pair(*yyvsp[0].istring, true));
yyval.ilist = yyvsp[-2].ilist;
delete yyvsp[0].istring;
;
break;}
case 39:
#line 418 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
{
yyvsp[-2].ilist->push_back(pair(*yyvsp[0].istring, false));
yyval.ilist = yyvsp[-2].ilist;
delete yyvsp[0].istring;
;
break;}
}
#line 839 "/usr/share/bison++/bison.cc"
/* the action file gets copied in in place of this dollarsign */
yyvsp -= yylen;
yyssp -= yylen;
#ifdef YY_CtaidParser_LSP_NEEDED
yylsp -= yylen;
#endif
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
*++yyvsp = yyval;
#ifdef YY_CtaidParser_LSP_NEEDED
yylsp++;
if (yylen == 0)
{
yylsp->first_line = YY_CtaidParser_LLOC.first_line;
yylsp->first_column = YY_CtaidParser_LLOC.first_column;
yylsp->last_line = (yylsp-1)->last_line;
yylsp->last_column = (yylsp-1)->last_column;
yylsp->text = 0;
}
else
{
yylsp->last_line = (yylsp+yylen-1)->last_line;
yylsp->last_column = (yylsp+yylen-1)->last_column;
}
#endif
/* Now "shift" the result of the reduction.
Determine what state that goes to,
based on the state we popped back to
and the rule number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];
YYGOTO(yynewstate);
YYLABEL(yyerrlab) /* here on detecting error */
if (! yyerrstatus)
/* If not already recovering from an error, report this error. */
{
++YY_CtaidParser_NERRS;
#ifdef YY_CtaidParser_ERROR_VERBOSE
yyn = yypact[yystate];
if (yyn > YYFLAG && yyn < YYLAST)
{
int size = 0;
char *msg;
int x, count;
count = 0;
/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
size += strlen(yytname[x]) + 15, count++;
msg = (char *) malloc(size + 15);
if (msg != 0)
{
strcpy(msg, "parse error");
if (count < 5)
{
count = 0;
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
{
strcat(msg, count == 0 ? ", expecting `" : " or `");
strcat(msg, yytname[x]);
strcat(msg, "'");
count++;
}
}
YY_CtaidParser_ERROR(msg);
free(msg);
}
else
YY_CtaidParser_ERROR ("parse error; also virtual memory exceeded");
}
else
#endif /* YY_CtaidParser_ERROR_VERBOSE */
YY_CtaidParser_ERROR("parse error");
}
YYGOTO(yyerrlab1);
YYLABEL(yyerrlab1) /* here on error raised explicitly by an action */
if (yyerrstatus == 3)
{
/* if just tried and failed to reuse lookahead token after an error, discard it. */
/* return failure if at end of input */
if (YY_CtaidParser_CHAR == YYEOF)
YYABORT;
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Discarding token %d (%s).\n", YY_CtaidParser_CHAR, yytname[yychar1]);
#endif
YY_CtaidParser_CHAR = YYEMPTY;
}
/* Else will try to reuse lookahead token
after shifting the error token. */
yyerrstatus = 3; /* Each real token shifted decrements this */
YYGOTO(yyerrhandle);
YYLABEL(yyerrdefault) /* current state does not do anything special for the error token. */
#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
if (yyn) YYGOTO(yydefault);
#endif
YYLABEL(yyerrpop) /* pop the current state because it cannot handle the error token */
if (yyssp == yyss) YYABORT;
yyvsp--;
yystate = *--yyssp;
#ifdef YY_CtaidParser_LSP_NEEDED
yylsp--;
#endif
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "Error: state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
YYLABEL(yyerrhandle)
yyn = yypact[yystate];
if (yyn == YYFLAG)
YYGOTO(yyerrdefault);
yyn += YYTERROR;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
YYGOTO(yyerrdefault);
yyn = yytable[yyn];
if (yyn < 0)
{
if (yyn == YYFLAG)
YYGOTO(yyerrpop);
yyn = -yyn;
YYGOTO(yyreduce);
}
else if (yyn == 0)
YYGOTO(yyerrpop);
if (yyn == YYFINAL)
YYACCEPT;
#if YY_CtaidParser_DEBUG != 0
if (YY_CtaidParser_DEBUG_FLAG)
fprintf(stderr, "Shifting error token, ");
#endif
*++yyvsp = YY_CtaidParser_LVAL;
#ifdef YY_CtaidParser_LSP_NEEDED
*++yylsp = YY_CtaidParser_LLOC;
#endif
yystate = yyn;
YYGOTO(yynewstate);
/* end loop, in which YYGOTO may be used. */
YYENDGOTO
}
/* END */
#line 1038 "/usr/share/bison++/bison.cc"
#line 424 "/home/tovok7/svn/potassco/coala/src/lib/c_taid/parser.y"
void CtaidParser::postProcessing() {
// trig_allow_actions = triggered_actions + allowed_actions
StringSet trig_allow_actions;
set_union(triggered_actions.begin(), triggered_actions.end(), allowed_actions.begin(), allowed_actions.end(),
insert_iterator(trig_allow_actions, trig_allow_actions.begin()) );
// exogenous_actions = all_actions - trig_allow_actions
set_difference(all_actions.begin(), all_actions.end(), trig_allow_actions.begin(), trig_allow_actions.end(),
insert_iterator(exogenous_actions, exogenous_actions.begin()) );
// add rules for EXOGENOUS actions (not triggered or allowed)
cout << "\n% exogenous actions\n";
for(StringSet::iterator n = exogenous_actions.begin(); n != exogenous_actions.end(); ++n) {
cout << "allow_action_"+*n+"(T) :- time(T).\n";
// hides allow_action for every exogenous action
if(debug < 2) cout << "#hide allow_action_"+*n+"(T).\n";
}
// inertial_fluents = all_fluents - default_fluents
set_difference(all_fluents.begin(), all_fluents.end(), default_fluents.begin(), default_fluents.end(),
insert_iterator(inertial_fluents, inertial_fluents.begin()) );
// add rules for INERTIAL fluents (not default)
cout << "\n% inertial fluents\n";
for(StringSet::iterator n = inertial_fluents.begin(); n != inertial_fluents.end(); ++n) {
cout << "fluent_"+*n+"(T+1) :- fluent_"+*n+"(T), not "+neg+"fluent_"+*n+"(T+1), time(T;T+1).\n";
cout << neg+"fluent_"+*n+"(T+1) :- "+neg+"fluent_"+*n+"(T), not fluent_"+*n+"(T+1), time(T;T+1).\n";
if(neg == "neg_") {
// relationship between fluent and its negation
cout << ":- fluent_"+*n+"(T), neg_fluent_"+*n+"(T), time(T).\n";
// hides neg_fluent for every inertial fluent
if(debug < 2) {
cout << "#hide neg_fluent_"+*n+"(T).\n";
}
}
if(debug < 1) cout << "#hide fluent_"+*n+"(T).\n";
}
// add time
cout << "\n% time facts\n";
cout << "time(0..n).\n";
if(debug < 2) cout << "#hide time(N).\n";
}
bool CtaidParser::cout_neg(bool not_neg) {
if(not_neg) return true;
else {
cout << neg;
return false;
}
}
coala-1.0.1_src/src/lib/c_taid/compiler.h 000644 001750 001750 00000002765 11477164507 020754 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c_taid/compiler.h - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#undef yyFlexLexer
#define yyFlexLexer ctaidFlexLexer
#include
#include
#include "../main.h"
#include "../options.h"
#include "parser.h"
namespace C_taid {
class Compiler : public Coala::AbstractCompiler, public CtaidParser {
private:
ctaidFlexLexer lexer;
public:
Compiler(Coala::CompilerOptions*);
virtual ~Compiler();
int compile();
int yylex();
void yyerror(char*);
void change_input(std::istream*);
};
};
coala-1.0.1_src/src/lib/c_taid/scanner.l 000644 001750 001750 00000006604 11477164507 020573 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c_taid/scanner.l - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
%{
#include "parser.h"
#include
bool second_part = false;
bool asked_query = false;
void printPartError(const string, const int);
void printQueryError(const string, const int);
%}
%option yylineno nounput noyywrap c++ prefix="ctaid"
IDENTIFIER [a-zA-Z][a-zA-Z0-9_]*
NEG_IDENTI \-[a-zA-Z0-9_]+
NUMBER [0-9]+
COMMENT \%.*\n
ACT
FLU
DEF
CAUS
IF
TRIG
ALLOW
INHIB
NCONC
AT
OCAT
EXP
PLAN
PRED
%%
[\t\n ]+ // ignore white space.
{ACT} { if(second_part) printPartError(yytext, lineno()); else return CtaidParser::ACT; }
{FLU} { return CtaidParser::FLU; }
{DEF} { return CtaidParser::DEF; }
{CAUS} { return CtaidParser::CAUS; }
{IF} { return CtaidParser::IF; }
{TRIG} { if(second_part) printPartError(yytext, lineno()); else return CtaidParser::TRIG; }
{ALLOW} { if(second_part) printPartError(yytext, lineno()); else return CtaidParser::ALLOW; }
{INHIB} { return CtaidParser::INHIB; }
{NCONC} { return CtaidParser::NCONC; }
{AT} { return CtaidParser::AT; }
{OCAT} { second_part = true; return CtaidParser::OC_AT; }
{EXP} { if(asked_query) printQueryError(yytext, lineno());
else {
asked_query = true;
return CtaidParser::EXP;
}
}
{PLAN} { if(asked_query) printQueryError(yytext, lineno());
else {
asked_query = true;
return CtaidParser::PLAN;
}
}
{PRED} { if(asked_query) printQueryError(yytext, lineno());
else {
asked_query = true;
return CtaidParser::PRED;
}
}
{IDENTIFIER} { return CtaidParser::IDENTIFIER; }
{NEG_IDENTI} { return CtaidParser::NEG_IDENTI; }
{NUMBER} { return CtaidParser::NUMBER; }
"," { return CtaidParser::COMMA; }
"." { return CtaidParser::DOT; }
{COMMENT} { /* comment */ }
<> { yyterminate(); }
. { cerr << "\n\nError: Unknown keyword '"+string(yytext)+"' found at line "<getInputStream());
}
Compiler::~Compiler() {
}
int Compiler::compile() {
return yyparse();
}
int Compiler::yylex() {
int token = lexer.yylex();
if(token == IDENTIFIER) yylval.istring = new string(lexer.YYText());
else {
if(token == NEG_IDENTI) {
// remove leading negation sign '-' from fluent
string *tmp_str = new string(lexer.YYText());
tmp_str->erase(0,1);
yylval.istring = tmp_str;
}
else {
if(token == NUMBER) yylval.number = atoi(lexer.YYText());
}
}
yylloc.first_line = lexer.lineno();
yylloc.last_line = lexer.lineno();
yylloc.text = (char *)lexer.YYText();
return token;
}
void Compiler::yyerror(char *m) {
if(strcmp(yylloc.text, "\n") == 0) yylloc.text = (char*)"[newline]";
cerr << "\n\ncoala: Error: Syntax error in line "<
namespace C {
class FluentDefinition : virtual public Statement
{
public:
FluentDefinition(int line, Formula* fluent_list, Types* types=NULL);
virtual ~FluentDefinition ( );
void print(Printer*, bool);
protected:
void printFakeNeg(Printer* p);
Formula* F_;
};
}; // end of package namespace
#endif // FLUENTDEFINITION_H
coala-1.0.1_src/src/lib/c/RQuery.cpp 000644 001750 001750 00000002433 11477164507 017713 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/RQuery.cpp - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#include "RQuery.h"
using namespace C;
RQuery::RQuery(int line, Formula* F, Formula* A, string* time, Types* types) : Query(line, types) {
F_ = F;
A_ = A;
time_ = *time;
}
RQuery::~RQuery ( ) { }
void RQuery::print(Printer* p) {
}
coala-1.0.1_src/src/lib/c/Types.h 000644 001750 001750 00000003447 11477164507 017243 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/Types.h - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#ifndef TYPES_H
#define TYPES_H
#include
#include
#include
#include
#include "Type.h"
#include "Constraint.h"
namespace C {
class Types
{
public:
Types();
Types(Type*);
Types(Constraint*);
virtual ~Types ( );
set* getVariables();
void addType(Type*);
void addType(Constraint*);
string getAsString(Printer*, set*, int);
void print(Printer* p, set* vars, int line);
bool printTypes(Printer*, set*, vector*);
void printConstraints(Printer*, set*, vector*, bool);
void check(set* vars, int line);
private:
vector types_;
vector constraints_;
};
}; // end of package namespace
#endif // TYPES_H
coala-1.0.1_src/src/lib/c/Type.cpp 000644 001750 001750 00000003031 11477164507 017400 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/Type.cpp - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#include "Type.h"
using namespace C;
Type::Type(string* name, Arguments* args, bool sign) : Identifier(name, args) {
sign_ = sign;
}
Type::~Type() { }
void Type::setMin(int number) {
args_->setMin(number);
}
void Type::setMax(int number) {
args_->setMax(number);
}
int Type::getMin() {
return args_->getMin();
}
int Type::getMax() {
return args_->getMax();
}
bool Type::isTrue() {
return sign_;
}
string Type::print(Printer* p) {
return getName() + "(" + args_->print(p) + ")";
}
coala-1.0.1_src/src/lib/c/Formula.h 000644 001750 001750 00000003736 11477164507 017545 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/Formula.h - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#ifndef FORMULA_H
#define FORMULA_H
#include "Types.h"
#include
#include
#include
#include
namespace C {
class FluentAction;
class Formula
{
public:
Formula();
Formula(char, Formula*);
Formula(char, vector*);
virtual ~Formula();
void addPart(Formula*);
char getType();
Formula* getFirstFormula();
vector::iterator begin();
vector::iterator end();
void insert(vector::iterator, vector::iterator, vector::iterator);
Formula* invert();
FluentAction* getFluentAction();
bool isTrue();
bool isFalse();
void print(Printer*, set*, string T="");
void printAlsoActions(Printer*, set*, string T="");
void printCompositeFluents(Printer*, Types*);
void printCompositeFluentActions(Printer*, Types*);
protected:
char type_;
private:
vector* I_;
};
}; // end of package namespace
#endif // FORMULA_H
coala-1.0.1_src/src/lib/c/Types.cpp 000644 001750 001750 00000015124 11477164507 017571 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/Types.cpp - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#include "Types.h"
using namespace C;
Types::Types() {
types_ = vector();
constraints_ = vector();
}
Types::Types(Type* identifier) {
types_ = vector(1, identifier);
constraints_ = vector();
}
Types::Types(Constraint* constraint) {
types_ = vector();
constraints_ = vector(1, constraint);
}
Types::~Types ( ) { }
set* Types::getVariables() {
set* vars = new set();
if(!types_.empty()) {
for(vector::iterator n = types_.begin(); n!= types_.end(); ++n) {
// only return variables that don't need additional type information
if((*n)->isTrue()) {
set* tmp_vars = (*n)->getVariables();
if(!tmp_vars->empty()) {
vars->insert(tmp_vars->begin(), tmp_vars->end());
}
}
} // end for
}
if(!constraints_.empty()) {
for(vector::iterator n = constraints_.begin(); n!= constraints_.end(); ++n) {
// only return variables that don't need additional type information
if((*n)->getType() == "==") {
set* tmp_vars = (*n)->getVariables();
if(!tmp_vars->empty()) {
vars->insert(tmp_vars->begin(), tmp_vars->end());
}
delete tmp_vars;
}
} // end for constraint loop
}
return vars;
}
void Types::addType(Type* identifier) {
types_.push_back(identifier);
}
void Types::addType(Constraint* constraint) {
constraints_.push_back(constraint);
}
string Types::getAsString(Printer* p, set* variables, int line) {
std::stringstream tmp_stream;
Printer* tmp_p = new Printer( &tmp_stream, p->debug, p->fake_neg, p->inc,
p->rev, p->no_w_chk, p->no_direct_enc,
p->lang);
print(tmp_p, variables, line);
delete tmp_p;
return tmp_stream.str();
}
void Types::print(Printer* p, set* variables, int line) {
// take variables from constraints into account
for(vector::iterator constraint = constraints_.begin(); constraint != constraints_.end(); ++constraint) {
set* constraint_vars = (*constraint)->getVariables();
variables->insert(constraint_vars->begin(), constraint_vars->end());
delete constraint_vars;
}
if(!p->no_w_chk) {
if(variables) check(variables, line);
else {
set* vars = new set();
check(vars, line);
delete vars;
}
}
bool printed = printTypes(p, variables, &types_);
printConstraints(p, variables, &constraints_, printed);
}
bool Types::printTypes(Printer* p, set* variables, vector* vec) {
bool printed = false;
if(!vec->empty()) {
for(vector::iterator n = vec->begin(); n != vec->end(); ++n) {
//set* type_vars = (*n)->getVariables();
//set result;
//insert_iterator< set > res_ins(result, result.begin());
//set_intersection(type_vars->begin(), type_vars->end(), variables->begin(), variables->end(), res_ins);
// only add types that have variables that are actually used and drop the rest
//if(!result.empty()) {
string type = (*n)->print(p);
string restricted = "";
int min = (*n)->getMin();
int max = (*n)->getMax();
// type grounding has been restricted
if(min != -1 || max != -1) {
restricted = "restricted_";
string min_str;
string max_str;
stringstream ss;
ss << min; ss >> min_str; ss.clear();
ss << max; ss >> max_str;
if(min != -1) p->addExtra(min_str + " ");
p->addExtra("{ " + restricted + type + " : " + type + " }");
if(max != -1) p->addExtra(" " + max_str);
p->addExtra(".\n");
}
if(printed) p->add(", ");
if(!(*n)->isTrue())
p->add("not ");
p->add(restricted + type);
printed = true;
//}
} // end for
}
return printed;
}
void Types::printConstraints(Printer* p, set* variables, vector* vec, bool printed) {
if(!vec->empty()) {
for(vector::iterator n = vec->begin(); n != vec->end(); ++n) {
//set* type_vars = (*n)->getVariables();
//set result;
//insert_iterator< set > res_ins(result, result.begin());
//set_intersection(type_vars->begin(), type_vars->end(), variables->begin(), variables->end(), res_ins);
// only add types that have variables that are actually used and drop the rest
//if(!result.empty()) {
if(printed) p->add(", ");
p->add((*n)->print(p));
printed = true;
//}
//delete type_vars;
}
}
}
void Types::check(set* vars, int line) {
set* type_vars = getVariables();
if(*vars != *type_vars) {
string error; stringstream ss; ss << line; ss >> error;
if(!type_vars->empty()) {
set::iterator type = type_vars->begin();
for(set::iterator var = vars->begin(); var != vars->end(); ++var) {
Variable* v = *var;
Variable* t = *type;
bool out = false;
if(v != t) {
for(; type != type_vars->end();) {
if(v == *type) {
out = true;
break;
}
else if(++type == type_vars->end()) {
throw std::runtime_error("Variable "+v->getText()+" not defined in line "+error+".\n");
}
}
}
if(out) break;
if(++type == type_vars->end()) {
string var_name;
if(var == vars->end()) { var_name = v->getText(); }
else { var_name = (*++var)->getText(); }
throw std::runtime_error("Variable "+var_name+" not defined in line "+error+".\n");
}
} // end for
}
else {
throw std::runtime_error("No Variables defined at line "+error+". Hint: Types with 'not' are not defining.\n");
}
}
delete type_vars;
}
coala-1.0.1_src/src/lib/c/Identifier.h 000644 001750 001750 00000003121 11477164507 020206 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/Identifier.h - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#ifndef IDENTIFIER_H
#define IDENTIFIER_H
#include
#include
#include "Variable.h"
#include "Arguments.h"
#include
namespace C {
class Identifier
{
public:
// Identifier();
Identifier(string* name, Arguments* args);
Identifier(string* name);
virtual ~Identifier();
//virtual string print(Printer*, string T="");
string getName();
/**
* @return vector
*/
set* getVariables();
protected:
Arguments* args_;
string name_;
};
}; // end of package namespace
#endif // IDENTIFIER_H
coala-1.0.1_src/src/lib/c/Scanner.cpp 000644 001750 001750 00000156670 11477164507 020072 0 ustar 00tovok7 tovok7 000000 000000 #line 2 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.cpp"
#line 4 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.cpp"
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5
#define YY_FLEX_SUBMINOR_VERSION 35
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
/* The c++ scanner is a mess. The FlexLexer.h header file relies on the
* following macro. This is required in order to pass the c++-multiple-scanners
* test in the regression suite. We get reports that it breaks inheritance.
* We will address this in a future release of flex, or omit the C++ scanner
* altogether.
*/
#define yyFlexLexer cFlexLexer
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */
/* end standard C headers. */
/* flex integer type definitions */
#ifndef FLEXINT_H
#define FLEXINT_H
/* C99 systems have . Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
* if you want the limit (max/min) macros for int types.
*/
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif
#include
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (4294967295U)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
/* begin standard C++ headers. */
#include
#include
#include
#include
#include
/* end standard C++ headers. */
#ifdef __cplusplus
/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST
#else /* ! __cplusplus */
/* C99 requires __STDC__ to be defined as 1. */
#if defined (__STDC__)
#define YY_USE_CONST
#endif /* defined (__STDC__) */
#endif /* ! __cplusplus */
#ifdef YY_USE_CONST
#define yyconst const
#else
#define yyconst
#endif
/* Returned upon end-of-file. */
#define YY_NULL 0
/* Promotes a possibly negative, possibly signed char to an unsigned
* integer for use as an array index. If the signed char is negative,
* we want to instead treat it as an 8-bit unsigned char, hence the
* double cast.
*/
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
/* Enter a start condition. This macro really ought to take a parameter,
* but we do it the disgusting crufty way forced on us by the ()-less
* definition of BEGIN.
*/
#define BEGIN (yy_start) = 1 + 2 *
/* Translate the current start state into a value that can be later handed
* to BEGIN to return to the state. The YYSTATE alias is for lex
* compatibility.
*/
#define YY_START (((yy_start) - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart( yyin )
#define YY_END_OF_BUFFER_CHAR 0
/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
* Ditto for the __ia64__ case accordingly.
*/
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif
/* The state buf must be large enough to hold one state per character in the main buffer.
*/
#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
extern int yyleng;
#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
/* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
* access to the local variable yy_act. Since yyless() is a macro, it would break
* existing scanners that call yyless() from OUTSIDE yylex.
* One obvious solution it to make yy_act a global. I tried that, and saw
* a 5% performance hit in a non-yylineno scanner, because yy_act is
* normally declared as a register variable-- so it is not worth it.
*/
#define YY_LESS_LINENO(n) \
do { \
int yyl;\
for ( yyl = n; yyl < yyleng; ++yyl )\
if ( yytext[yyl] == '\n' )\
--yylineno;\
}while(0)
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
*yy_cp = (yy_hold_char); \
YY_RESTORE_YY_MORE_OFFSET \
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \
while ( 0 )
#define unput(c) yyunput( c, (yytext_ptr) )
#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
{
std::istream* yy_input_file;
char *yy_ch_buf; /* input buffer */
char *yy_buf_pos; /* current position in input buffer */
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
yy_size_t yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
* delete it.
*/
int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and
* if we're using stdio for input, then we want to use getc()
* instead of fread(), to make sure we stop fetching input after
* each newline.
*/
int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line.
* If so, '^' rules will be active on the next match, otherwise
* not.
*/
int yy_at_bol;
int yy_bs_lineno; /**< The line count. */
int yy_bs_column; /**< The column count. */
/* Whether to try to fill the input buffer when we reach the
* end of it.
*/
int yy_fill_buffer;
int yy_buffer_status;
#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
/* When an EOF's been seen but there's still some text to process
* then we mark the buffer as YY_EOF_PENDING, to indicate that we
* shouldn't try reading from the input source any more. We might
* still have a bunch of tokens to match, though, because of
* possible backing-up.
*
* When we actually see the EOF, we change the status to "new"
* (via yyrestart()), so that the user can continue scanning by
* just pointing yyin at a new input file.
*/
#define YY_BUFFER_EOF_PENDING 2
};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
/* We provide macros for accessing buffer states in case in the
* future we want to put the buffer states in a more general
* "scanner state".
*
* Returns the top of the stack, or NULL.
*/
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
? (yy_buffer_stack)[(yy_buffer_stack_top)] \
: NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
* NULL or when we need an lvalue. For internal use only.
*/
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
void *calloc (yy_size_t );
void *crealloc (void *,yy_size_t );
void cfree (void * );
#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
{ \
if ( ! YY_CURRENT_BUFFER ){ \
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer( yyin, YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
#define yy_set_bol(at_bol) \
{ \
if ( ! YY_CURRENT_BUFFER ){\
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer( yyin, YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
/* Begin user sect3 */
#define YY_SKIP_YYWRAP
typedef unsigned char YY_CHAR;
#define yytext_ptr yytext
#define YY_INTERACTIVE
#include
int yyFlexLexer::yywrap() { return 1; }
/* Done after the current pattern has been matched and before the
* corresponding action - sets up yytext.
*/
#define YY_DO_BEFORE_ACTION \
(yytext_ptr) = yy_bp; \
yyleng = (size_t) (yy_cp - yy_bp); \
(yy_hold_char) = *yy_cp; \
*yy_cp = '\0'; \
(yy_c_buf_p) = yy_cp;
#define YY_NUM_RULES 60
#define YY_END_OF_BUFFER 61
/* This struct is not used in this scanner,
but its presence is necessary. */
struct yy_trans_info
{
flex_int32_t yy_verify;
flex_int32_t yy_nxt;
};
static yyconst flex_int16_t yy_accept[190] =
{ 0,
0, 0, 0, 0, 61, 59, 1, 1, 54, 59,
51, 39, 40, 49, 47, 34, 48, 38, 50, 32,
36, 35, 43, 59, 44, 52, 33, 33, 53, 30,
30, 30, 55, 4, 5, 7, 6, 3, 1, 42,
0, 58, 56, 31, 37, 32, 0, 45, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 41,
46, 33, 33, 30, 30, 30, 31, 57, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 33, 29, 8, 0, 0,
0, 28, 0, 0, 0, 0, 0, 12, 0, 0,
0, 0, 0, 0, 0, 2, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 14, 0, 0, 13, 0, 0,
0, 0, 15, 0, 0, 26, 0, 0, 0, 0,
0, 22, 9, 19, 11, 18, 0, 10, 0, 0,
0, 0, 0, 0, 25, 16, 0, 0, 0, 0,
0, 0, 24, 17, 0, 0, 0, 0, 20, 0,
0, 23, 0, 0, 27, 0, 0, 21, 0
} ;
static yyconst flex_int32_t yy_ec[256] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 4, 5, 1, 1, 1, 6, 7, 1, 8,
9, 10, 11, 12, 13, 14, 15, 16, 16, 16,
16, 16, 16, 16, 16, 16, 16, 17, 18, 19,
20, 21, 22, 1, 23, 23, 23, 23, 23, 24,
25, 23, 23, 23, 23, 26, 23, 23, 23, 23,
23, 27, 23, 28, 29, 23, 23, 30, 23, 23,
1, 1, 1, 31, 32, 1, 33, 34, 35, 36,
37, 38, 39, 40, 41, 39, 39, 42, 43, 44,
45, 39, 39, 46, 47, 48, 49, 39, 50, 51,
52, 39, 1, 53, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1
} ;
static yyconst flex_int32_t yy_meta[54] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 2, 1, 1, 1, 1,
3, 1, 2, 2, 2, 2, 2, 2, 2, 2,
1, 2, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 1
} ;
static yyconst flex_int16_t yy_base[195] =
{ 0,
0, 0, 30, 37, 231, 232, 66, 69, 210, 226,
232, 232, 232, 232, 232, 232, 207, 213, 232, 210,
232, 232, 61, 205, 204, 232, 0, 195, 232, 0,
177, 176, 232, 0, 0, 0, 0, 0, 73, 232,
217, 232, 232, 0, 232, 203, 197, 232, 44, 184,
179, 23, 170, 40, 181, 43, 178, 166, 171, 232,
232, 0, 184, 0, 173, 160, 0, 232, 159, 158,
155, 183, 154, 164, 159, 151, 157, 177, 160, 144,
160, 150, 158, 143, 154, 173, 0, 0, 148, 151,
154, 232, 139, 152, 137, 146, 146, 232, 135, 176,
142, 141, 128, 139, 129, 232, 129, 127, 120, 134,
121, 132, 124, 120, 118, 130, 117, 112, 116, 140,
123, 115, 137, 110, 51, 114, 134, 106, 79, 112,
119, 104, 113, 102, 232, 127, 126, 232, 125, 124,
123, 95, 232, 121, 108, 232, 107, 90, 105, 102,
86, 232, 232, 232, 232, 232, 115, 232, 87, 92,
86, 86, 82, 97, 232, 232, 108, 107, 90, 84,
74, 71, 232, 232, 89, 66, 70, 74, 232, 41,
57, 232, 68, 43, 232, 26, 37, 232, 232, 111,
113, 116, 119, 122
} ;
static yyconst flex_int16_t yy_def[195] =
{ 0,
189, 1, 1, 1, 189, 189, 189, 189, 189, 190,
189, 189, 189, 189, 189, 189, 191, 189, 189, 189,
189, 189, 189, 189, 189, 189, 192, 192, 189, 193,
193, 193, 189, 192, 192, 192, 192, 192, 189, 189,
190, 189, 189, 194, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 192, 192, 193, 193, 193, 194, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 192, 193, 193, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 0, 189,
189, 189, 189, 189
} ;
static yyconst flex_int16_t yy_nxt[286] =
{ 0,
6, 7, 8, 7, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 27, 27, 28, 27, 27, 27, 27,
29, 6, 30, 30, 30, 30, 30, 30, 30, 30,
30, 30, 31, 32, 30, 30, 30, 30, 30, 30,
30, 30, 33, 34, 35, 75, 36, 188, 37, 38,
34, 35, 187, 36, 76, 37, 38, 39, 39, 39,
39, 39, 39, 47, 39, 39, 39, 78, 69, 81,
48, 70, 145, 79, 186, 71, 140, 82, 185, 164,
184, 72, 183, 49, 182, 50, 51, 141, 52, 146,
53, 54, 181, 55, 56, 57, 165, 180, 58, 179,
59, 41, 41, 41, 41, 44, 44, 62, 178, 62,
64, 177, 64, 67, 176, 67, 175, 174, 173, 172,
171, 170, 169, 168, 167, 166, 163, 162, 161, 160,
159, 158, 157, 156, 155, 154, 153, 152, 151, 150,
149, 148, 147, 144, 143, 142, 139, 138, 137, 136,
135, 134, 133, 132, 131, 130, 129, 128, 127, 126,
125, 124, 123, 122, 121, 120, 119, 118, 117, 116,
115, 114, 113, 112, 111, 110, 109, 108, 107, 106,
105, 104, 103, 102, 101, 100, 99, 98, 97, 96,
95, 94, 93, 92, 91, 90, 89, 88, 87, 86,
85, 84, 83, 80, 77, 74, 73, 68, 46, 42,
66, 65, 63, 61, 60, 46, 45, 43, 42, 40,
189, 5, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189
} ;
static yyconst flex_int16_t yy_chk[286] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 3, 3, 52, 3, 187, 3, 3,
4, 4, 186, 4, 52, 4, 4, 7, 7, 7,
8, 8, 8, 23, 39, 39, 39, 54, 49, 56,
23, 49, 129, 54, 184, 49, 125, 56, 183, 151,
181, 49, 180, 23, 178, 23, 23, 125, 23, 129,
23, 23, 177, 23, 23, 23, 151, 176, 23, 175,
23, 190, 190, 190, 190, 191, 191, 192, 172, 192,
193, 171, 193, 194, 170, 194, 169, 168, 167, 164,
163, 162, 161, 160, 159, 157, 150, 149, 148, 147,
145, 144, 142, 141, 140, 139, 137, 136, 134, 133,
132, 131, 130, 128, 127, 126, 124, 123, 122, 121,
120, 119, 118, 117, 116, 115, 114, 113, 112, 111,
110, 109, 108, 107, 105, 104, 103, 102, 101, 100,
99, 97, 96, 95, 94, 93, 91, 90, 89, 86,
85, 84, 83, 82, 81, 80, 79, 78, 77, 76,
75, 74, 73, 72, 71, 70, 69, 66, 65, 63,
59, 58, 57, 55, 53, 51, 50, 47, 46, 41,
32, 31, 28, 25, 24, 20, 18, 17, 10, 9,
5, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
189, 189, 189, 189, 189
} ;
/* Table of booleans, true if rule could match eol. */
static yyconst flex_int32_t yy_rule_can_match_eol[61] =
{ 0,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
0, };
/* The intent behind this definition is that it'll catch
* any uses of REJECT which flex missed.
*/
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
#line 1 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
/****************************************************************************
* lib/c/Scanner.l - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#line 21 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
#include
#include "Parser.h"
#line 586 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.cpp"
#define INITIAL 0
#define ltl 1
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
* down here because we want the user's section 1 to have been scanned first.
* The user has a chance to override it with an option.
*/
#include
#endif
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
#ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int );
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * );
#endif
#ifndef YY_NO_INPUT
#endif
/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif
/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
#define ECHO LexerOutput( yytext, yyleng )
#endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
* is returned in "result".
*/
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
\
if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
YY_FATAL_ERROR( "input in flex scanner failed" );
#endif
/* No semi-colon after return; correct usage is to write "yyterminate();" -
* we don't want an extra ';' after the "return" because that will cause
* some compilers to complain about unreachable statements.
*/
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif
/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif
/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) LexerError( msg )
#endif
/* end tables serialization structures and prototypes */
/* Default declaration of generated scanner - a define so the user can
* easily add parameters.
*/
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1
#define YY_DECL int yyFlexLexer::yylex()
#endif /* !YY_DECL */
/* Code executed at the beginning of each rule, after yytext and yyleng
* have been set up.
*/
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif
/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#endif
#define YY_RULE_SETUP \
YY_USER_ACTION
/** The main scanner function which does all the work.
*/
YY_DECL
{
register yy_state_type yy_current_state;
register char *yy_cp, *yy_bp;
register int yy_act;
#line 57 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
#line 694 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.cpp"
if ( !(yy_init) )
{
(yy_init) = 1;
#ifdef YY_USER_INIT
YY_USER_INIT;
#endif
if ( ! (yy_start) )
(yy_start) = 1; /* first start state */
if ( ! yyin )
yyin = & std::cin;
if ( ! yyout )
yyout = & std::cout;
if ( ! YY_CURRENT_BUFFER ) {
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer( yyin, YY_BUF_SIZE );
}
yy_load_buffer_state( );
}
while ( 1 ) /* loops until end-of-file is reached */
{
yy_cp = (yy_c_buf_p);
/* Support of yytext. */
*yy_cp = (yy_hold_char);
/* yy_bp points to the position in yy_ch_buf of the start of
* the current run.
*/
yy_bp = yy_cp;
yy_current_state = (yy_start);
yy_match:
do
{
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 190 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp;
}
while ( yy_base[yy_current_state] != 232 );
yy_find_action:
yy_act = yy_accept[yy_current_state];
if ( yy_act == 0 )
{ /* have to back up */
yy_cp = (yy_last_accepting_cpos);
yy_current_state = (yy_last_accepting_state);
yy_act = yy_accept[yy_current_state];
}
YY_DO_BEFORE_ACTION;
if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
{
int yyl;
for ( yyl = 0; yyl < yyleng; ++yyl )
if ( yytext[yyl] == '\n' )
yylineno++;
;
}
do_action: /* This label is used only to access EOF actions. */
switch ( yy_act )
{ /* beginning of action switch */
case 0: /* must back up */
/* undo the effects of YY_DO_BEFORE_ACTION */
*yy_cp = (yy_hold_char);
yy_cp = (yy_last_accepting_cpos);
yy_current_state = (yy_last_accepting_state);
goto yy_find_action;
case 1:
/* rule 1 can match eol */
YY_RULE_SETUP
#line 58 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
// ignore white space.
YY_BREAK
case 2:
YY_RULE_SETUP
#line 59 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ BEGIN(ltl); return Parser::LTL; }
YY_BREAK
case 3:
YY_RULE_SETUP
#line 60 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::X; }
YY_BREAK
case 4:
YY_RULE_SETUP
#line 61 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::F; }
YY_BREAK
case 5:
YY_RULE_SETUP
#line 62 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::G; }
YY_BREAK
case 6:
YY_RULE_SETUP
#line 63 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::U; }
YY_BREAK
case 7:
YY_RULE_SETUP
#line 64 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::R; }
YY_BREAK
case 8:
YY_RULE_SETUP
#line 65 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::NOT; }
YY_BREAK
case 9:
YY_RULE_SETUP
#line 66 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::ACT; }
YY_BREAK
case 10:
YY_RULE_SETUP
#line 67 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::FLU; }
YY_BREAK
case 11:
YY_RULE_SETUP
#line 68 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::CAUS; }
YY_BREAK
case 12:
YY_RULE_SETUP
#line 69 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::IF; }
YY_BREAK
case 13:
YY_RULE_SETUP
#line 70 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::AFTER; }
YY_BREAK
case 14:
YY_RULE_SETUP
#line 71 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::TRUE; }
YY_BREAK
case 15:
YY_RULE_SETUP
#line 72 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::FALSE; }
YY_BREAK
case 16:
YY_RULE_SETUP
#line 73 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::DEF; }
YY_BREAK
case 17:
YY_RULE_SETUP
#line 74 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::INERT; }
YY_BREAK
case 18:
YY_RULE_SETUP
#line 75 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::CAUSES; }
YY_BREAK
case 19:
YY_RULE_SETUP
#line 76 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::ALWAYS; }
YY_BREAK
case 20:
YY_RULE_SETUP
#line 77 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::MAY; }
YY_BREAK
case 21:
YY_RULE_SETUP
#line 78 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::NONEXE; }
YY_BREAK
case 22:
YY_RULE_SETUP
#line 79 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::WHERE; }
YY_BREAK
case 23:
YY_RULE_SETUP
#line 80 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::OC_AT; }
YY_BREAK
case 24:
YY_RULE_SETUP
#line 81 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::HO_AT; }
YY_BREAK
case 25:
YY_RULE_SETUP
#line 82 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::OCCURS; }
YY_BREAK
case 26:
YY_RULE_SETUP
#line 83 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::HOLDS; }
YY_BREAK
case 27:
YY_RULE_SETUP
#line 84 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::NECES; }
YY_BREAK
case 28:
YY_RULE_SETUP
#line 85 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::AT; }
YY_BREAK
case 29:
YY_RULE_SETUP
#line 86 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::MOD; }
YY_BREAK
case 30:
YY_RULE_SETUP
#line 87 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::IDENTIFIER; }
YY_BREAK
case 31:
YY_RULE_SETUP
#line 88 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::NEG_IDENTI; }
YY_BREAK
case 32:
YY_RULE_SETUP
#line 89 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::NUMBER; }
YY_BREAK
case 33:
YY_RULE_SETUP
#line 90 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::VARIABLE; }
YY_BREAK
case 34:
YY_RULE_SETUP
#line 91 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::COMMA; }
YY_BREAK
case 35:
YY_RULE_SETUP
#line 92 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::SEMIC; }
YY_BREAK
case 36:
YY_RULE_SETUP
#line 93 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::COLON; }
YY_BREAK
case 37:
YY_RULE_SETUP
#line 94 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::DDOT; }
YY_BREAK
case 38:
YY_RULE_SETUP
#line 95 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ BEGIN(0); return Parser::DOT; }
YY_BREAK
case 39:
YY_RULE_SETUP
#line 96 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::LBRAC; }
YY_BREAK
case 40:
YY_RULE_SETUP
#line 97 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::RBRAC; }
YY_BREAK
case 41:
YY_RULE_SETUP
#line 98 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::EQ; }
YY_BREAK
case 42:
YY_RULE_SETUP
#line 99 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::NEQ; }
YY_BREAK
case 43:
YY_RULE_SETUP
#line 100 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::LT; }
YY_BREAK
case 44:
YY_RULE_SETUP
#line 101 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::GT; }
YY_BREAK
case 45:
YY_RULE_SETUP
#line 102 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::LE; }
YY_BREAK
case 46:
YY_RULE_SETUP
#line 103 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::GE; }
YY_BREAK
case 47:
YY_RULE_SETUP
#line 104 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::PLUS; }
YY_BREAK
case 48:
YY_RULE_SETUP
#line 105 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::MINUS; }
YY_BREAK
case 49:
YY_RULE_SETUP
#line 106 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::TIMES; }
YY_BREAK
case 50:
YY_RULE_SETUP
#line 107 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::DIV; }
YY_BREAK
case 51:
YY_RULE_SETUP
#line 108 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::AND; }
YY_BREAK
case 52:
YY_RULE_SETUP
#line 109 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::OR; }
YY_BREAK
case 53:
YY_RULE_SETUP
#line 110 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::XOR; }
YY_BREAK
case 54:
YY_RULE_SETUP
#line 111 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::LTLNOT; }
YY_BREAK
case 55:
YY_RULE_SETUP
#line 112 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::LTLOR; }
YY_BREAK
case 56:
YY_RULE_SETUP
#line 113 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::IMPL; }
YY_BREAK
case 57:
YY_RULE_SETUP
#line 114 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ return Parser::EQUIV; }
YY_BREAK
case 58:
/* rule 58 can match eol */
YY_RULE_SETUP
#line 115 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ /* comment */ }
YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(ltl):
#line 116 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ yyterminate(); }
YY_BREAK
case 59:
YY_RULE_SETUP
#line 117 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
{ cerr << "\n\nError: Unknown keyword '"+string(yytext)+"' found at line "<yy_buffer_status == YY_BUFFER_NEW )
{
/* We're scanning a new file or input source. It's
* possible that this happened because the user
* just pointed yyin at a new source and called
* yylex(). If so, then we have to assure
* consistency between YY_CURRENT_BUFFER and our
* globals. Here is the right place to do so, because
* this is the first action (other than possibly a
* back-up) that will match for the new input source.
*/
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
}
/* Note that here we test for yy_c_buf_p "<=" to the position
* of the first EOB in the buffer, since yy_c_buf_p will
* already have been incremented past the NUL character
* (since all states make transitions on EOB to the
* end-of-buffer state). Contrast this with the test
* in input().
*/
if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
{ /* This was really a NUL. */
yy_state_type yy_next_state;
(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
/* Okay, we're now positioned to make the NUL
* transition. We couldn't have
* yy_get_previous_state() go ahead and do it
* for us because it doesn't know how to deal
* with the possibility of jamming (and we don't
* want to build jamming into it because then it
* will run more slowly).
*/
yy_next_state = yy_try_NUL_trans( yy_current_state );
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
if ( yy_next_state )
{
/* Consume the NUL. */
yy_cp = ++(yy_c_buf_p);
yy_current_state = yy_next_state;
goto yy_match;
}
else
{
yy_cp = (yy_c_buf_p);
goto yy_find_action;
}
}
else switch ( yy_get_next_buffer( ) )
{
case EOB_ACT_END_OF_FILE:
{
(yy_did_buffer_switch_on_eof) = 0;
if ( yywrap( ) )
{
/* Note: because we've taken care in
* yy_get_next_buffer() to have set up
* yytext, we can now set up
* yy_c_buf_p so that if some total
* hoser (like flex itself) wants to
* call the scanner after we return the
* YY_NULL, it'll still work - another
* YY_NULL will get returned.
*/
(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
yy_act = YY_STATE_EOF(YY_START);
goto do_action;
}
else
{
if ( ! (yy_did_buffer_switch_on_eof) )
YY_NEW_FILE;
}
break;
}
case EOB_ACT_CONTINUE_SCAN:
(yy_c_buf_p) =
(yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p);
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
goto yy_match;
case EOB_ACT_LAST_MATCH:
(yy_c_buf_p) =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p);
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
goto yy_find_action;
}
break;
}
default:
YY_FATAL_ERROR(
"fatal flex scanner internal error--no action found" );
} /* end of action switch */
} /* end of scanning one token */
} /* end of yylex */
/* The contents of this function are C++ specific, so the () macro is not used.
*/
yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
{
yyin = arg_yyin;
yyout = arg_yyout;
yy_c_buf_p = 0;
yy_init = 0;
yy_start = 0;
yy_flex_debug = 0;
yylineno = 1; // this will only get updated if %option yylineno
yy_did_buffer_switch_on_eof = 0;
yy_looking_for_trail_begin = 0;
yy_more_flag = 0;
yy_more_len = 0;
yy_more_offset = yy_prev_more_offset = 0;
yy_start_stack_ptr = yy_start_stack_depth = 0;
yy_start_stack = NULL;
yy_buffer_stack = 0;
yy_buffer_stack_top = 0;
yy_buffer_stack_max = 0;
yy_state_buf = 0;
}
/* The contents of this function are C++ specific, so the () macro is not used.
*/
yyFlexLexer::~yyFlexLexer()
{
delete [] yy_state_buf;
cfree(yy_start_stack );
yy_delete_buffer( YY_CURRENT_BUFFER );
cfree(yy_buffer_stack );
}
/* The contents of this function are C++ specific, so the () macro is not used.
*/
void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
{
if ( new_in )
{
yy_delete_buffer( YY_CURRENT_BUFFER );
yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
}
if ( new_out )
yyout = new_out;
}
#ifdef YY_INTERACTIVE
int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
#else
int yyFlexLexer::LexerInput( char* buf, int max_size )
#endif
{
if ( yyin->eof() || yyin->fail() )
return 0;
#ifdef YY_INTERACTIVE
yyin->get( buf[0] );
if ( yyin->eof() )
return 0;
if ( yyin->bad() )
return -1;
return 1;
#else
(void) yyin->read( buf, max_size );
if ( yyin->bad() )
return -1;
else
return yyin->gcount();
#endif
}
void yyFlexLexer::LexerOutput( const char* buf, int size )
{
(void) yyout->write( buf, size );
}
/* yy_get_next_buffer - try to read in a new buffer
*
* Returns a code representing an action:
* EOB_ACT_LAST_MATCH -
* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
* EOB_ACT_END_OF_FILE - end of file
*/
int yyFlexLexer::yy_get_next_buffer()
{
register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
register char *source = (yytext_ptr);
register int number_to_move, i;
int ret_val;
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
YY_FATAL_ERROR(
"fatal flex scanner internal error--end of buffer missed" );
if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
{ /* Don't try to fill the buffer, so this is an EOF. */
if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
{
/* We matched a single character, the EOB, so
* treat this as a final EOF.
*/
return EOB_ACT_END_OF_FILE;
}
else
{
/* We matched some text prior to the EOB, first
* process it.
*/
return EOB_ACT_LAST_MATCH;
}
}
/* Try to read more data. */
/* First move last chars to start of buffer. */
number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
/* don't do the read, it's not guaranteed to return an EOF,
* just force an EOF
*/
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
else
{
int num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
{ /* Not enough room in the buffer - grow it. */
/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
int yy_c_buf_p_offset =
(int) ((yy_c_buf_p) - b->yy_ch_buf);
if ( b->yy_is_our_buffer )
{
int new_size = b->yy_buf_size * 2;
if ( new_size <= 0 )
b->yy_buf_size += b->yy_buf_size / 8;
else
b->yy_buf_size *= 2;
b->yy_ch_buf = (char *)
/* Include room in for 2 EOB chars. */
crealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
}
else
/* Can't grow it, we don't own it. */
b->yy_ch_buf = 0;
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(
"fatal error - scanner input buffer overflow" );
(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
number_to_move - 1;
}
if ( num_to_read > YY_READ_BUF_SIZE )
num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
(yy_n_chars), (size_t) num_to_read );
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
if ( (yy_n_chars) == 0 )
{
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
yyrestart( yyin );
}
else
{
ret_val = EOB_ACT_LAST_MATCH;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
YY_BUFFER_EOF_PENDING;
}
}
else
ret_val = EOB_ACT_CONTINUE_SCAN;
if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
/* Extend the array by 50%, plus the number we really need. */
yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) crealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
}
(yy_n_chars) += number_to_move;
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
return ret_val;
}
/* yy_get_previous_state - get the state just before the EOB char was reached */
yy_state_type yyFlexLexer::yy_get_previous_state()
{
register yy_state_type yy_current_state;
register char *yy_cp;
yy_current_state = (yy_start);
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
{
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 190 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
}
return yy_current_state;
}
/* yy_try_NUL_trans - try to make a transition on the NUL character
*
* synopsis
* next_state = yy_try_NUL_trans( current_state );
*/
yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
{
register int yy_is_jam;
register char *yy_cp = (yy_c_buf_p);
register YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 190 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_is_jam = (yy_current_state == 189);
return yy_is_jam ? 0 : yy_current_state;
}
void yyFlexLexer::yyunput( int c, register char* yy_bp)
{
register char *yy_cp;
yy_cp = (yy_c_buf_p);
/* undo effects of setting up yytext */
*yy_cp = (yy_hold_char);
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
register int number_to_move = (yy_n_chars) + 2;
register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
register char *source =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
*--dest = *--source;
yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
}
*--yy_cp = (char) c;
if ( c == '\n' ){
--yylineno;
}
(yytext_ptr) = yy_bp;
(yy_hold_char) = *yy_cp;
(yy_c_buf_p) = yy_cp;
}
int yyFlexLexer::yyinput()
{
int c;
*(yy_c_buf_p) = (yy_hold_char);
if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
{
/* yy_c_buf_p now points to the character we want to return.
* If this occurs *before* the EOB characters, then it's a
* valid NUL; if not, then we've hit the end of the buffer.
*/
if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
/* This was really a NUL. */
*(yy_c_buf_p) = '\0';
else
{ /* need more input */
int offset = (yy_c_buf_p) - (yytext_ptr);
++(yy_c_buf_p);
switch ( yy_get_next_buffer( ) )
{
case EOB_ACT_LAST_MATCH:
/* This happens because yy_g_n_b()
* sees that we've accumulated a
* token and flags that we need to
* try matching the token before
* proceeding. But for input(),
* there's no matching to consider.
* So convert the EOB_ACT_LAST_MATCH
* to EOB_ACT_END_OF_FILE.
*/
/* Reset buffer status. */
yyrestart( yyin );
/*FALLTHROUGH*/
case EOB_ACT_END_OF_FILE:
{
if ( yywrap( ) )
return EOF;
if ( ! (yy_did_buffer_switch_on_eof) )
YY_NEW_FILE;
#ifdef __cplusplus
return yyinput();
#else
return input();
#endif
}
case EOB_ACT_CONTINUE_SCAN:
(yy_c_buf_p) = (yytext_ptr) + offset;
break;
}
}
}
c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
*(yy_c_buf_p) = '\0'; /* preserve yytext */
(yy_hold_char) = *++(yy_c_buf_p);
if ( c == '\n' )
yylineno++;
;
return c;
}
/** Immediately switch to a different input stream.
* @param input_file A readable stream.
*
* @note This function does not reset the start condition to @c INITIAL .
*/
void yyFlexLexer::yyrestart( std::istream* input_file )
{
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer( yyin, YY_BUF_SIZE );
}
yy_init_buffer( YY_CURRENT_BUFFER, input_file );
yy_load_buffer_state( );
}
/** Switch to a different input buffer.
* @param new_buffer The new input buffer.
*
*/
void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
{
/* TODO. We should be able to replace this entire function body
* with
* yypop_buffer_state();
* yypush_buffer_state(new_buffer);
*/
yyensure_buffer_stack ();
if ( YY_CURRENT_BUFFER == new_buffer )
return;
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
YY_CURRENT_BUFFER_LVALUE = new_buffer;
yy_load_buffer_state( );
/* We don't actually know whether we did this switch during
* EOF (yywrap()) processing, but the only time this flag
* is looked at is after yywrap() is called, so it's safe
* to go ahead and always set it.
*/
(yy_did_buffer_switch_on_eof) = 1;
}
void yyFlexLexer::yy_load_buffer_state()
{
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
(yy_hold_char) = *(yy_c_buf_p);
}
/** Allocate and initialize an input buffer state.
* @param file A readable stream.
* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
*
* @return the allocated buffer state.
*/
YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file, int size )
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) calloc(sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size given because
* we need to put in 2 end-of-buffer characters.
*/
b->yy_ch_buf = (char *) calloc(b->yy_buf_size + 2 );
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_is_our_buffer = 1;
yy_init_buffer( b, file );
return b;
}
/** Destroy the buffer.
* @param b a buffer created with yy_create_buffer()
*
*/
void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
{
if ( ! b )
return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
cfree((void *) b->yy_ch_buf );
cfree((void *) b );
}
extern "C" int isatty (int );
/* Initializes or reinitializes a buffer.
* This function is sometimes called more than once on the same buffer,
* such as during a yyrestart() or at EOF.
*/
void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
{
int oerrno = errno;
yy_flush_buffer( b );
b->yy_input_file = file;
b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_
* called from yyrestart() or through yy_get_next_buffer.
* In that case, we don't want to reset the lineno or column.
*/
if (b != YY_CURRENT_BUFFER){
b->yy_bs_lineno = 1;
b->yy_bs_column = 0;
}
b->yy_is_interactive = 0;
errno = oerrno;
}
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
*
*/
void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
{
if ( ! b )
return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes
* a transition to the end-of-buffer state. The second causes
* a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
yy_load_buffer_state( );
}
/** Pushes the new state onto the stack. The new state becomes
* the current state. This function will allocate the stack
* if necessary.
* @param new_buffer The new state.
*
*/
void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
{
if (new_buffer == NULL)
return;
yyensure_buffer_stack();
/* This block is copied from yy_switch_to_buffer. */
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
/* Only push if top exists. Otherwise, replace top. */
if (YY_CURRENT_BUFFER)
(yy_buffer_stack_top)++;
YY_CURRENT_BUFFER_LVALUE = new_buffer;
/* copied from yy_switch_to_buffer. */
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
/** Removes and deletes the top of the stack, if present.
* The next element becomes the new top.
*
*/
void yyFlexLexer::yypop_buffer_state (void)
{
if (!YY_CURRENT_BUFFER)
return;
yy_delete_buffer(YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;
if ((yy_buffer_stack_top) > 0)
--(yy_buffer_stack_top);
if (YY_CURRENT_BUFFER) {
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
}
/* Allocates the stack if it does not exist.
* Guarantees space for at least one push.
*/
void yyFlexLexer::yyensure_buffer_stack(void)
{
int num_to_alloc;
if (!(yy_buffer_stack)) {
/* First allocation is just for 2 elements, since we don't know if this
* scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call.
*/
num_to_alloc = 1;
(yy_buffer_stack) = (struct yy_buffer_state**)calloc
(num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
(yy_buffer_stack_max) = num_to_alloc;
(yy_buffer_stack_top) = 0;
return;
}
if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
/* Increase the buffer to prepare for a possible push. */
int grow_size = 8 /* arbitrary grow size */;
num_to_alloc = (yy_buffer_stack_max) + grow_size;
(yy_buffer_stack) = (struct yy_buffer_state**)crealloc
((yy_buffer_stack),
num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
/* zero only the new slots.*/
memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
(yy_buffer_stack_max) = num_to_alloc;
}
}
void yyFlexLexer::yy_push_state( int new_state )
{
if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
{
yy_size_t new_size;
(yy_start_stack_depth) += YY_START_STACK_INCR;
new_size = (yy_start_stack_depth) * sizeof( int );
if ( ! (yy_start_stack) )
(yy_start_stack) = (int *) calloc(new_size );
else
(yy_start_stack) = (int *) crealloc((void *) (yy_start_stack),new_size );
if ( ! (yy_start_stack) )
YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
}
(yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
BEGIN(new_state);
}
void yyFlexLexer::yy_pop_state()
{
if ( --(yy_start_stack_ptr) < 0 )
YY_FATAL_ERROR( "start-condition stack underflow" );
BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
}
int yyFlexLexer::yy_top_state()
{
return (yy_start_stack)[(yy_start_stack_ptr) - 1];
}
#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif
void yyFlexLexer::LexerError( yyconst char msg[] )
{
std::cerr << msg << std::endl;
exit( YY_EXIT_FAILURE );
}
/* Redefine yyless() so it works in section 3 code. */
#undef yyless
#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
yytext[yyleng] = (yy_hold_char); \
(yy_c_buf_p) = yytext + yyless_macro_arg; \
(yy_hold_char) = *(yy_c_buf_p); \
*(yy_c_buf_p) = '\0'; \
yyleng = yyless_macro_arg; \
} \
while ( 0 )
/* Accessor methods (get/set functions) to struct members. */
/*
* Internal utility routines.
*/
#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
{
register int i;
for ( i = 0; i < n; ++i )
s1[i] = s2[i];
}
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * s )
{
register int n;
for ( n = 0; s[n]; ++n )
;
return n;
}
#endif
void *calloc (yy_size_t size )
{
return (void *) malloc( size );
}
void *crealloc (void * ptr, yy_size_t size )
{
/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latter
* because both ANSI C and C++ allow castless assignment from
* any pointer type to void*, and deal with argument conversions
* as though doing an assignment.
*/
return (void *) realloc( (char *) ptr, size );
}
void cfree (void * ptr )
{
free( (char *) ptr ); /* see crealloc() for (char *) cast */
}
#define YYTABLES_NAME "yytables"
#line 120 "/home/tovok7/svn/potassco/coala/src/lib/c/Scanner.l"
coala-1.0.1_src/src/lib/c/Formula.cpp 000644 001750 001750 00000020627 11477164507 020076 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/Formula.cpp - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#include "Formula.h"
#include "FluentAction.h"
using namespace C;
Formula::Formula() {
I_ = new vector();
type_ = '?';
}
Formula::Formula(char type, Formula* identifier) {
type_ = type;
I_ = new vector(1, identifier);
}
Formula::Formula(char type, vector* vec) {
type_ = type;
if(vec == NULL) I_ = new vector();
else I_ = vec;
}
Formula::~Formula () {
delete I_;
}
void Formula::addPart(Formula* identifier) {
I_->push_back(identifier);
}
char Formula::getType() {
return type_;
}
Formula* Formula::getFirstFormula() {
return I_->at(0);
}
vector::iterator Formula::begin() {
return I_->begin();
}
vector::iterator Formula::end() {
return I_->end();
}
void Formula::insert(vector::iterator loc, vector::iterator begin, vector::iterator end) {
I_->insert(loc, begin, end);
}
Formula* Formula::invert() {
if(getType() == 'c') {
for(vector::iterator n = I_->begin(); n != I_->end(); ++n) {
*n = (*n)->invert();
}
return this;
}
else if(getType() == '_') {
return new Formula('n', new vector(1, this));
}
else if(getType() == 'n') {
return (Formula*) I_->at(0);
}
else {
return this;
}
}
bool Formula::isTrue() {
if(I_->size() == 1 && I_->at(0)->getType() == '_' && ((FluentAction*)I_->at(0))->getName() == "0") return true;
else return false;
}
bool Formula::isFalse() {
if(getType() == 'n' && I_->size() == 1 && I_->at(0)->getType() == '_' && ((FluentAction*)I_->at(0))->getName() == "0") return true;
else return false;
}
FluentAction* Formula::getFluentAction() {
if(getType() == '_') return (FluentAction*) this;
else if(getType() == 'n' && I_->size() == 1 && I_->at(0)->getType() == '_') return (FluentAction*) I_->at(0);
else throw std::runtime_error("getFluentAction() was called in wrong context. Please notify the author!");
}
// TODO check if this can be generalized for every Type of Formula (FluentAction as well)
void Formula::print(Printer* p, set* vars, string T) {
assert(p->no_direct_enc);
if(I_->empty()) {
p->add("\"true\"");
}
else if(I_->size() == 1) {
FluentAction* f;
bool neg;
if(I_->at(0)->getType() == 'n') {
f = (FluentAction*) I_->at(0)->getFirstFormula();
neg = true;
}
else {
f = (FluentAction*) I_->at(0);
neg = false;
}
if(neg) p->add("neg(" + f->print(p, T) + ")");
else p->add(f->print(p, T));
// get the vars
set* tmp_vars = f->getVariables();
if(!tmp_vars->empty())
vars->insert(tmp_vars->begin(), tmp_vars->end());
delete tmp_vars;
}
else {
p->add("and(");
for(vector::iterator n = I_->begin(); n != I_->end(); ++n) {
FluentAction* f;
bool neg;
if((*n)->getType() == 'n') {
f = (FluentAction*) (*n)->getFirstFormula();
neg = true;
}
else {
f = (FluentAction*) *n;
neg = false;
}
if(neg) p->add("neg(" + f->print(p, T) + ")");
else p->add(f->print(p, T));
if(n != I_->end()-1) p->add(", ");
// get the vars
set* tmp_vars = f->getVariables();
if(!tmp_vars->empty())
vars->insert(tmp_vars->begin(), tmp_vars->end());
}
p->add(")");
}
}
void Formula::printAlsoActions(Printer* p, set* vars, string T) {
string F = "";
string A = "";
int f = 0;
int a = 0;
FluentAction* i;
bool neg;
for(vector::iterator n = I_->begin(); n != I_->end(); ++n) {
// check for negation
if((*n)->getType() == 'n') {
i = (FluentAction*) (*n)->getFirstFormula();
neg = true;
}
else {
i = (FluentAction*) *n;
neg = false;
}
if(i->getClass() == "Fluent") {
if(f > 0) F += ", ";
if(neg) {
if(p->no_direct_enc) F += "neg(";
else F += p->neg;
F += i->print(p, T);
if(p->no_direct_enc) F += ")";
}
else F += i->print(p, T);
f++;
}
else {
if(a > 0) A += ", ";
if(neg) {
if(p->no_direct_enc) A += "neg(";
else A += p->neg;
A += i->print(p, T);
if(p->no_direct_enc) A += ")";
}
else A += i->print(p, T);
a++;
}
// get the vars
set* tmp_vars = i->getVariables();
if(!tmp_vars->empty())
vars->insert(tmp_vars->begin(), tmp_vars->end());
}
if(p->no_direct_enc) {
if(f == 0) F = "\"true\"";
else if(f > 1) F = "and("+F+")";
if(a == 0) A = "\"true\"";
else if(a > 1) A = "and("+A+")";
p->add(F + ", " + A);
}
else {
p->add(F);
if(f != 0 && a != 0) p->add(", ");
p->add(A);
}
}
void Formula::printCompositeFluents(Printer* p, Types* types) {
if(I_->size() > 1) {
set vars;
// print cfluent
p->add("cfluent(");
print(p, &vars);
p->add(")");
if(vars.empty()) p->add(".\n");
else {
p->add(" :- ");
types->print(p, &vars, 0);
p->add(".\n");
}
// print fpart
for(vector::iterator n = I_->begin(); n != I_->end(); ++n) {
FluentAction* f;
bool neg;
if((*n)->getType() == 'n') {
f = (FluentAction*) (*n)->getFirstFormula();
neg = true;
}
else {
f = (FluentAction*) *n;
neg = false;
}
p->add("fpart(");
print(p, &vars);
p->add(", ");
if(neg) p->add("neg(" + f->print(p, "") + ")");
else p->add(f->print(p, ""));
p->add(")");
if(vars.empty()) p->add(".\n");
else {
p->add(" :- ");
types->print(p, &vars, 0);
p->add(".\n");
}
}
} // end if size>1
}
void Formula::printCompositeFluentActions(Printer* p, Types* types) {
string F = "";
vector Fs = vector();
set F_vars;
string A = "";
vector As = vector();
set A_vars;
int f = 0;
int a = 0;
for(vector::iterator n = I_->begin(); n != I_->end(); ++n) {
FluentAction* i;
bool neg;
if((*n)->getType() == 'n') {
i = (FluentAction*) (*n)->getFirstFormula();
neg = true;
}
else {
i = (FluentAction*) *n;
neg = false;
}
if(i->getClass() == "Fluent") {
if(f > 0) F += ", ";
f++;
if(neg) {
F += "neg(" + i->print(p, "") + ")";
Fs.push_back("neg(" + i->print(p, "") + ")");
}
else {
F += i->print(p, "");
Fs.push_back(i->print(p, ""));
}
set* tmp_vars = i->getVariables();
if(!tmp_vars->empty())
F_vars.insert(tmp_vars->begin(), tmp_vars->end());
}
else {
if(a > 0) A += ", ";
a++;
if(neg) {
A += "neg(" + i->print(p, "") + ")";
As.push_back("neg(" + i->print(p, "") + ")");
}
else {
A += i->print(p, "");
As.push_back(i->print(p, ""));
}
set* tmp_vars = i->getVariables();
if(!tmp_vars->empty())
A_vars.insert(tmp_vars->begin(), tmp_vars->end());
}
}
if(f > 1) {
p->add("cfluent(and("+F+"))");
if(F_vars.empty()) p->add(".\n");
else {
p->add(" :- ");
types->print(p, &F_vars, 0);
p->add(".\n");
}
for(vector::iterator n = Fs.begin(); n != Fs.end(); ++n) {
p->add("fpart(and("+F+"), "+*n+")");
if(F_vars.empty()) p->add(".\n");
else {
p->add(" :- ");
types->print(p, &F_vars, 0);
p->add(".\n");
}
}
}
if(a > 1) {
p->add("caction(and("+A+"))");
if(A_vars.empty()) p->add(".\n");
else {
p->add(" :- ");
types->print(p, &A_vars, 0);
p->add(".\n");
}
for(vector::iterator n = As.begin(); n != As.end(); ++n) {
p->add("apart(and("+A+"), "+*n+")");
if(A_vars.empty()) p->add(".\n");
else {
p->add(" :- ");
types->print(p, &A_vars, 0);
p->add(".\n");
}
}
}
}
coala-1.0.1_src/src/lib/c/Program.cpp 000644 001750 001750 00000022660 11477164507 020077 0 ustar 00tovok7 tovok7 000000 000000 /****************************************************************************
* lib/c/Program.cpp - This file is part of coala *
* *
* Copyright (C) 2009 Torsten Grote *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, see http://www.gnu.org/licenses *
****************************************************************************/
#include "Program.h"
#include "Parser.h"
using namespace C;
Program::Program(Coala::CompilerOptions* options) {
options_ = options;
ltl_node_num_ = 1;
ltlquery_ = NULL;
// true/false fluent
fluents_.insert( make_pair("0", new FluentAction(new string("0"))) );
}
Program::~Program() {
for(map::iterator n = fluents_.begin(); n != fluents_.end(); ++n) {
delete n->second;
}
}
void Program::setLine(int* line) {
line_ = line;
}
Variable* Program::addVariable(string* name) {
map::iterator iter = variables_.find(*name);
if(iter != variables_.end()) {
return variables_[*name];
}
else {
Variable* var = new Variable(name);
variables_.insert(make_pair(*name, var));
return var;
}
}
Formula* Program::addFormula(char type, Formula* identifier) {
// TODO check for duplicates
return new Formula(type, identifier);
}
Formula* Program::addFormula(char type, vector* vec) {
// TODO check for duplicates
return new Formula(type, vec);
}
bool Program::addAction(FluentAction* action) {
pair::iterator,bool> result = actions_.insert( make_pair(action->getName(), action) );
return result.second;
}
void Program::addActionDef(Formula* action_list, Types* types) {
FluentAction* a;
for(vector::iterator action = action_list->begin(); action != action_list->end(); action++) {
a = (FluentAction*) *action;
a->setClass("Action");
if(!addAction(a))
cerr << "Warning: action " << a->getName() << " defined multiple times at line " << *line_ << ".\n";
}
action_definitions_.push_back(new ActionDefinition(*line_, action_list, types));
}
bool Program::addFluent(FluentAction* fluent) {
pair::iterator,bool> result = fluents_.insert( make_pair(fluent->getName(), (FluentAction*)fluent) );
return result.second;
}
void Program::addFluentDef(Formula* fluent_list, Types* types) {
FluentAction* f;
for(vector::iterator fluent = fluent_list->begin(); fluent != fluent_list->end(); fluent++) {
if((*fluent)->getType() == 'n') {
cerr << "Warning: fluent '" << f->getName() << "' can not be defined negatively at line " << *line_ << ".\n";
f = (*fluent)->getFluentAction();
*fluent = f;
}
else f = (FluentAction*) *fluent;
f->setClass("Fluent");
if(!addFluent(f))
cerr << "Warning: fluent '" << f->getName() << "' defined multiple times at line " << *line_ << ".\n";
}
fluent_definitions_.push_back(new FluentDefinition(*line_, fluent_list, types));
}
void Program::addStaticRule(Formula* F, Formula* G, Types* types) {
if(options_->getLanguage() == "c") {
transformFormula(F, "Fluent");
transformFormula(G, "Fluent");
}
else if(options_->getLanguage() == "m") {
transformFormula(F, "Action");
transformFormula(G, "Action");
}
static_rules_.push_back(new StaticRule(*line_, F, G, types));
}
void Program::addDynamicRule(Formula* F, Formula* G, Formula* H, Types* types) {
transformFormula(F, "Fluent");
transformFormula(G, "Fluent");
transformFormula(H, "Action");
dynamic_rules_.push_back(new DynamicRule(*line_, F, G, H, types));
}
// f_1,...,f_n g_1,...,g_m = f f_1, g_1,...,g_m
void Program::addDefaultRule(Formula* F, Formula* G, Types* types) {
for(vector::iterator n = F->begin(); n != F->end(); ++n) {
Formula* F_new = addFormula(F->getType(), *n);
vector* G_new = new vector(1, *n);
if(G) G_new->insert(G_new->end(), G->begin(), G->end());
addStaticRule(F_new, addFormula('c', G_new), types);
}
delete F;
delete G;
}
// f_1, ..., f_n = f f f
void Program::addInertialRule(Formula* F, Types* types) {
for(vector::iterator n = F->begin(); n != F->end(); ++n) {
Formula* F_new = addFormula(F->getType(), *n);
addDynamicRule(F_new, F_new, F_new, types);
}
delete F;
}
// a1,...,a_o f_1, ..., f_n g_1, ..., g_m = f g, a
void Program::addCausesRule(Formula* A, Formula* F, Formula* G, Types* types) {
Formula* G_new;
if(G) {
G->insert(G->begin(), A->begin(), A->end());
G_new = G;
}
else {
G_new = A;
}
addDynamicRule(F, NULL, G_new, types);
// Don't delete G here since it is G_new as well
}
// f_1, ..., f_n =