diff --git a/INSTALL b/INSTALL new file mode 100644 index 0000000..4088fdd --- /dev/null +++ b/INSTALL @@ -0,0 +1,45 @@ +-------------------------------------------------- + Reasonable Python - INSTALLATION +-------------------------------------------------- + +CAUTION: Reasonable Python was only tested on kubuntu +linux (using XSB and Flora2). If you manage to get it +to work on another platform please let me know, I'll +be pleased to add your solution to the project. + +Installation should be performed in the following way. +Since you are reading this document I assume you +allready untared the Reasonable Python tar archive to +a folder, say ~/reasonable. + +First thing to do, if you didn't allready, is to install: + +- XSB Prolog engine (http://xsb.sourceforge.net) +- Flora2 (http://flora.sourceforge.net) +- ZODB (http://www.zope.org/Products/StandaloneZODB) + +After this steps first build Reasonable Python by +issuing: + +~/reasonable/python setup.py build --xsb /path/to/xsb --flora2 /path/to/flora2 + +Where /path/to/xsb is the path to yout XSB installation, +and /path/to/flora2 the path tou yout Flora2 installation. + +Additionally you can (should?) add the option: + +--platform your-platform + +Where your-platform is the platform specified in the +path/to/xsb/config directory. + +If build doesn't complain about any errors issue as +superuser: + +python setup.py install + +If nothing went wrong you should be able to use +Reasonable Python within your python installation +now. + +-------------------------------------------------- diff --git a/LICENCE b/LICENCE new file mode 100644 index 0000000..9069922 --- /dev/null +++ b/LICENCE @@ -0,0 +1,256 @@ + +GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 +Copyright (C) 1991, 1999 Free Software Foundation, Inc. +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +Everyone is permitted to copy and distribute verbatim copies +of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + +Preamble + The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU +General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the +software is free for all its users. + This license, the Lesser General Public License, applies to some specially designated software packages--typically +libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest +you first think carefully about whether this license or the ordinary General Public License is the better strategy to +use in any particular case, based on the explanations below. + When we speak of free software, we are referring to freedom of use, 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 this service if +you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces +of it in new free programs; and that you are informed that you can do these things. + To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you +to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies +of the library or if you modify it. + For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all +the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other +code with the library, you must provide complete object files to the recipients, so that they can relink them with +the library after making changes to the library and recompiling it. And you must show them these terms so they know +their rights. + We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, +which gives you legal permission to copy, distribute and/or modify the library. + To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if +the library is modified by someone else and passed on, the recipients should know that what they have is not the +original version, so that the original author's reputation will not be affected by problems that might be introduced +by others. + Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a +company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent +holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with +the full freedom of use specified in this license. + Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, +the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the +ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries +into non-free programs. + When a program is linked with a library, whether statically or using a shared library, the combination of the two is +legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore +permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License +permits more lax criteria for linking other code with the library. + We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the +ordinary General Public License. It also provides other free software developers Less of an advantage over competing +non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. +However, the Lesser license provides advantages in certain special circumstances. + For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain +library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the +library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public +License. + In other cases, permission to use a particular library in non-free programs enables a greater number of people to +use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many +more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. + Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of +a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified +version of the Library. + The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the +difference between a "work based on the library" and a "work that uses the library". The former contains code derived +from the library, whereas the latter must be combined with the library in order to run. +TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION +0. This License Agreement applies to any software library or other program which contains a notice placed by the +copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public +License (also called "this License"). Each licensee is addressed as "you". + A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with +application programs (which use some of those functions and data) to form executables. + The "Library", below, refers to any such software library or work which has been distributed under these terms. A +"work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a +work containing the Library or a portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is included without limitation in the term +"modification".) + "Source code" for a work means the preferred form of the work for making modifications to it. For a library, +complete source code means all the source code for all modules it contains, plus any associated interface definition +files, plus the scripts used to control compilation and installation of the library. + Activities other than copying, distribution and modification are not covered by this License; they are outside its +scope. The act of running a program using the Library is not restricted, and output from such a program is covered +only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. +1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any +medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and +disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; +and distribute a copy of this License along with the Library. + You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty +protection in exchange for a fee. +2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, +and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet +all of these conditions: +a) The modified work must itself be a software library. +b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of +any change. +c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this +License. +d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application +program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a +good faith effort to ensure that, in the event an application does not supply such function or table, the facility +still operates, and performs whatever part of its purpose remains meaningful. + (For example, a function in a library to compute square roots has a purpose that is entirely well-defined +independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table +used by this function must be optional: if the application does not supply it, the square root function must still +compute square roots.) + These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from +the Library, and can be reasonably considered independent and separate works in themselves, then this License, and +its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the +same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the +terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every +part regardless of who wrote it. + Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; +rather, the intent is to exercise the right to control the distribution of derivative or collective works based on +the Library. + In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the +Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this +License. +3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy +of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the +ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make +any other change in these notices. + Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public +License applies to all subsequent copies and derivative works made from that copy. + This option is useful when you wish to copy part of the code of the Library into a program that is not a library. +4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or +executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete +corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + If distribution of object code is made by offering access to copy from a designated place, then offering equivalent +access to copy the source code from the same place satisfies the requirement to distribute the source code, even +though third parties are not compelled to copy the source along with the object code. +5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by +being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a +derivative work of the Library, and therefore falls outside the scope of this License. + However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the +Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is +therefore covered by this License. Section 6 states terms for distribution of such executables. + When a "work that uses the Library" uses material from a header file that is part of the Library, the object code +for the work may be a derivative work of the Library even though the source code is not. Whether this is true is +especially significant if the work can be linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and +small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of +whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will +still fall under Section 6.) + Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the +terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked +directly with the Library itself. +6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the +Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, +provided that the terms permit modification of the work for the customer's own use and reverse engineering for +debugging such modifications. + You must give prominent notice with each copy of the work that the Library is used in it and that the Library and +its use are covered by this License. You must supply a copy of this License. If the work during execution displays +copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing +the user to the copy of this License. Also, you must do one of these things: +a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever +changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an +executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code +and/or source code, so that the user can modify the Library and then relink to produce a modified executable +containing the modified Library. (It is understood that the user who changes the contents of definitions files in the +Library will not necessarily be able to recompile the application to use the modified definitions.) +b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at +run time a copy of the library already present on the user's computer system, rather than copying library functions +into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, +as long as the modified version is interface-compatible with the version that the work was made with. +c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials +specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. +d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to +copy the above specified materials from the same place. +e) Verify that the user has already received a copy of these materials or that you have already sent this user a +copy. + For an executable, the required form of the "work that uses the Library" must include any data and utility programs +needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need +not include anything that is normally distributed (in either source or binary form) with the major components +(compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself +accompanies the executable. + It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not +normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together +in an executable that you distribute. +7. You may place library facilities that are a work based on the Library side-by-side in a single library together +with other library facilities not covered by this License, and distribute such a combined library, provided that the +separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, +and provided that you do these two things: +a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other +library facilities. This must be distributed under the terms of the Sections above. +b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and +explaining where to find the accompanying uncombined form of the same work. +8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this +License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will +automatically terminate your rights under this License. However, parties who have received copies, or rights, from +you under this License will not have their licenses terminated so long as such parties remain in full compliance. +9. You are not required to accept this License, since you have not signed it. However, nothing else grants you +permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do +not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you +indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or +modifying the Library or works based on it. +10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a +license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and +conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You +are not responsible for enforcing compliance by third parties with this License. +11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not +limited to patent issues), 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 +distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, +then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit +royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to refrain entirely from distribution of the +Library. + If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of +the section is intended to apply, and the section as a whole is intended to apply in other circumstances. + It is not the purpose of this section to induce you to infringe any patents or other property right claims or to +contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free +software distribution system which is implemented by public license practices. Many people have made generous +contributions to the wide range of software distributed through that system in reliance on consistent application of +that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other +system and a licensee cannot impose that choice. + This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. +12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by +copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit +geographical distribution limitation excluding those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this +License. +13. The Free Software Foundation may publish revised and/or new versions of the Lesser 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 Library specifies a version number of this License +which applies to it and "any later version", you have the option of following the terms and conditions either of that +version or of any later version published by the Free Software Foundation. If the Library does not specify a license +version number, you may choose any version ever published by the Free Software Foundation. +14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are +incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will +be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the +sharing and reuse of software generally. +NO WARRANTY +15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE +LIBRARY "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 LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. +16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER +PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY 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 LIBRARY +(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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN +ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +END OF TERMS AND CONDITIONS + + + diff --git a/PKG-INFO b/PKG-INFO new file mode 100644 index 0000000..4dec6f8 --- /dev/null +++ b/PKG-INFO @@ -0,0 +1,10 @@ +Metadata-Version: 1.0 +Name: ReasonablePython +Version: 0.1.2 +Summary: UNKNOWN +Home-page: http://reasonablepy.sourcforge.net +Author: Markus Schatten +Author-email: markus.schatten@foi.hr +License: UNKNOWN +Description: UNKNOWN +Platform: UNKNOWN diff --git a/README b/README new file mode 100644 index 0000000..fcb2449 --- /dev/null +++ b/README @@ -0,0 +1,270 @@ +-------------------------------------------------------- + Reasonable Python - README +-------------------------------------------------------- + +Reasonable Python is a module which adds F-Logic to Python. +This is an initial package and is still pretty unstable. +Any bug repport is very appriciated. + +Here some introduction on how to use the package (it's a +copy/paste from a paper I wrote, but some basic information +is included). I'll try to write an easy to understand tutorial +as soon as possible. + +To import Reasonable Python use: + + >>> from rp import * + + Most important logic programming concepts to introduce +into Python addressed here are logic variables, facts, rules and +queries. In FLORA-2 logic variables are denoted by any word +starting with an uppercase letter or the underscore (’_’). A +similar way is used in Python, by creating a class of objects +named Variable which behavior is shown in the following +Python interactive shell session. + + >>> X = f.Variable( ’X’ ) + >>> X + + >>> print X + X + >>> X == 27 + >>> print X + X = 27 + + When analyzing facts, rules and queries we can conclude +that they are all instances of a construct which has the form: + + Head : −Body. (1) + + : −Body. (2) + + Head : − . (3) + + (1) is a rule where Head is the rule head, and Body is +the rule body (denoted by Head :- Body.). (2) is a query +where Body is the query string (denoted by ?- Body.). (3) +is a fact where Head is the actual fact (denoted by Head.). +We can conclude that we need only one class when introducing +these concepts into Python which behavior is shown in the +following interactive shell session (where Bogus is a logical +class as argued further). + + >>> x = f.Construct() + >>> print x + >>> h, b1, b2 = f.Bogus(), f.Bogus(), + f.Bogus() + >>> x & h + >>> x.__class__ + + >>> del x + >>> x = f.Construct() + >>> x << b1 & b2 + >>> x.__class__ + + >>> del x + >>> x = f.Construct() + >>> ( x & h ) << b1 | b2 + >>> x.__class__ + + + + One can see that x which is an instance of the Construct +class dynamically changes its class to Fact, Rule or Query +according to its content (e. g. its head and body). The bitwise +shift (’<<’), the bitwise or (’|’) and the bitwise and (’&’) were +overridden in order to allow logic programming constructs, +and stand for ’:-’, ’;’ and ’,’ respectively. This means that +a logic programming construct like: + + X :− (Y , Z) ; W. (4) + + in Python would be written like: + + X << (Y & Z) | W. (5) + + Which is similar to both FLORA-2 and Python syntax. In +addition to these two classes some additional classes were +defined to ease such behavior. + + + Another task to be accomplished is the translation of Python +objects into F-molecules in FLORA-2 syntax in order to allow +reasoning about them. Python has a feature which eases this +translation and can be seen in the following interactive shell +session. + + >>> class a: + ... def __init__ ( self, b1 = 1, b2 = 2 ): + ... self.b1 = b1 + ... self.b2 = b2 + ... + >>> y = a() + >>> dir( y ) + [’__doc__’, '__init__’, ’__module__’, ’b1’, ’b2’] + >>> y. dict + ’b1’: 1, ’b2’: 2 + >>> y.__class__ + + + We can conclude that Python objects allow us to query their +internal structure and content. Using this feature a multiple +recursive algorithm was developed which translates Python +objects into FLORA-2 F-molecules. For example the y object +from the example when translated into FLORA-2 would be: + + >>> tr = py2f.py2f() + >>> tr.f2obj( y ) + ’py0xb7db4e2cpyobj____main__py__ : + pyapyclass____main__py__ ["b1"->1, "b2"->2]’ + + To have unique object names in our knowledge base we +use the objects internal memory addresses and some additional +information about its module. When an object is translated it is +automatically stored in a ZOBD object base for later retrieval +and permanent storage. Python objects which are not logical +constructs as argued earlier, are considered to be facts. + + In order to use the FLORA-2 engine from Python an +interface had to be developed. FLORA-2 is build upon the +OpenSource XSB Prolog engine which is developed in C +and thus has a C interface [8]. The Simplified Wrapper and +Interface Generator (SWIG) was used to create an interface +between XSB and Python (but could be easily extended to +any other language supported by SWIG i. e. AllegroCL, C# - +Mono, C# - MS .NET, CFFI, CHICKEN, CLISP, Guile, Java, +Lua, MzScheme, Ocaml, Perl, PHP, Ruby, or Tcl/Tk). + Through such an interface FLORA-2 is then loaded as a +module into XSB. Additional wrapper classes were devel- +oped to ease communication between XSB and Python, and +FLORA-2 and Python, as shown in the following interactive +shell session. + >>> f = interface.Flora2() + [FLORA2 specific output] + >>> f.consult( ’test’ ) + [FLORA2 specific output] + >>> f.query( ’X:person[ Y -> Z ].’, [’X’, + ’Y’, ’Z’] ) + [{’Y’: ’age’, ’X’: ’mirko1’, ’Z’: ’40’},{’Y’: + ’age’, ’X’: ’mirko2’, ’Z’: ’42’}] + >>> f.close_query() + + We can conclude that such an interface allows for using +XSB and FLORA-2 engines from Python. Compiling and +loading of Prolog and FLORA-2 specific programs is also +supported. Queries can be issued directly whereas return +variables have to be provided in a Python list as the second +argument. The results of queries are Python lists which ele- +ments are Python dictionaries where each dictionary represents +one solution. Keys of each dictionary are the provided return +variables, and the matching values are the returned values from +the knowledge base. + + + After describing the particular parts of this integration +it is possible to connect all together in order to facilitate +logic programming in Python. All previously described parts +constitute a Python module. In addition to theses parts a new +class was defined which integrates them. In particular this class +represents an F-Logic base with storing and querying facilities. + Any object to be stored in to the knowledge base is first +stored in the ZODB in order to be persistent. Afterwards it is +translated into FLORA-2 syntax and loaded into the FLORA-2 +engine. Additionally the FLORA-2 code is saved in an external +file so the state can be restored later. This behavior of the +system is transparent to the Python programmer. + To query the knowledge base one can either use FLORA-2 +syntax or create special query objects using logical variables +and logical constructs. In the following interactive shell session +we first create a construct and define a logical class which we +will use for querying the knowledge base. + >>> x = Construct() + >>> class query object( Logical ): + ... def init ( self, a, b ): + ... Logical.__init__( self ) + ... self.a = a + ... self.b = b + + Now we can create a query object and modify it to fit our +needs. Note how it is possible to use a logical object to query +for any object of any class by overriding its type and class +type attributes with logical variables. We can also override the +names of attributes by inserting a logical variable in the place +of the attributes name. + + >>> q = query_object( Variable( ’X’ ), + Variable( ’Y’ ) ) + >>> x << q + >>> print x + ?- py0xb7d6cdacpyobj____main__py__ : + pyquery__objectpyclass__main__py__ [ + "b"->Y, "a"->X]. + >>> q.__type__ = Variable( ’Z’ ) + >>> print x + ?- Z : pyquery__objectpyclass__main__py__ [ + "b"->Y, "a"->X]. + >>> q.__classtype__ = Variable( ’W’ ) + >>> print x + ?- Z:W[ "b"->Y, "a"->X]. + >>> q.__dict__[ Variable( ’V’ ) ] = q.__dict__[ + ’a’ ] + >>> del q.__dict__[ ’a’ ] + >>> print x + ?- Z:W[ "b"->Y, V->X]. + >>> del q.__dict__[ ’b’ ] + >>> print x + ?- Z:W[ V->X ]. + + To query the knowledge base some facts and/or rules have +to be stored in it. A simple data object class which subclasses +the Persistent class is created in the following. + The subclassing allows all instances of the class to be stored +in the ZODB. Instances to be stored in the knowledge base +are also created in this interactive shell session. + >>> class data object( Persistent ): + ... def init ( self, a, b ): + ... self.a = a + ... self.b = b + ... + >>> d1 = data object( 1, 2 ) + >>> d2 = data object( 3, 4 ) + + Now it is possible to create the knowledge base which is +just an Python object like any other and insert the data objects. + + >>> fb = FBase( ’my flbase’ ) + [FLORA-2 specific output] + >>> fb.insert( d1 ) + [FLORA-2 specific output] + >>> fb.insert( d2 ) + [FLORA-2 specific output] + + By using the previously created query object the following +results are obtained. Note that the W variable returned the +string ’class’ which is due to the impossibility of ZODB to +store class objects (e. g. they are not persistent). + + >>> fb.query( x ) + [{’X’: ’1’, ’Z’: < main .data object +object at 0xb7dde96c>, ’W’: ’class’}, +{’X’: ’2’, ’Z’: < main .data object object +at 0xb7dde96c>, ’W’: ’class’}, {’X’: +’3’, ’Z’: < main .data object object at +0xb7c52aac>, ’W’: ’class’}, {’X’: ’4’, ’Z’: +< main .data object object at 0xb7c52aac>, +’W’: ’class’}] + + This simple example shows how transparent the knowledge +base is to a Python programmer. The programmer just has +to create an FBase object to store Python objects in the +knowledgde base. + To query the knowledge base query objects have to be +created. Using logic objects and logical variables this task is +intuitive and fair easy to accomplish. + + To add rules to the knowledge base one has to use constructs +in order to create them and store them. These rules are similar +to their Prolog and FLORA-2 counterparts with some minor +syntax differences still preserving the flexibility of normal +Python code. + diff --git a/rp/__init__.py b/rp/__init__.py new file mode 100644 index 0000000..1147212 --- /dev/null +++ b/rp/__init__.py @@ -0,0 +1,32 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/python + + + +__doc__ = ''' +Reasonable Python +A module for integrating F-logic into Python + +__init__.py --- makes most important objects available + +by Markus Schatten +Faculty of Organization and Informatics, +Varaždin, Croatia, 2007 + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +''' + +from reasonable import * diff --git a/rp/dbms.py b/rp/dbms.py new file mode 100644 index 0000000..91a1a65 --- /dev/null +++ b/rp/dbms.py @@ -0,0 +1,177 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/python + +__doc__ = ''' +Reasonable Python +A module for integrating F-logic into Python + +dbms.py --- easy interface to ZODB + +by Markus Schatten +Faculty of Organization and Informatics, +Varaždin, Croatia, 2007 + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +''' + +import ZODB +from ZODB import DB +from ZODB.FileStorage import FileStorage +import transaction + +class Objectbase: + ''' + Class Objectbase - interface to an object database + ''' + def __init__( self, dbfile = None ): + ''' + Initializes the connection to the database located in 'dbfile'. If + 'dbfile' not supplied, only initalizes and sets opened to False. If + database does not exist, creates a new one with the name 'dbfile' + ''' + if dbfile: + self.st = FileStorage( dbfile ) + self.db = DB( self.st ) + self.cn = self.db.open() + self.root = self.cn.root() + self.opened = True + else: + self.opened = False + + def selectByName( self, name ): + ''' + Returns the object with the key name. If database doesn't contain such an + object raises ValueError + ''' + if self.opened: + if self.root[ name ]: + return self.root[ name ] + else: + error = 'This database has no object with the name ' + name + raise ValueError, error + else: + error = 'Database is closed' + raise ValueError, error + + def selectByType( self, typ ): + ''' + Searches the database for a given type and returns a dictionary with + key:object pairs which match this type. If database doesn't contain any + object of the given type, returns an empty dictionary. + ''' + if self.opened: + objects = {} + for i in self.root: + if issubclass( type( self.root[ i ] ), typ ): + objects[ i ] = self.root[ i ] + return objects + else: + error = 'Database is closed' + raise ValueError, error + + def delete( self, name, cascade = False ): + ''' + Deletes an object from the database by it's key (name). If database + doesn't contain such an object raises ValueError. Parameter cascade is + used (if True) to delete all relations of this object in other objects. + Cascade option is not well implemented since it does not roll back the + transaction if somewhere in the process an error is raised (e.g. if + a '1' side of a 1:1 or 1:N relation is being tried to remove). Use it only + if the object you try to remove does not engage 1:1 relations or is the + '1' side of a 1:N relation. + ''' + error = '' + if self.opened: + try: + if not cascade: + if False: # NOTE implement a way to check if a object has relations to other objects + error = 'This object has relations to other objects in the objectbase' + raise ValueError, error + else: + del self.root[ name ] + else: + for i in self.root[ name ].relations: + for j in i[ 0 ]: + j.removeRelation( self.root[ name ] ) + del self.root[ name ] + except: + if error == '': + error = 'This database has no object with the name ' + name + print error + raise ValueError, error + else: + error = 'Database is closed' + raise ValueError, error + + def update( self, name, object ): + ''' + Updates the object with the key 'name' to match the value of 'object'. If + database doesn't contain such an object raises ValueError. It also raises + a ValueError if the object is not a subclass of the original object in the + database. + ''' + if self.opened: + try: + if issubclass( type( self.root[ name ] ), type( object ) ): + del self.root[ name ] + self.root[ name ] = object + else: + error = 'You cannot change the type of the object ' + name + ' to ' + str( type( object ) ) + raise ValueError, error + except: + error = 'This database has no object with the name ' + name + raise ValueError, error + else: + error = 'Database is closed' + raise ValueError, error + + def insert( self, name, object ): + ''' + Inserts a new object with the key 'name' to the database. + ''' + if self.opened: + self.root[ name ] = object + else: + error = 'Database is closed' + raise ValueError, error + + def close( self ): + ''' + Closes the database. + ''' + if self.opened: + transaction.commit() + self.cn.close() + self.db.close() + self.st.close() + self.opened = False + else: + error = 'Database is allready closed' + raise ValueError, error + + def open( self, dbfile ): + ''' + Opens a database stored in 'dbfile' or creates a new one. + ''' + if not self.opened: + self.st = FileStorage( dbfile ) + self.db = DB( self.st ) + self.cn = self.db.open() + self.root = self.cn.root() + self.opened = True + else: + error = 'Database is allready open' + raise ValueError, error diff --git a/rp/doc/index.html b/rp/doc/index.html new file mode 100644 index 0000000..6df8858 --- /dev/null +++ b/rp/doc/index.html @@ -0,0 +1,49 @@ + + +Python: package rp + + + + +
 
+ 
rp		index
/usr/lib/python2.4/site-packages/rp/__init__.py
+

Reasonable Python
+A module for integrating F-logic into Python
+ 
+__init__.py --- makes most important objects available
+        
+by Markus Schatten <markus_dot_schatten_at_foi_dot_hr>
+Faculty of Organization and Informatics,
+Varaždin, Croatia, 2007
+ 
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+ 
+This library 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
+Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+

+ + + + + +
 
+Package Contents
       
dbms
+f
+		interface
+libs
+		py2f
+reasonable
+		xsb_swig (package)
+
+ \ No newline at end of file diff --git a/rp/doc/rp.dbms.html b/rp/doc/rp.dbms.html new file mode 100644 index 0000000..939890b --- /dev/null +++ b/rp/doc/rp.dbms.html @@ -0,0 +1,95 @@ + + +Python: module rp.dbms + + + + +
 
+ 
rp.dbms		index
/usr/lib/python2.4/site-packages/rp/dbms.py
+

Reasonable Python
+A module for integrating F-logic into Python
+        
+dbms.py --- easy interface to ZODB
+        
+by Markus Schatten <markus_dot_schatten_at_foi_dot_hr>
+Faculty of Organization and Informatics,
+Varaždin, Croatia, 2007
+ 
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+ 
+This library 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
+Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+

+ + + + + +
 
+Modules
       
ZODB
+		transaction
+

+ + + + + +
 
+Classes
       
+
Objectbase +
+

+ + + + + + + +
 
+class Objectbase
   Class Objectbase - interface to an object database
 
 Methods defined here:
+
__init__(self, dbfile=None)
Initializes the connection to the database located in 'dbfile'. If 
+'dbfile' not supplied, only initalizes and sets opened to False. If 
+database does not exist, creates a new one with the name 'dbfile'
+ +
close(self)
Closes the database.
+ +
delete(self, name, cascade=False)
Deletes an object from the database by it's key (name). If database 
+doesn't contain such an object raises ValueError. Parameter cascade is
+used (if True) to delete all relations of this object in other objects.
+Cascade option is not well implemented since it does not roll back the 
+transaction if somewhere in the process an error is raised (e.g. if
+a '1' side of a 1:1 or 1:N relation is being tried to remove). Use it only
+if the object you try to remove does not engage 1:1 relations or is the 
+'1' side of a 1:N relation.
+ +
insert(self, name, object)
Inserts a new object with the key 'name' to the database.
+ +
open(self, dbfile)
Opens a database stored in 'dbfile' or creates a new one.
+ +
selectByName(self, name)
Returns the object with the key name. If database doesn't contain such an
+object raises ValueError
+ +
selectByType(self, typ)
Searches the database for a given type and returns a dictionary with
+key:object pairs which match this type. If database doesn't contain any
+object of the given type, returns an empty dictionary.
+ +
update(self, name, object)
Updates the object with the key 'name' to match the value of 'object'. If
+database doesn't contain such an object raises ValueError. It also raises
+a ValueError if the object is not a subclass of the original object in the
+database.
+ +

+ \ No newline at end of file diff --git a/rp/doc/rp.f.html b/rp/doc/rp.f.html new file mode 100644 index 0000000..6569017 --- /dev/null +++ b/rp/doc/rp.f.html @@ -0,0 +1,442 @@ + + +Python: module rp.f + + + + +
 
+ 
rp.f		index
/usr/lib/python2.4/site-packages/rp/f.py
+

Reasonable Python
+A module for integrating F-logic into Python
+        
+f.py --- F-logic concepts (rule, query, fact, variable )
+        
+by Markus Schatten <markus_dot_schatten_at_foi_dot_hr>
+Faculty of Organization and Informatics,
+Varaždin, Croatia, 2007
+ 
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+ 
+This library 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
+Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+

+ + + + + +
 
+Modules
       
string
+

+ + + + + +
 
+Classes
       
+
persistent.Persistent(__builtin__.object) +
+
+
Logical +
+
+
Bogus +
+
+
Variable +
+
+
Construct +
+
+
Fact +
Query +
Rule +
+
+
Formula +
+

+ + + + + + + +
 
+class Bogus(Logical)
   Bogus testing class. Ignore!
 
 
Method resolution order:
+
Bogus
+
Logical
+
persistent.Persistent
+
__builtin__.object
+
+
+Methods defined here:
+
__init__(self, a=1, b=[2, 3])
+ +
+Methods inherited from Logical:
+
__and__(self, new)
+ +
__fstr__(self)
+ +
__or__(self, new)
+ +
+Data and other attributes inherited from Logical:
+
__dict__ = <dictproxy object>
dictionary for instance variables (if defined)
+ +
__weakref__ = <attribute '__weakref__' of 'Logical' objects>
list of weak references to the object (if defined)
+ +
+Methods inherited from persistent.Persistent:
+
__delattr__(...)
x.__delattr__('name') <==> del x.name
+ +
__getattribute__(...)
x.__getattribute__('name') <==> x.name
+ +
__getstate__(...)
Get the object serialization state
+ 
+If the object has no assigned slots and has no instance dictionary, then 
+None is returned.
+ 
+If the object has no assigned slots and has an instance dictionary, then 
+the a copy of the instance dictionary is returned. The copy has any items 
+with names starting with '_v_' or '_p_' ommitted.
+ 
+If the object has assigned slots, then a two-element tuple is returned.  
+The first element is either None or a copy of the instance dictionary, 
+as described above. The second element is a dictionary with items 
+for each of the assigned slots.
+ +
__reduce__(...)
Reduce an object to contituent parts for serialization
+ +
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
+ +
__setstate__(...)
Set the object serialization state
+ 
+The state should be in one of 3 forms:
+ 
+- None
+ 
+  Ignored
+ 
+- A dictionary
+ 
+  In this case, the object's instance dictionary will be cleared and 
+  updated with the new state.
+ 
+- A two-tuple with a string as the first element. 
+ 
+  In this case, the method named by the string in the first element will be
+  called with the second element.
+ 
+  This form supports migration of data formats.
+ 
+- A two-tuple with None or a Dictionary as the first element and
+  with a dictionary as the second element.
+ 
+  If the first element is not None, then the object's instance dictionary 
+  will be cleared and updated with the value.
+ 
+  The items in the second element will be assigned as attributes.
+ +
+Data and other attributes inherited from persistent.Persistent:
+
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
+ +

+ + + + + + + +
 
+class Construct
   Three possibilities of logical constructs:
+ 
+a) h :- b.
+b) _ :- b.
+c) h :- _.
+ 
+a) is a rule where h is the head and b is the body (denoted by h :- b. )
+b) is a query where b is the query body (denoted by ?- b. )
+c) is a fact which consists of b (denoted by b. )
 
 Methods defined here:
+
__and__(self, new)
Adds a formula to the head of the construct 
+using the logic operator and (&).
+ +
__init__(self)
Initializes the logical construct
+ +
__lshift__(self, body)
Adds a formula to the body of the construct.
+ +
__or__(self, new)
Adds a formula to the head of the construct
+using the logic operator or (|).
+ +
__str__(self)
Prints the construct
+ +

+ + + + + +
 
+class Fact(Construct)
    Methods inherited from Construct:
+
__and__(self, new)
Adds a formula to the head of the construct 
+using the logic operator and (&).
+ +
__init__(self)
Initializes the logical construct
+ +
__lshift__(self, body)
Adds a formula to the body of the construct.
+ +
__or__(self, new)
Adds a formula to the head of the construct
+using the logic operator or (|).
+ +
__str__(self)
Prints the construct
+ +

+ + + + + + + +
 
+class Formula
   Class used for building logical constructs.
 
 Methods defined here:
+
__and__(self, new)
+ +
__init__(self, first=None)
+ +
__or__(self, new)
+ +
__str__(self)
+ +

+ + + + + + + +
 
+class Logical(persistent.Persistent)
   Class used for building logical queries.
 
 
Method resolution order:
+
Logical
+
persistent.Persistent
+
__builtin__.object
+
+
+Methods defined here:
+
__and__(self, new)
+ +
__fstr__(self)
+ +
__init__(self)
+ +
__or__(self, new)
+ +
+Data and other attributes defined here:
+
__dict__ = <dictproxy object>
dictionary for instance variables (if defined)
+ +
__weakref__ = <attribute '__weakref__' of 'Logical' objects>
list of weak references to the object (if defined)
+ +
+Methods inherited from persistent.Persistent:
+
__delattr__(...)
x.__delattr__('name') <==> del x.name
+ +
__getattribute__(...)
x.__getattribute__('name') <==> x.name
+ +
__getstate__(...)
Get the object serialization state
+ 
+If the object has no assigned slots and has no instance dictionary, then 
+None is returned.
+ 
+If the object has no assigned slots and has an instance dictionary, then 
+the a copy of the instance dictionary is returned. The copy has any items 
+with names starting with '_v_' or '_p_' ommitted.
+ 
+If the object has assigned slots, then a two-element tuple is returned.  
+The first element is either None or a copy of the instance dictionary, 
+as described above. The second element is a dictionary with items 
+for each of the assigned slots.
+ +
__reduce__(...)
Reduce an object to contituent parts for serialization
+ +
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
+ +
__setstate__(...)
Set the object serialization state
+ 
+The state should be in one of 3 forms:
+ 
+- None
+ 
+  Ignored
+ 
+- A dictionary
+ 
+  In this case, the object's instance dictionary will be cleared and 
+  updated with the new state.
+ 
+- A two-tuple with a string as the first element. 
+ 
+  In this case, the method named by the string in the first element will be
+  called with the second element.
+ 
+  This form supports migration of data formats.
+ 
+- A two-tuple with None or a Dictionary as the first element and
+  with a dictionary as the second element.
+ 
+  If the first element is not None, then the object's instance dictionary 
+  will be cleared and updated with the value.
+ 
+  The items in the second element will be assigned as attributes.
+ +
+Data and other attributes inherited from persistent.Persistent:
+
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
+ +

+ + + + + +
 
+class Query(Construct)
    Methods inherited from Construct:
+
__and__(self, new)
Adds a formula to the head of the construct 
+using the logic operator and (&).
+ +
__init__(self)
Initializes the logical construct
+ +
__lshift__(self, body)
Adds a formula to the body of the construct.
+ +
__or__(self, new)
Adds a formula to the head of the construct
+using the logic operator or (|).
+ +
__str__(self)
Prints the construct
+ +

+ + + + + +
 
+class Rule(Construct)
    Methods inherited from Construct:
+
__and__(self, new)
Adds a formula to the head of the construct 
+using the logic operator and (&).
+ +
__init__(self)
Initializes the logical construct
+ +
__lshift__(self, body)
Adds a formula to the body of the construct.
+ +
__or__(self, new)
Adds a formula to the head of the construct
+using the logic operator or (|).
+ +
__str__(self)
Prints the construct
+ +

+ + + + + + + +
 
+class Variable(persistent.Persistent)
   Implementation of logical variables in Python.
 
 
Method resolution order:
+
Variable
+
persistent.Persistent
+
__builtin__.object
+
+
+Methods defined here:
+
__eq__(self, value)
+ +
__init__(self, name)
+ +
__str__(self)
+ +
bind(self, value)
+ +
+Data and other attributes defined here:
+
__dict__ = <dictproxy object>
dictionary for instance variables (if defined)
+ +
__weakref__ = <attribute '__weakref__' of 'Variable' objects>
list of weak references to the object (if defined)
+ +
+Methods inherited from persistent.Persistent:
+
__delattr__(...)
x.__delattr__('name') <==> del x.name
+ +
__getattribute__(...)
x.__getattribute__('name') <==> x.name
+ +
__getstate__(...)
Get the object serialization state
+ 
+If the object has no assigned slots and has no instance dictionary, then 
+None is returned.
+ 
+If the object has no assigned slots and has an instance dictionary, then 
+the a copy of the instance dictionary is returned. The copy has any items 
+with names starting with '_v_' or '_p_' ommitted.
+ 
+If the object has assigned slots, then a two-element tuple is returned.  
+The first element is either None or a copy of the instance dictionary, 
+as described above. The second element is a dictionary with items 
+for each of the assigned slots.
+ +
__reduce__(...)
Reduce an object to contituent parts for serialization
+ +
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
+ +
__setstate__(...)
Set the object serialization state
+ 
+The state should be in one of 3 forms:
+ 
+- None
+ 
+  Ignored
+ 
+- A dictionary
+ 
+  In this case, the object's instance dictionary will be cleared and 
+  updated with the new state.
+ 
+- A two-tuple with a string as the first element. 
+ 
+  In this case, the method named by the string in the first element will be
+  called with the second element.
+ 
+  This form supports migration of data formats.
+ 
+- A two-tuple with None or a Dictionary as the first element and
+  with a dictionary as the second element.
+ 
+  If the first element is not None, then the object's instance dictionary 
+  will be cleared and updated with the value.
+ 
+  The items in the second element will be assigned as attributes.
+ +
+Data and other attributes inherited from persistent.Persistent:
+
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
+ +

+ \ No newline at end of file diff --git a/rp/doc/rp.html b/rp/doc/rp.html new file mode 100644 index 0000000..6df8858 --- /dev/null +++ b/rp/doc/rp.html @@ -0,0 +1,49 @@ + + +Python: package rp + + + + +
 
+ 
rp		index
/usr/lib/python2.4/site-packages/rp/__init__.py
+

Reasonable Python
+A module for integrating F-logic into Python
+ 
+__init__.py --- makes most important objects available
+        
+by Markus Schatten <markus_dot_schatten_at_foi_dot_hr>
+Faculty of Organization and Informatics,
+Varaždin, Croatia, 2007
+ 
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+ 
+This library 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
+Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+

+ + + + + +
 
+Package Contents
       
dbms
+f
+		interface
+libs
+		py2f
+reasonable
+		xsb_swig (package)
+
+ \ No newline at end of file diff --git a/rp/doc/rp.interface.html b/rp/doc/rp.interface.html new file mode 100644 index 0000000..7752e0f --- /dev/null +++ b/rp/doc/rp.interface.html @@ -0,0 +1,186 @@ + + +Python: module rp.interface + + + + +
 
+ 
rp.interface		index
/usr/lib/python2.4/site-packages/rp/interface.py
+

Reasonable Python
+A module for integrating F-logic into Python
+        
+interface.py --- interface to XSB anf Flora-2
+        
+by Markus Schatten <markus_dot_schatten_at_foi_dot_hr>
+Faculty of Organization and Informatics,
+Varaždin, Croatia, 2007
+ 
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+ 
+This library 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
+Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+

+ + + + + +
 
+Modules
       
new
+

+ + + + + +
 
+Classes
       
+
xsb +
+
+
Flora2 +
+
+
+

+ + + + + +
 
+class Flora2(xsb)
    Methods defined here:
+
__init__(self, args=['/home/mschatte/myPackages/XSB/', '-n', '-m', '100000', '-c', '20000', '-e', "asserta(library_directory('/home/mschatte/myPackages/flora2/')). [flora2]. bootstrap_flora."])
+ +
consult(self, file_name)
+ +
query(self, query, var_list)
+ +
+Methods inherited from xsb:
+
close_query(self)
+ +
get_ret_args(self, term)
+ +
next(self)
+ +
term2string(self, term)
+ +

+ + + + + +
 
+class xsb
    Methods defined here:
+
__init__(self, args=['/home/mschatte/myPackages/XSB/', '-n'])
+ +
close_query(self)
+ +
consult(self, file_name)
+ +
get_ret_args(self, term)
+ +
next(self)
+ +
query(self, query)
+ +
term2string(self, term)
+ +

+ + + + + +
 
+Functions
       
assign_string(...)
+
c2p_chars(...)
+
c2p_float(...)
+
c2p_functor(...)
+
c2p_int(...)
+
c2p_list(...)
+
c2p_nil(...)
+
c2p_setfree(...)
+
c2p_string(...)
+
c2p_term(...)
+
create_string_array(...)
+
ctop_float(...)
+
ctop_int(...)
+
ctop_string(...)
+
ensure_heap_space(...)
+
extern_ctop_string(...)
+
intpointer(...)
+
is_atom(...)
+
is_attv(...)
+
is_charlist(...)
+
is_float(...)
+
is_functor(...)
+
is_int(...)
+
is_list(...)
+
is_nil(...)
+
is_string(...)
+
is_var(...)
+
p2c_arity(...)
+
p2c_chars(...)
+
p2c_float(...)
+
p2c_functor(...)
+
p2c_int(...)
+
p2c_string(...)
+
p2c_term(...)
+
p2p_arg(...)
+
p2p_car(...)
+
p2p_cdr(...)
+
p2p_deref(...)
+
p2p_new(...)
+
p2p_unify(...)
+
p_charlist_to_c_string(...)
+
pcharlist2string(...)
+
print_pterm(...)
+
print_string_array(...)
+
ptoc_float(...)
+
ptoc_int(...)
+
ptoc_longstring(...)
+
ptoc_string(...)
+
reg_term(...)
+
release_string_array(...)
+
string_find(...)
+
xsb_close(...)
+
xsb_close_query(...)
+
xsb_command(...)
+
xsb_command_string(...)
+
xsb_get_last_answer_string(...)
+
xsb_get_last_error_string(...)
+
xsb_init(...)
+
xsb_init_string(...)
+
xsb_next(...)
+
xsb_next_string(...)
+
xsb_next_string_b(...)
+
xsb_query(...)
+
xsb_query_string(...)
+
xsb_query_string_string(...)
+
xsb_query_string_string_b(...)
+

+ + + + + +
 
+Data
       flArgs = ['/home/mschatte/myPackages/XSB/', '-n', '-m', '100000', '-c', '20000', '-e', 'asserta(library_directory(" + flora2_home + ")). [flora2]. bootstrap_flora.']
+flora2_home = '/home/mschatte/myPackages/flora2/'
+xsb_home = '/home/mschatte/myPackages/XSB/'
+ \ No newline at end of file diff --git a/rp/doc/rp.py2f.html b/rp/doc/rp.py2f.html new file mode 100644 index 0000000..1b12e9e --- /dev/null +++ b/rp/doc/rp.py2f.html @@ -0,0 +1,50 @@ + + +Python: class py2f + +

+ + + + + +
 
+rp.py2f = class py2f
    Methods defined here:
+
__del__(self)
+ +
__init__(self, base=None, insert=False)
+ +
f2bool(self, boolean)
+ +
f2class(self, cl)
+ +
f2dict(self, di)
+ +
f2float(self, floatnum)
+ +
f2func(self, fun)
+ +
f2imethod(self, met)
+ +
f2int(self, integer)
+ +
f2list(self, li)
+ +
f2method(self, met)
+ +
f2module(self, mod)
+ +
f2none(self, none)
+ +
f2ntype(self, value)
+ +
f2obj(self, obj)
+ +
f2str(self, string)
+ +
f2tuple(self, tu)
+ +
f2type(self, value)
+ +
+ \ No newline at end of file diff --git a/rp/doc/rp.reasonable.html b/rp/doc/rp.reasonable.html new file mode 100644 index 0000000..caa8106 --- /dev/null +++ b/rp/doc/rp.reasonable.html @@ -0,0 +1,69 @@ + + +Python: module rp.reasonable + + + + +
 
+ 
rp.reasonable		index
/usr/lib/python2.4/site-packages/rp/reasonable.py
+

Reasonable Python
+A module for integrating F-logic into Python
+        
+reasonable.py --- creates interface to FBase
+        
+by Markus Schatten <markus_dot_schatten_at_foi_dot_hr>
+Faculty of Organization and Informatics,
+Varaždin, Croatia, 2007
+ 
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+ 
+This library 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
+Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+

+ + + + + +
 
+Modules
       
string
+

+ + + + + +
 
+Classes
       
+
FBase +
+

+ + + + + +
 
+class FBase
    Methods defined here:
+
__init__(self, filename)
+ +
insert(self, object)
+ +
query(self, query)
+ +
write_and_load(self, string)
+ +

+ \ No newline at end of file diff --git a/rp/doc/rp.xsb_swig._xsb.html b/rp/doc/rp.xsb_swig._xsb.html new file mode 100644 index 0000000..5212ddb --- /dev/null +++ b/rp/doc/rp.xsb_swig._xsb.html @@ -0,0 +1,87 @@ + + +Python: module rp.xsb_swig._xsb + + + + +
 
+ 
rp.xsb_swig._xsb		index
/usr/lib/python2.4/site-packages/rp/xsb_swig/_xsb.so
+

+

+ + + + + +
 
+Functions
       
assign_string(...)
+
c2p_chars(...)
+
c2p_float(...)
+
c2p_functor(...)
+
c2p_int(...)
+
c2p_list(...)
+
c2p_nil(...)
+
c2p_setfree(...)
+
c2p_string(...)
+
c2p_term(...)
+
create_string_array(...)
+
ctop_float(...)
+
ctop_int(...)
+
ctop_string(...)
+
ensure_heap_space(...)
+
extern_ctop_string(...)
+
intpointer(...)
+
is_atom(...)
+
is_attv(...)
+
is_charlist(...)
+
is_float(...)
+
is_functor(...)
+
is_int(...)
+
is_list(...)
+
is_nil(...)
+
is_string(...)
+
is_var(...)
+
p2c_arity(...)
+
p2c_chars(...)
+
p2c_float(...)
+
p2c_functor(...)
+
p2c_int(...)
+
p2c_string(...)
+
p2c_term(...)
+
p2p_arg(...)
+
p2p_car(...)
+
p2p_cdr(...)
+
p2p_deref(...)
+
p2p_new(...)
+
p2p_unify(...)
+
p_charlist_to_c_string(...)
+
pcharlist2string(...)
+
print_pterm(...)
+
print_string_array(...)
+
ptoc_float(...)
+
ptoc_int(...)
+
ptoc_longstring(...)
+
ptoc_string(...)
+
reg_term(...)
+
release_string_array(...)
+
string_find(...)
+
xsb_close(...)
+
xsb_close_query(...)
+
xsb_command(...)
+
xsb_command_string(...)
+
xsb_get_last_answer_string(...)
+
xsb_get_last_error_string(...)
+
xsb_init(...)
+
xsb_init_string(...)
+
xsb_next(...)
+
xsb_next_string(...)
+
xsb_next_string_b(...)
+
xsb_query(...)
+
xsb_query_string(...)
+
xsb_query_string_string(...)
+
xsb_query_string_string_b(...)
+
+ \ No newline at end of file diff --git a/rp/doc/rp.xsb_swig.html b/rp/doc/rp.xsb_swig.html new file mode 100644 index 0000000..ec6cf94 --- /dev/null +++ b/rp/doc/rp.xsb_swig.html @@ -0,0 +1,35 @@ + + +Python: package rp.xsb_swig + + + + +
 
+ 
rp.xsb_swig		index
/usr/lib/python2.4/site-packages/rp/xsb_swig/__init__.py
+

This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+ 
+This library 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
+Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+

+ + + + + +
 
+Package Contents
       
_xsb
+		xsb
+
+ \ No newline at end of file diff --git a/rp/doc/rp.xsb_swig.xsb.html b/rp/doc/rp.xsb_swig.xsb.html new file mode 100644 index 0000000..910854b --- /dev/null +++ b/rp/doc/rp.xsb_swig.xsb.html @@ -0,0 +1,98 @@ + + +Python: module rp.xsb_swig.xsb + + + + +
 
+ 
rp.xsb_swig.xsb		index
/usr/lib/python2.4/site-packages/rp/xsb_swig/xsb.py
+

# This file was created automatically by SWIG 1.3.28.
+# Don't modify this file, modify the SWIG interface instead.
+# This file is compatible with both classic and new-style classes.

+

+ + + + + +
 
+Modules
       
rp.xsb_swig._xsb
+		new
+

+ + + + + +
 
+Functions
       
assign_string(...)
+
c2p_chars(...)
+
c2p_float(...)
+
c2p_functor(...)
+
c2p_int(...)
+
c2p_list(...)
+
c2p_nil(...)
+
c2p_setfree(...)
+
c2p_string(...)
+
c2p_term(...)
+
create_string_array(...)
+
ctop_float(...)
+
ctop_int(...)
+
ctop_string(...)
+
ensure_heap_space(...)
+
extern_ctop_string(...)
+
intpointer(...)
+
is_atom(...)
+
is_attv(...)
+
is_charlist(...)
+
is_float(...)
+
is_functor(...)
+
is_int(...)
+
is_list(...)
+
is_nil(...)
+
is_string(...)
+
is_var(...)
+
p2c_arity(...)
+
p2c_chars(...)
+
p2c_float(...)
+
p2c_functor(...)
+
p2c_int(...)
+
p2c_string(...)
+
p2c_term(...)
+
p2p_arg(...)
+
p2p_car(...)
+
p2p_cdr(...)
+
p2p_deref(...)
+
p2p_new(...)
+
p2p_unify(...)
+
p_charlist_to_c_string(...)
+
pcharlist2string(...)
+
print_pterm(...)
+
print_string_array(...)
+
ptoc_float(...)
+
ptoc_int(...)
+
ptoc_longstring(...)
+
ptoc_string(...)
+
reg_term(...)
+
release_string_array(...)
+
string_find(...)
+
xsb_close(...)
+
xsb_close_query(...)
+
xsb_command(...)
+
xsb_command_string(...)
+
xsb_get_last_answer_string(...)
+
xsb_get_last_error_string(...)
+
xsb_init(...)
+
xsb_init_string(...)
+
xsb_next(...)
+
xsb_next_string(...)
+
xsb_next_string_b(...)
+
xsb_query(...)
+
xsb_query_string(...)
+
xsb_query_string_string(...)
+
xsb_query_string_string_b(...)
+
+ \ No newline at end of file diff --git a/rp/f.py b/rp/f.py new file mode 100644 index 0000000..dfecc71 --- /dev/null +++ b/rp/f.py @@ -0,0 +1,287 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/python + +__doc__ = ''' +Reasonable Python +A module for integrating F-logic into Python + +f.py --- F-logic concepts (rule, query, fact, variable ) + +by Markus Schatten +Faculty of Organization and Informatics, +Varaždin, Croatia, 2007 + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +''' + +from persistent import Persistent +import string + +from py2f import py2f + + + +class Construct: + ''' + Three possibilities of logical constructs: + + a) h :- b. + b) _ :- b. + c) h :- _. + + a) is a rule where h is the head and b is the body (denoted by h :- b. ) + b) is a query where b is the query body (denoted by ?- b. ) + c) is a fact which consists of b (denoted by b. ) + + + ''' + + def __init__( self ): + ''' + Initializes the logical construct + ''' + self.head = Formula() + self.body = Formula() + + def __lshift__( self, body ): + ''' + Adds a formula to the body of the construct. + ''' + self.body & body + self.__str__() + return self.body + + def __and__( self, new ): + ''' + Adds a formula to the head of the construct + using the logic operator and (&). + ''' + self.head & new + self.__str__() + return self + + def __or__( self, new ): + ''' + Adds a formula to the head of the construct + using the logic operator or (|). + ''' + + self.head | new + self.__str__() + return self + + + def __str__( self ): + ''' + Prints the construct + ''' + + has_head = False + has_body = False + s = '' + if self.head.content != []: + s += str( self.head ) + has_head = True + self.__class__ = Fact + if self.body.content != []: + has_body = True + if has_head: + s += ' :- ' + str( self.body ) + self.__class__ = Rule + else: + s += ' ?- ' + str( self.body ) + self.__class__ = Query + if has_head or has_body: + s += '.' + return s + +class Rule( Construct ): pass +class Fact( Construct ): pass +class Query( Construct ): pass + +class Formula: + ''' + Class used for building logical constructs. + ''' + + def __init__( self, first=None ): + self.content = [] + if first != None: + self.content.append( first ) + + def __and__( self, new ): + if self.content != []: + self.content.append( '__and__' ) + + if issubclass( new.__class__, Logical ): + if len( new.content ) > 1: + self.content.append( '(' ) + for i in new.content: + self.content.append( i ) + if len( new.content ) > 1: + self.content.append( ')' ) + #print 'Logical class detected' + else: + self.content.append( new ) + + # print 'Anded', str( new ) + return self + + def __or__( self, new ): + if self.content != []: + self.content.append( '__or__' ) + if issubclass( new.__class__, Logical ): + if len( new.content ) > 1: + self.content.append( '(' ) + for i in new.content: + self.content.append( i ) + if len( new.content ) > 1: + self.content.append( ')' ) + + #print 'Logical class detected' + else: + self.content.append( new ) + # print 'Ored', str( new ) + return self + + def __str__( self ): + s = '' + for i in self.content: + if i == '__and__': + s += ', ' + elif i == '__or__': + s += '; ' + elif i == '(': + s += '(' + elif i == ')': + s += ')' + else: + if isinstance( i, Logical ): + s += i.__fstr__() + else: + pf = py2f() + s += pf.translate( i ) + return s + +class Logical( Persistent ): + ''' + Class used for building logical queries. + ''' + def __init__( self ): + self.content = [ self ] + self.__type__ = None + self.__classtype__ = None + + def __and__( self, new ): + if self.content != []: + self.content.append( '__and__' ) + self.content.append( new ) + return self + + def __or__( self, new ): + if self.content != []: + self.content.append( '__or__' ) + self.content.append( new ) + return self + + def __fstr__( self ): + pf = py2f() + if issubclass( self.__type__.__class__, Variable ) or issubclass( self.__type__.__class__, str ): + fs = str( self.__type__ ) + else: + fs = pf.name( self ) + if not issubclass( self.__classtype__.__class__, Variable ): + fs += ':' + pf.name( self.__class__ ) + '[' + else: + fs += ':' + str( self.__classtype__ ) + '[ ' + for i in self.__dict__.keys(): + if i != 'content' and i != '__type__' and i != '__classtype__': + if not ( isinstance( self.__dict__[ i ], Variable ) ): + if isinstance( i, Variable ): + fs += str( i ) + '->' + pf.translate( self.__dict__[ i ] ) + ', ' + else: + fs += '"' + str( i ) + '"' + '->' + pf.translate( self.__dict__[ i ] ) + ', ' + else: + if isinstance( i, Variable ): + fs += str( i ) + '->' + str( self.__dict__[ i ] ) + ', ' + else: + fs += '"' + str( i ) + '"' + '->' + str( self.__dict__[ i ] ) + ', ' + + if fs[ -2 ] != '[': + fs = fs[ :-2 ] + ']' + else: + fs = fs[ :-2 ] + + return fs + + + + +class Variable( Persistent ): + ''' + Implementation of logical variables in Python. + ''' + def __init__( self, name ): + if not( name[ 0 ] in string.uppercase or name[ 0 ] == '_' ): + raise ValueError, 'Logical variables have to start with uppercase or \'_\' if they are (named) don\'t care variables.' + else: + self.name = name + + self.value = None + + def __str__( self ): + if self.value == None: + return self.name + else: + return self.name + ' = ' + str( self.value ) + + def bind( self, value ): + self.value = value + + def __eq__( self, value ): + self.value = value + +class Bogus( Logical ): + ''' + Bogus testing class. Ignore! + ''' + def __init__( self, a=1, b=[ 2, 3 ] ): + Logical.__init__( self ) + self.a = a + self.b = b + + +if __name__ == '__main__': + + x = Construct() + + X = Variable( 'X' ) + + h = Bogus( X ) + b1 = Bogus() + b2 = Bogus() + + + pf = py2f() + + print pf.name( h ) + + ( x & h ) + # x << b1 & b2 + + print x + + diff --git a/rp/f2py.py b/rp/f2py.py new file mode 100644 index 0000000..ae4c4a9 --- /dev/null +++ b/rp/f2py.py @@ -0,0 +1,106 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/python + +__doc__ = ''' +Reasonable Python +A module for integrating F-logic into Python + +f2py.py --- translating F-logic back to Python + +by Markus Schatten +Faculty of Organization and Informatics, +Varaždin, Croatia, 2007 + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +''' + +import types + +class f2py: + def classForName( self, name, ns ): + return ns[ name ] + + + def translate( self, string, gl ): + if not isinstance( string, str ): + raise ValueError, 'Only FLORA-2 strings can be translated back to Python objects' + if not string[ :2 ] == 'py': + raise ValueError, 'The supplied string does not seem to be a FLORA-2 string' + if string == 'pybuffer': + return types.BufferType + if string == 'pybuiltinfunction': + return types.BuiltinFunctionType + if string == 'pybuiltinmethod': + return types.BuiltinMethodType + if string == 'pycode': + return types.CodeType + if string == 'pydictproxy': + return types.DictProxyType + if string == 'pyellipsis': + return types.EllipsisType + if string == 'pyfile': + return types.FileType + if string == 'pyframe': + return types.FrameType + if string == 'pyfunction': + return types.FunctionType + if string == 'pygenerator': + return types.GeneratorType + if string == 'pylambda': + return types.LambdaType + if string == 'pymethod': + return types.MethodType + if string == 'pynotimplemented': + return types.NotImplementedType + if string == 'pyslice': + return types.SliceType + if string == 'pytraceback': + return types.TracebackType + if string == 'pyunboundmethod': + return types.UnboundMethodType + if string == 'pyxrange': + return types.XRangeType + if string[ 0 ] == '_': + return None + if string[ :6 ] == 'pytype' or string[ :8 ] == 'pyclass': + classname = string.split( 'xxxmarexxx' )[ -1: ][ 0 ] + package = string.split( 'xxxmarexxx' )[ -1: ][ : ] + return self.classForName( classname, gl ) + else: + return 'pyunknown' + + def clean_list( self, lst ): + retlst = [] + for i in lst: + if i == 'true': + retlst.append( True ) + elif i == 'false': + retlst.append( False ) + try: + retlst.append( int( i ) ) + except: + try: + retlst.append( long( i ) ) + except: + try: + retlst.append( float( i ) ) + except: + try: + retlst.append( complex( i ) ) + except: + retlst.append( i ) + return retlst + \ No newline at end of file diff --git a/rp/interface.py b/rp/interface.py new file mode 100644 index 0000000..024c0cb --- /dev/null +++ b/rp/interface.py @@ -0,0 +1,183 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/python + +__doc__ = ''' +Reasonable Python +A module for integrating F-logic into Python + +interface.py --- interface to XSB anf Flora-2 + +by Markus Schatten +Faculty of Organization and Informatics, +Varaždin, Croatia, 2007 + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +''' + +from xsb_swig.xsb import * +try: + from libs import * +except: + print 'Don\'t know where XSB and Flora-2 are but will proceed as requested' + xsb_home = '' + flora2_home = '' + + +class xsb: + def __init__( self, args=[ xsb_home, '-n' ] ): + lenght = len( args ) + array = create_string_array( lenght ) + + i = 0 + for arg in args: + array = assign_string( array, arg, i ) + i += 1 + + #print_string_array( array, lenght ) + + xsb_init( lenght, array ) + + release_string_array( array, lenght ) + + def consult( self, file_name ): + xsb_query_string( 'consult('+file_name+').' ) + xsb_close_query() + + def query( self, query ): # add vars to be returned + xsb_query_string( query ) + + def close_query( self ): + xsb_close_query() + + def next( self ): + xsb_next() + + def term2string( self, term ): + termstring = '' + if is_var( term ) > 0: + return '_' + str( term ) + elif is_int( term ) > 0: + return str( p2c_int( term ) ) + elif is_float( term ) > 0: + return str (p2c_float( term ) ) + elif is_nil( term ) > 0 : + return str( [] ) + elif is_string( term ) > 0: + return p2c_string( term ) + elif is_list( term ) > 0: + save_term = term + termstring += '[' + termstring += self.term2string( p2p_car( term ) ) + li = [] + li.append( self.term2string( p2p_car( term ) ) ) + term = p2p_cdr( term ) + while is_list( term ) > 0: + termstring += ', ' + termstring += self.term2string( p2p_car( term ) ) + li.append( self.term2string( p2p_car( term ) ) ) + term = p2p_cdr( term ) + if not is_nil( term ) > 0: + termstring += '|' + termstring += self.term2string( term ) + termstring += ']' + if is_charlist( save_term, intpointer( len( li ) ) ) > 0: + return pcharlist2string( save_term, len( li ) ) + return termstring + elif is_functor( term ): + termstring += p2c_functor( term ) + if p2c_arity( term ) > 0: + termstring += '(' + termstring += self.term2string( p2p_arg( term, 1 ) ) + arity = p2c_arity( term ) + for i in range( 2, arity ): + termstring += ', ' + termstring += self.term2string( p2p_arg( term, i ) ) + termstring += ')' + return termstring + else: + raise ValueError, 'Unrecognized term type at:' + termstring + + def get_ret_args( self, term ): + if is_functor( term > 0 ): + if p2c_functor( term ) == 'ret': + arity = p2c_arity( term ) + args = [] + for i in range ( 1, arity ): + args.append( self.term2string( p2p_arg( term, i ) ) ) + return args + else: + raise ValueError, 'Functor is not of type \'ret\'' + else: + raise ValueError, 'Term is not a functor.' + +class Flora2( xsb ): + def __init__( self, args=[ xsb_home, '-n', '-m', '100000', '-c', '20000', '-e', +'asserta(library_directory(\'' + flora2_home + '\')). [flora2]. bootstrap_flora.' ] ): + xsb.__init__( self, args ) + + def consult( self, file_name ): + xsb.query( self, "flora_query('[+" + file_name + "].',[],_,_)." ) + xsb.close_query( self ) + + def query( self, query, var_list ): # add vars to be returned + if var_list != []: + mapping = '[' + for i in var_list: + mapping += "'" + i + "' = " + i + "1," + + + mapping = mapping[ :-1 ] + "]" + else: + mapping = '[]' + xsb.query( self, "flora_query('" + query + "'," + mapping + ",_,_)." ) + + ans = ' ' + + answer = [] + + while ans[ 0 ] != '_': + ans = self.term2string( reg_term( 2 ) ) + if ans[ 0 ] == '_': + break + + args = self.get_ret_args( reg_term( 2 ) ) + args = args[ :-1 ] + + answer.append( dict( zip( var_list, args ) ) ) + + self.next() + + return answer + + +flArgs = [ xsb_home, '-n', '-m', '100000', '-c', '20000', '-e', +'asserta(library_directory(" + flora2_home + ")). [flora2]. bootstrap_flora.' ] #flora_shell. + +if __name__ == '__main__': + + #x = xsb( flArgs ) + #x.consult( 'fammily' ) + #x.query( 'predak( X, lara ),writeln( X ).' ) + #x.query( "flora_query('flLoad(test).',[],A,B), write('A = '), writeln(A), nl, write('B = '), write(B)." ) + #x.close_query() + #x.query( "flora_query('X[ a -> 10 ].',['X' = Xa],A,B), writeln('Xa ='), writeln(Xa), writeln(A), writeln(B)." ) + #for i in range( 6 ): + # x.next() + #x.close_query() + f = Flora2() + f.consult( 'mybase_new' ) + ans = f.query( "X:Z[ Y -> S ].", ['X', 'Z', 'Y', 'S'] ) # OVO RADI + print ans diff --git a/rp/libs.py b/rp/libs.py new file mode 100644 index 0000000..c06b75d --- /dev/null +++ b/rp/libs.py @@ -0,0 +1,154 @@ +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' +xsb_home = '/home/mschatte/myPackages/XSB/' +flora2_home = '/home/mschatte/myPackages/flora2' diff --git a/rp/py2f.py b/rp/py2f.py new file mode 100644 index 0000000..63c8c66 --- /dev/null +++ b/rp/py2f.py @@ -0,0 +1,368 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/python + + + +__doc__ = ''' +Reasonable Python +A module for integrating F-logic into Python + +py2f.py --- converting Python objects into Flora2 F-molecules + +by Markus Schatten + Faculty of Organization and Informatics, + Varaždin, Croatia, 2007 + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + ''' + +import re, types + +from dbms import Objectbase +from persistent import Persistent + +class py2f: + def __init__( self, base=None, insert=False ): + self.classdefs = [] + self.insert = insert + self.count = 0 + if self.insert: + if base == None: + self.ob = Objectbase( 'p2f.fs' ) + else: + self.ob = base + else: + self.ob = None + + def store( self, object ): + if self.insert: + try: + key = self.name( object ) + except: + raise ValueError, 'Don\'t know how to translate ' + str( object ) + ' to FLORA-2 syntax' + try: + self.ob.insert( key, object ) + except: + self.ob.insert( key, 'unpickable_object' ) + print 'WARNING: inserting unpickable object ' + str( object ) + 'into objectbase' + + def delete( self, object ): + if self.insert: + try: + key = self.name( object ) + except: + raise ValueError, 'Don\'t know how to translate ' + str( object ) + ' to FLORA-2 syntax' + try: + self.ob.delete( key ) + except: + raise ValueError, 'No such object in the object base: ' + str( object ) + + def translate( self, object ): + if isinstance( object, types.NoneType ): + return '_'.replace( '\x00', '' ) + elif isinstance( object, bool ): + return str( object ).lower().replace( '\x00', '' ) + elif isinstance( object, int ): + return str( object ).replace( '\x00', '' ) + elif isinstance( object, float ): + return str( object ).replace( '\x00', '' ) + elif isinstance( object, long ): + return str( object ).replace( '\x00', '' ) + elif isinstance( object, complex ): + return '"' + str( object ) + '"'.replace( '\x00', '' ) + elif isinstance( object, str ): + return '"' + object + '"'.replace( '\x00', '' ) + elif isinstance( object, unicode ): + return '"' + object + '"'.replace( '\x00', '' ) + elif isinstance( object, types.BufferType ): + return '"' + str( object ) + '":pybuffer'.replace( '\x00', '' ) + elif isinstance( object, types.BuiltinFunctionType ): + return '"' + str( object ) + '":pybuiltinfunction'.replace( '\x00', '' ) + elif isinstance( object, types.BuiltinMethodType ): + return '"' + str( object ) + '":pybuiltinmethod'.replace( '\x00', '' ) + elif isinstance( object, types.CodeType ): + return '"' + str( object ) + '":pycode'.replace( '\x00', '' ) + elif isinstance( object, types.DictProxyType ): + return '"' + str( object ) + '":pydictproxy'.replace( '\x00', '' ) + elif isinstance( object, types.EllipsisType ): + return '"' + str( object ) + '":pyellipsis'.replace( '\x00', '' ) + elif isinstance( object, types.FileType ): + return '"' + str( object ) + '":pyfile'.replace( '\x00', '' ) + elif isinstance( object, types.FrameType ): + return '"' + str( object ) + '":pyframe'.replace( '\x00', '' ) + elif isinstance( object, types.FunctionType ): + return '"' + str( object ) + '":pyfunction'.replace( '\x00', '' ) + elif isinstance( object, types.GeneratorType ): + return '"' + str( object ) + '":pygenerator'.replace( '\x00', '' ) + elif isinstance( object, types.LambdaType ): + return '"' + str( object ) + '":pylambda'.replace( '\x00', '' ) + elif isinstance( object, types.MethodType ): + return '"' + str( object ) + '":pymethod'.replace( '\x00', '' ) + elif isinstance( object, types.NotImplementedType ): + return '"' + str( object ) + '":pynotimplemented'.replace( '\x00', '' ) + elif isinstance( object, types.SliceType ): + return '"' + str( object ) + '":pyslice'.replace( '\x00', '' ) + elif isinstance( object, types.TracebackType ): + return '"' + str( object ) + '":pytraceback'.replace( '\x00', '' ) + elif isinstance( object, types.UnboundMethodType ): + return '"' + str( object ) + '":pyunboundmethod'.replace( '\x00', '' ) + elif isinstance( object, types.XRangeType ): + return '"' + str( object ) + '":pyxrange'.replace( '\x00', '' ) + elif isinstance( object, list ): + retstr = '[' + ok = False + for i in object: + if self.insert: + key = self.name( i ) + if self.ob.root.has_key( key ): + retstr += key + ', ' + else: + retstr += self.translate( i ) + ', ' + else: + retstr += self.translate( i ) + ', ' + ok = True + if not ok: + return '[]:list'.replace( '\x00', '' ) + retstr = retstr[ :-2 ] + retstr += ']:list' + return retstr.replace( '\x00', '' ) + elif isinstance( object, tuple ): + retstr = '[' + ok = False + for i in object: + if self.insert: + key = self.name( i ) + if self.ob.root.has_key( key ): + retstr += key + ', ' + else: + retstr += self.translate( i ) + ', ' + else: + retstr += self.translate( i ) + ', ' + ok = True + if not ok: + return '[]:tuple'.replace( '\x00', '' ) + retstr = retstr[ :-2 ] + retstr += ']:tuple' + return retstr.replace( '\x00', '' ) + elif isinstance( object, dict ): + retstr = '_:dict[' + ok = False + for i in object.keys(): + if self.insert: + key = self.name( i ) + val = self.name( object[ i ] ) + if self.ob.root.has_key( key ): + retstr += key + '->' + else: + retstr += self.translate( i ) + '->' + if self.ob.root.has_key( val ): + retstr += val + ', ' + else: + retstr += self.translate( object[ i ] ) + ', ' + else: + retstr += self.translate( i ) + '->' + retstr += self.translate( object[ i ] ) + ', ' + ok = True + if not ok: + return '_:dict'.replace( '\x00', '' ) + retstr = retstr[ :-2 ] + retstr += ']' + return retstr.replace( '\x00', '' ) + elif isinstance( object, types.ClassType ) or isinstance( object, types.TypeType ): + retstr = self.name( object ) + retstr += '[' + ok = False + for i in dir( object ): + if self.insert: + key = self.name( i ) + val = self.name( eval( 'object.' + i ) ) + if self.ob.root.has_key( key ): + retstr += key + '->' + else: + vv = self.translate( i ) + retstr += vv + '->' + if self.ob.root.has_key( val ): + retstr += val + ', ' + else: + kk = self.translate( eval( 'object.' + i ) ) + retstr += kk + ', ' + if self.ob.root.has_key( key ): + retstr += key + '=>' + else: + retstr += vv + '=>' + if self.ob.root.has_key( val ): + retstr += val + ', ' + else: + retstr += kk + ', ' + else: + t_i = self.translate( i ) + v_i = self.translate( eval( 'object.' + i ) ) + retstr += t_i + '=>' + retstr += v_i + ', ' + retstr += t_i + '->' + retstr += v_i + ', ' + ok = True + if not ok: + return retstr[ :-1 ].replace( '\x00', '' ) + retstr = retstr[ :-2 ] + retstr += ']' + if retstr not in self.classdefs: + self.classdefs.append( retstr ) + return retstr.replace( '\x00', '' ) + elif isinstance( object, types.ObjectType ) or isinstance( object, types.InstanceType ): + clname = self.name( object.__class__ ) + if clname not in self.classdefs: + self.classdefs.append( clname ) + retstr = self.name( object ) + retstr += ':' + clname + '[' + ok = False + for i in dir( object ): + if i[ :1 ] != '_' and i[ :-2 ] != '__' : + if self.insert: + key = self.name( i ) + val = self.name( eval( 'object.' + i ) ) + if self.ob.root.has_key( key ): + retstr += key + '->' + else: + vv = self.translate( i ) + retstr += vv + '->' + if self.ob.root.has_key( val ): + retstr += val + ', ' + else: + kk = self.translate( eval( 'object.' + i ) ) + retstr += kk + ', ' + else: + retstr += self.translate( i ) + '->' + retstr += self.translate( eval( 'object.' + i ) ) + ', ' + ok = True + if not ok: + return retstr[ :-1 ].replace( '\x00', '' ) + retstr = retstr[ :-2 ] + retstr += ']' + return retstr.replace( '\x00', '' ) + elif isinstance( object, types.ModuleType ): + retstr = self.name( object ) + '[' + ok = False + for i in dir( object ): + if self.insert: + key = self.name( i ) + val = self.name( eval( 'object.' + i ) ) + if self.ob.root.has_key( key ): + retstr += key + '->' + else: + vv = self.translate( i ) + retstr += vv + '->' + if self.ob.root.has_key( val ): + retstr += val + ', ' + else: + kk = self.translate( eval( 'object.' + i ) ) + retstr += kk + ', ' + else: + retstr += self.translate( i ) + '->' + retstr += self.translate( eval( 'object.' + i ) ) + ', ' + ok = True + if not ok: + return retstr[ :-1 ].replace( '\x00', '' ) + retstr = retstr[ :-2 ] + retstr += ']' + return retstr.replace( '\x00', '' ) + else: + retstr = self.translate( str( object ) ) + ':pyunknown' + return retstr.replace( '\x00', '' ) + + def name( self, object ): + if isinstance( object, types.NoneType ): + return '_'.replace( '\x00', '' ) + elif isinstance( object, bool ): + return str( object ).lower().replace( '\x00', '' ) + elif isinstance( object, int ): + return str( object ).replace( '\x00', '' ) + elif isinstance( object, float ): + return str( object ).replace( '\x00', '' ) + elif isinstance( object, long ): + return str( object ).replace( '\x00', '' ) + elif isinstance( object, complex ): + return '"' + str( object ) + '"'.replace( '\x00', '' ) + elif isinstance( object, str ): + return '"' + object + '"'.replace( '\x00', '' ) + elif isinstance( object, unicode ): + return '"' + object + '"'.replace( '\x00', '' ) + elif isinstance( object, types.ModuleType ): + return 'pymodule' + self.findname( object ) + elif isinstance( object, types.ClassType ): + return 'pyclass' + self.findname( object ) + elif isinstance( object, types.TypeType ): + return 'pytype' + self.findname( object ) + elif isinstance( object, types.ObjectType ): + return 'pyobject' + self.findname( object ) + elif isinstance( object, types.InstanceType ): + return 'pyinstance' + self.findname( object ) + else: + return self.translate( object ) + + def findname( self, object ): + retstr = '' + x = [] + for i in str( object ).split( '.' ): + x += i.split() + y = [] + for i in x: + a = i.replace( '<', '' ) + a = a.replace( '>', '' ) + a = a.replace( '"', '' ) + a = a.replace( '\'', '' ) + a = a.replace( '/', 'xxxmarexxx' ) + a = a.replace( '\\', '' ) + + y.append( a ) + + for i in y: + retstr += 'xxxmarexxx' + i + + return retstr + +if __name__ == '__main__': + pf = py2f() + + a = 1 + b = 1.0 + c = True + d = "Wazaaap" + e = [ a, b, 3, 4, d ] + f = ( 1, 2, b, c, e ) + g = { a:b, c:d, d:f } + + class h: + ''' + A little funny class + ''' + def __init__( self, i, j ): + self.i = i + self.j = j + + k = h( e, f ) + + l = re + + test = [ a, b, c, d, e, f, g, h, k, l ] + + for i in test: + print 'translating: ' + str( i ) + print pf.translate( i ) + '\n' + + for i in pf.classdefs: + print i + \ No newline at end of file diff --git a/rp/reasonable.py b/rp/reasonable.py new file mode 100644 index 0000000..cb9358f --- /dev/null +++ b/rp/reasonable.py @@ -0,0 +1,195 @@ +# -*- coding: utf-8 -*- +#!/usr/bin/python + + + +__doc__ = ''' +Reasonable Python +A module for integrating F-logic into Python + +reasonable.py --- creates interface to FBase + +by Markus Schatten +Faculty of Organization and Informatics, +Varaždin, Croatia, 2007 + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +''' + +from dbms import Objectbase +from interface import Flora2 +from f import * +from py2f import py2f +from f2py import f2py + +class FBase: + def __init__( self, filename ): + self.fn = filename + ob = Objectbase( self.fn + '.fs' ) + self.db = py2f( ob, True ) + self.bd = f2py() + self.f2 = Flora2() + self.ffa = open( self.fn + '_all.flr', 'ar' ) + + self.listquery = Construct() + Type = Variable('Type') + self.qw = Logical() + self.qw.__classtype__ = Type + self.listquery << self.qw + self.indicator = False + + def write_and_load( self, string ): + self.ffa.write( string + '\n' ) + self.ffa.flush() + + string = string.replace( '\x00', '' ) + + self.f2.query( 'insert{ ' + string[ :-1 ] + '}.', []) + self.f2.close_query() + + + + def insert( self, object ): + if issubclass( object.__class__, Logical ) or issubclass( object.__class__, Variable ) or issubclass( object.__class__, Formula ): + raise ValueError, 'Only Constructs and non-logical objects can be inserted into the FBase.\n' + str( object ) + if issubclass( object.__class__, Construct ): + if issubclass( object.__class__, Fact ): + self.write_and_load( str( object ) ) + self.db.store( object ) + elif issubclass( object.__class__, Rule ): + self.db.store( object ) + self.write_and_load( str( object ) ) + elif issubclass( object.__class__, Query ): + raise ValueError, 'Provided object to insert is a query.\n' + str( object ) + else: + raise ValueError, 'Construct empty. Nothing to insert.' + else: + self.write_and_load( self.db.translate( object ) + '.' ) + self.db.store( object ) + + def delete( self, object ): + if issubclass( object.__class__, Logical ) or issubclass( object.__class__, Variable ) or issubclass( object.__class__, Formula ): + raise ValueError, 'Only Constructs and non-logical objects can be deleted from the FBase.\n' + str( object ) + if issubclass( object.__class__, Construct ): + if issubclass( object.__class__, Fact ): + self.f2.query( 'deleteall{' + self.db.translate( object ) + '}.', [] ) + self.f2.close_query() + self.db.delete( object ) + elif issubclass( object.__class__, Rule ): + raise ValueError, 'Rules cannot be deleted from the FBase.\n' + str( object ) + elif issubclass( object.__class__, Query ): + raise ValueError, 'Provided object to delete is a query.\n' + str( object ) + else: + raise ValueError, 'Construct empty, nothing to delete.' + else: + self.f2.query( 'deleteall{ ' + self.db.translate( object ) + ' }.', [] ) + self.db.delete( object ) + self.f2.close_query() + + + def query( self, query, gl ): + if issubclass( query.__class__, Query ): + vars = [] + for i in query.body.content: + if not isinstance( i, str ): + for j in i.__dict__: + if issubclass( i.__dict__[ j ].__class__, Variable ) and str( i.__dict__[ j ] ) not in vars: + vars.append( str( i.__dict__[ j ] ) ) + results = self.f2.query( str( query )[ 4: ], vars ) + self.f2.close_query() + res = [] + for i in results: + ri = {} + for j in i.keys(): + try: + ri[ j ] = self.db.ob.root[ i[ j ] ] + except: + if j[ 0 ] != '_': + if i[ j ][ :2 ] == 'py': + ri[ j ] = self.bd.translate( i[ j ], gl ) + elif i[ j ][ 0 ] == '[' and not self.indicator: + self.indicator = True + self.qw.__type__ = Variable( j ) + query << self.qw + resu = self.query( query, gl ) + typ = resu[ results.index( i ) ][ 'Type' ] + lst = i[ j ][ 1:-1 ].split( ',' ) + + lst = self.bd.clean_list( lst ) + + if typ == 'list': + ri[ j ] = lst + elif typ == 'tuple': + ri[ j ] = tuple( lst ) + self.indicator = False + else: + ri[ j ] = i[ j ] + res.append( ri ) + + return res + + + +if __name__ == '__main__': + fb = FBase( 'mybase' ) + + x = Construct() + y = Construct() + + Y = Variable( 'Y' ) + X = Variable( 'E' ) + Z = Variable( 'Z' ) + D = Variable( 'D' ) + + h = Bogus() + b1 = Bogus( 1, 2 ) + b1.__type__ = Z + b1.__classtype__ = X + b2 = Bogus() + + #x << h + + y & h + + x << b1 + + print x + + class mali( Persistent ): + def __init__( self, a=1, b=2 ): + self.a = a + self.b = b + + + c = mali() + d = mali() + e = mali() + + #print x + fb.insert( c ) + fb.insert( d ) + fb.insert( e ) + + + + + fb.delete( c ) + + result = fb.query( x, globals() ) + + print result + + diff --git a/rp/xsb_swig/__init__.py b/rp/xsb_swig/__init__.py new file mode 100644 index 0000000..ea15e18 --- /dev/null +++ b/rp/xsb_swig/__init__.py @@ -0,0 +1,16 @@ +''' +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library 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 +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +''' diff --git a/rp/xsb_swig/setup.py b/rp/xsb_swig/setup.py new file mode 100644 index 0000000..a0f29b3 --- /dev/null +++ b/rp/xsb_swig/setup.py @@ -0,0 +1,6 @@ +from distutils.core import setup, Extension + +setup(name="swig_xsb", version="0.0", + ext_modules = [Extension("_swig_xsb", ["swig_xsb_wrap.c", "swig_xsb.c"], include_dirs = [ +'/home/mschatte/myPackages/XSB/config/i686-pc-linux-gnu', '/home/mschatte/myPackages/XSB/emu'], extra_link_args = +[ '/home/mschatte/myPackages/XSB/config/i686-pc-linux-gnu/saved.o/xsb.o' ] )]) diff --git a/rp/xsb_swig/swig_xsb.c b/rp/xsb_swig/swig_xsb.c new file mode 100644 index 0000000..b801b2c --- /dev/null +++ b/rp/xsb_swig/swig_xsb.c @@ -0,0 +1,191 @@ +/* File: swig_xsb.c +** Author(s): Markus Schatten +** Contact: markus_dot_schatten_at_foi_dot_hr +** +** Copyright (C) Faculty of Organization and Informatics, 2006. +** +** Reasonable Python is free software; you can redistribute it and/or modify +** it under the terms of the GNU Library General Public License as published +** by the Free Software Foundation; either version 2 of the License, or (at +** your option) any later version. +** +** Flopy 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 Library General Public License for +** more details. +** +** You should have received a copy of the GNU Library General Public License +** along with Flopy; if not, write to the Free Software Foundation, +** Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** +*/ + + +#include +#include +#include +#include "swig_xsb.h" +#include "builtin.h" + +/*extern int xsb_init(int, char **); +extern int xsb_query_string(char *); +extern int xsb_next(); +extern int xsb_next_string(VarString*,char*); +extern int xsb_get_last_answer_string(char*,int,int*); +extern int xsb_close_query(); +extern int xsb_close(); +extern int xsb_get_last_error_string(char*,int,int*); + +extern char *xsb_executable_full_path(char *); +extern char *strip_names_from_path(char*, int);*/ + +char **create_string_array( int size ) +{ + char **array = malloc ( size * sizeof ( char* ) ); + return array; +} + +char **assign_string( char **string_array, char *string, int index ) +{ + string_array[ index ] = malloc ( strlen( string ) + 1 ); + string_array[ index ] = strcpy( string_array[ index ], string ); + return string_array; +} + +void print_string_array( char **string_array, int size ) +{ + int i; + for( i = 0; i < size; i++ ) + printf( "Entry number %d: %s\n", i, string_array[ i ] ); +} + +void release_string_array( char **string_array, int size ) +{ + int i; + for( i = 0; i < size-1; i++ ) + free( string_array[ i ] ); + + free( string_array ); +} + +char *pcharlist2string( unsigned long term, int size ) +{ + char *expression; + char *buf = malloc( size * sizeof( char ) ); + + expression = p2c_chars(term, buf, size ); + + return expression; +} + +int *intpointer( int num ) +{ + return # +} + + +extern int ptoc_int(int); + /* defined in builtin.c */ +extern double ptoc_float(int); + /* defined in builtin.c */ +extern char* ptoc_string(int); + /* defined in builtin.c */ +extern char* ptoc_longstring(int); + /* defined in builtin.c */ +//extern char* ptoc_abs(int); + +extern void ctop_int(int, int); + /* defined in builtin.c */ +extern void ctop_float(int, double); + /* def in builtin.c */ +extern void ctop_string(int, char*); + /* def in builtin.c */ +extern void extern_ctop_string(int, char*); + /* def in builtin.c */ +/*extern int ctop_abs(int, char*);*/ + +extern char* string_find(char*, int); /* defined in psc.c */ + +/*extern int ctop_term(char*, char*, reg_num); +extern int ptoc_term(char*, char*, reg_num);*/ + +/*======================================================================*/ +/* Low level C interface */ +/*======================================================================*/ + + +extern unsigned long reg_term(int); + +extern short c2p_int(int, unsigned long); +extern short c2p_float(double, unsigned long); +extern short c2p_string(char *, unsigned long); +extern short c2p_list(unsigned long); +extern short c2p_nil(unsigned long); +extern void ensure_heap_space(int, int); +extern short c2p_functor(char *, int, unsigned long); +extern void c2p_setfree(unsigned long); +extern void c2p_chars(char *str, int regs_to_protect, unsigned long term); + +extern int p2c_int(unsigned long); +extern double p2c_float(unsigned long); +extern char* p2c_string(unsigned long); +extern char* p2c_functor(unsigned long); +extern int p2c_arity(unsigned long); +extern char* p2c_chars(unsigned long,char *,int); + +extern unsigned long p2p_arg(unsigned long, int); +extern unsigned long p2p_car(unsigned long); +extern unsigned long p2p_cdr(unsigned long); +extern unsigned long p2p_new(); +extern short p2p_unify(unsigned long, unsigned long); +/*extern short p2p_call(unsigned long); +extern void p2p_funtrail();*/ +extern unsigned long p2p_deref(unsigned long); + +extern short is_var(unsigned long); +extern short is_int(unsigned long); +extern short is_float(unsigned long); +extern short is_string(unsigned long); +extern short is_atom(unsigned long); +extern short is_list(unsigned long); +extern short is_nil(unsigned long); +extern short is_functor(unsigned long); +extern short is_charlist(unsigned long,int*); +extern short is_attv(unsigned long); + +extern int c2p_term(char*, char*, unsigned long); +extern int p2c_term(char*, char*, unsigned long); + +/*======================================================================*/ +/* Other utilities */ +/*======================================================================*/ + + +//extern char *vfile_open(/* vfile, func, func, func, func, func */); +//extern char *vfile_obj(/* vfile */); + +/*======================================================================*/ +/* Routines to call xsb from C */ +/*======================================================================*/ + +extern int xsb_init(int, char **); +extern int xsb_init_string(char *); +extern int xsb_command(); +extern int xsb_command_string(char *); +extern int xsb_query(); +extern int xsb_query_string(char *); +extern int xsb_query_string_string(char*,VarString*,char*); +extern int xsb_query_string_string_b(char*,char*,int,int*,char*); +extern int xsb_next(); +extern int xsb_next_string(VarString*,char*); +extern int xsb_next_string_b(char*,int,int*,char*); +extern int xsb_get_last_answer_string(char*,int,int*); +extern int xsb_close_query(); +extern int xsb_close(); +extern int xsb_get_last_error_string(char*,int,int*); + +extern void print_pterm(Cell, int, VarString*); +extern char *p_charlist_to_c_string(unsigned long term, VarString *buf, + char *in_func, char *where); + diff --git a/rp/xsb_swig/swig_xsb.h b/rp/xsb_swig/swig_xsb.h new file mode 100644 index 0000000..586b74e --- /dev/null +++ b/rp/xsb_swig/swig_xsb.h @@ -0,0 +1,152 @@ +/* File: swig_xsb.h +** Author(s): Markus Schatten +** Contact: markus_dot_schatten_at_foi_dot_hr +** +** Copyright (C) Faculty of Organization and Informatics, 2006. +** +** Reasonable Python is free software; you can redistribute it and/or modify +** it under the terms of the GNU Library General Public License as published +** by the Free Software Foundation; either version 2 of the License, or (at +** your option) any later version. +** +** Flopy 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 Library General Public License for +** more details. +** +** You should have received a copy of the GNU Library General Public License +** along with Flopy; if not, write to the Free Software Foundation, +** Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +** +** +*/ + +#include +#include "cinterf.h" +#include "builtin.h" + +/*extern int xsb_init(int, char **); +extern int xsb_query_string(char *); +extern int xsb_next(); +extern int xsb_next_string(VarString*,char*); +extern int xsb_get_last_answer_string(char*,int,int*); +extern int xsb_close_query(); +extern int xsb_close(); +extern int xsb_get_last_error_string(char*,int,int*); + +extern char *xsb_executable_full_path(char *); +extern char *strip_names_from_path(char*, int);*/ + +extern char **create_string_array( int ); +extern char **assign_string( char **, char *, int ); +extern void print_string_array( char ** , int ); +extern void release_string_array( char **, int ); +extern char *pcharlist2string( unsigned long, int ); +extern int *intpointer( int ); + + +extern int ptoc_int(int); + /* defined in builtin.c */ +extern double ptoc_float(int); + /* defined in builtin.c */ +extern char* ptoc_string(int); + /* defined in builtin.c */ +extern char* ptoc_longstring(int); + /* defined in builtin.c */ +//extern char* ptoc_abs(int); + +extern void ctop_int(int, int); + /* defined in builtin.c */ +extern void ctop_float(int, double); + /* def in builtin.c */ +extern void ctop_string(int, char*); + /* def in builtin.c */ +extern void extern_ctop_string(int, char*); + /* def in builtin.c */ +/*extern int ctop_abs(int, char*);*/ + +extern char* string_find(char*, int); /* defined in psc.c */ + +/*extern int ctop_term(char*, char*, reg_num); +extern int ptoc_term(char*, char*, reg_num);*/ + +/*======================================================================*/ +/* Low level C interface */ +/*======================================================================*/ + + +extern unsigned long reg_term(int); + +extern short c2p_int(int, unsigned long); +extern short c2p_float(double, unsigned long); +extern short c2p_string(char *, unsigned long); +extern short c2p_list(unsigned long); +extern short c2p_nil(unsigned long); +extern void ensure_heap_space(int, int); +extern short c2p_functor(char *, int, unsigned long); +extern void c2p_setfree(unsigned long); +extern void c2p_chars(char *str, int regs_to_protect, unsigned long term); + + +extern int p2c_int(unsigned long); +extern double p2c_float(unsigned long); +extern char* p2c_string(unsigned long); +extern char* p2c_functor(unsigned long); +extern int p2c_arity(unsigned long); +extern char* p2c_chars(unsigned long,char *,int); + +extern unsigned long p2p_arg(unsigned long, int); +extern unsigned long p2p_car(unsigned long); +extern unsigned long p2p_cdr(unsigned long); +extern unsigned long p2p_new(); +extern short p2p_unify(unsigned long, unsigned long); +/*extern short p2p_call(unsigned long); +extern void p2p_funtrail();*/ +extern unsigned long p2p_deref(unsigned long); + +extern short is_var(unsigned long); +extern short is_int(unsigned long); +extern short is_float(unsigned long); +extern short is_string(unsigned long); +extern short is_atom(unsigned long); +extern short is_list(unsigned long); +extern short is_nil(unsigned long); +extern short is_functor(unsigned long); +extern short is_charlist(unsigned long,int*); +extern short is_attv(unsigned long); + +extern int c2p_term(char*, char*, unsigned long); +extern int p2c_term(char*, char*, unsigned long); + +/*======================================================================*/ +/* Other utilities */ +/*======================================================================*/ + + +//extern char *vfile_open(/* vfile, func, func, func, func, func */); +//extern char *vfile_obj(/* vfile */); + +/*======================================================================*/ +/* Routines to call xsb from C */ +/*======================================================================*/ + +extern int xsb_init(int, char **); +extern int xsb_init_string(char *); +extern int xsb_command(); +extern int xsb_command_string(char *); +extern int xsb_query(); +extern int xsb_query_string(char *); +extern int xsb_query_string_string(char*,VarString*,char*); +extern int xsb_query_string_string_b(char*,char*,int,int*,char*); +extern int xsb_next(); +extern int xsb_next_string(VarString*,char*); +extern int xsb_next_string_b(char*,int,int*,char*); +extern int xsb_get_last_answer_string(char*,int,int*); +extern int xsb_close_query(); +extern int xsb_close(); +extern int xsb_get_last_error_string(char*,int,int*); + +extern void print_pterm(Cell, int, VarString*); +extern char *p_charlist_to_c_string(unsigned long term, VarString *buf, + char *in_func, char *where); + diff --git a/rp/xsb_swig/swig_xsb_wrap.c b/rp/xsb_swig/swig_xsb_wrap.c new file mode 100644 index 0000000..2f7f33b --- /dev/null +++ b/rp/xsb_swig/swig_xsb_wrap.c @@ -0,0 +1,5229 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.28 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#define SWIGPYTHON +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE +/*********************************************************************** + * + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * + ************************************************************************/ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) +# if (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods for Windows DLLs */ +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# define SWIGEXPORT +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + + +/* Python.h has to appear first */ +#include + +/*********************************************************************** + * swigrun.swg + * + * This file contains generic CAPI SWIG runtime support for pointer + * type checking. + * + ************************************************************************/ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "2" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the swig runtime code. + In 99.9% of the cases, swig just needs to declare them as 'static'. + + But only do this if is strictly necessary, ie, if you have problems + with your compiler or so. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The swig conversion methods, as ConvertPtr, return and integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old swig versions, you usually write code as: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit as: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + that seems to be the same, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + requires also to SWIG_ConvertPtr to return new result values, as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + swig errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() + + + */ +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store inforomation on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (int)(*f1 - *f2); + } + return (l1 - f1) - (l2 - f2); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCompare(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + + +/* think of this as a c++ template<> or a scheme macro */ +#define SWIG_TypeCheck_Template(comparison, ty) \ + if (ty) { \ + swig_cast_info *iter = ty->cast; \ + while (iter) { \ + if (comparison) { \ + if (iter == ty->cast) return iter; \ + /* Move iter to the top of the linked list */ \ + iter->prev->next = iter->next; \ + if (iter->next) \ + iter->next->prev = iter->prev; \ + iter->next = ty->cast; \ + iter->prev = 0; \ + if (ty->cast) ty->cast->prev = iter; \ + ty->cast = iter; \ + return iter; \ + } \ + iter = iter->next; \ + } \ + } \ + return 0 + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); +} + +/* Same as previous function, except strcmp is replaced with a pointer comparison */ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { + SWIG_TypeCheck_Template(iter->type == from, into); +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + register size_t l = 0; + register size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + register size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + register int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + register size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + register const unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + register unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register char d = *(c++); + register unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = ((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Python.h has to appear first */ +#include + +/* Add PyOS_snprintf for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) +# define PyOS_snprintf _snprintf +# else +# define PyOS_snprintf snprintf +# endif +#endif + +/* A crude PyString_FromFormat implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 + +#ifndef SWIG_PYBUFFER_SIZE +#define SWIG_PYBUFFER_SIZE 1024 +#endif + +static PyObject * +PyString_FromFormat(const char *fmt, ...) { + va_list ap; + char buf[SWIG_PYBUFFER_SIZE * 2]; + int res; + va_start(ap, fmt); + res = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf); +} +#endif + +/* Add PyObject_Del for old Pythons */ +#if PY_VERSION_HEX < 0x01060000 +#define PyObject_Del(op) PyMem_DEL((op)) +#endif +#ifndef PyObject_DEL +#define PyObject_DEL PyObject_Del +#endif + +/* A crude PyExc_StopIteration exception for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +#define PyExc_StopIteration PyExc_RuntimeError +#define PyObject_GenericGetAttr 0 +#define Py_NotImplemented PyExc_RuntimeError +#endif + + +/* A crude PyString_AsStringAndSize implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02010000 +#define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} +#endif + +#if PY_VERSION_HEX < 0x02000000 +#define PySequence_Size PySequence_Length +#endif + + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + PyErr_Clear(); + Py_XINCREF(type); + PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_Format(PyExc_RuntimeError, mesg); + } +} + + + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ +# define SWIG_PYTHON_USE_GIL +# endif +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* cc-mode */ +#endif +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +#if 0 +{ /* cc-mode */ +#endif +} +#endif + + +/*********************************************************************** + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * Author : David Beazley (beazley@cs.uchicago.edu) + ************************************************************************/ + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags) +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule() +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) PySwigClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, (char *) msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, (char*) name, obj); + Py_DECREF(obj); +} + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { +#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +#else + PyObject* o2; + PyObject* o3; + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyTuple_Check(result)) { + o2 = result; + result = PyTuple_New(1); + PyTuple_SET_ITEM(result, 0, o2); + } + o3 = PyTuple_New(1); + PyTuple_SET_ITEM(o3, 0, obj); + o2 = result; + result = PySequence_Concat(o2, o3); + Py_DECREF(o2); + Py_DECREF(o3); + } + return result; +#endif +} + +/* Unpack the argument tuple */ + +SWIGINTERN int +SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), min); + return 0; + } + } + if (!PyTuple_Check(args)) { + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + register int l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), min, l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), max, l); + return 0; + } else { + register int i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#if PY_VERSION_HEX >= 0x02020000 +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); +#else +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); +#endif + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* cc-mode */ +#endif +#endif + +/* How to access Py_None */ +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# ifndef SWIG_PYTHON_NO_BUILD_NONE +# ifndef SWIG_PYTHON_BUILD_NONE +# define SWIG_PYTHON_BUILD_NONE +# endif +# endif +#endif + +#ifdef SWIG_PYTHON_BUILD_NONE +# ifdef Py_None +# undef Py_None +# define Py_None SWIG_Py_None() +# endif +SWIGRUNTIMEINLINE PyObject * +_SWIG_Py_None(void) +{ + PyObject *none = Py_BuildValue(""); + Py_DECREF(none); + return none; +} +SWIGRUNTIME PyObject * +SWIG_Py_None(void) +{ + static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); + return none; +} +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + + +/* PySwigClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; +} PySwigClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + PySwigClientData *data = (PySwigClientData *)ty->clientdata; + return data ? data->implicitconv : 0; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME PySwigClientData * +PySwigClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(obj); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { +#if (PY_VERSION_HEX < 0x02020000) + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); +#else + data->newraw = PyObject_GetAttrString((PyObject*)&PyBaseObject_Type, (char *)"__new__"); + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + Py_INCREF(data->newargs); +#endif + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); +#ifdef METH_O + data->delargs = !(flags & (METH_O)); +#else + data->delargs = 0; +#endif + } else { + data->delargs = 0; + } + data->implicitconv = 0; + return data; + } +} + +SWIGRUNTIME void +PySwigClientData_Del(PySwigClientData* data) +{ + Py_XDECREF(data->klass); + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== PySwigObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +} PySwigObject; + +SWIGRUNTIME PyObject * +PySwigObject_long(PySwigObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +PySwigObject_format(const char* fmt, PySwigObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) { + PyObject *ofmt = PyString_FromString(fmt); + if (ofmt) { + res = PyString_Format(ofmt,args); + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +PySwigObject_oct(PySwigObject *v) +{ + return PySwigObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +PySwigObject_hex(PySwigObject *v) +{ + return PySwigObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +PySwigObject_repr(PySwigObject *v) +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *hex = PySwigObject_hex(v); + PyObject *repr = PyString_FromFormat("", name, PyString_AsString(hex)); + Py_DECREF(hex); + if (v->next) { + PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next); + PyString_ConcatAndDel(&repr,nrep); + } + return repr; +} + +SWIGRUNTIME int +PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +{ + PyObject *repr = PySwigObject_repr(v); + if (repr) { + fputs(PyString_AsString(repr), fp); + Py_DECREF(repr); + return 0; + } else { + return 1; + } +} + +SWIGRUNTIME PyObject * +PySwigObject_str(PySwigObject *v) +{ + char result[SWIG_BUFFER_SIZE]; + return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? + PyString_FromString(result) : 0; +} + +SWIGRUNTIME int +PySwigObject_compare(PySwigObject *v, PySwigObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +SWIGRUNTIME PyTypeObject* _PySwigObject_type(void); + +SWIGRUNTIME PyTypeObject* +PySwigObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type(); + return type; +} + +SWIGRUNTIMEINLINE int +PySwigObject_Check(PyObject *op) { + return ((op)->ob_type == PySwigObject_type()) + || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0); +} + +SWIGRUNTIME PyObject * +PySwigObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +PySwigObject_dealloc(PyObject *v) +{ + PySwigObject *sobj = (PySwigObject *) v; + PyObject *next = sobj->next; + if (sobj->own) { + swig_type_info *ty = sobj->ty; + PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + if (data->delargs) { + /* we need to create a temporal object to carry the destroy operation */ + PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + Py_XDECREF(res); + } else { + const char *name = SWIG_TypePrettyName(ty); +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name); +#endif + } + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +PySwigObject_append(PyObject* v, PyObject* next) +{ + PySwigObject *sobj = (PySwigObject *) v; +#ifndef METH_O + PyObject *tmp = 0; + if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; + next = tmp; +#endif + if (!PySwigObject_Check(next)) { + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +#ifdef METH_NOARGS +PySwigObject_next(PyObject* v) +#else +PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + PySwigObject *sobj = (PySwigObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +PySwigObject_disown(PyObject *v) +#else +PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + PySwigObject *sobj = (PySwigObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +PySwigObject_acquire(PyObject *v) +#else +PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + PySwigObject *sobj = (PySwigObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +PySwigObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; +#if (PY_VERSION_HEX < 0x02020000) + if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) +#else + if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) +#endif + { + return NULL; + } + else + { + PySwigObject *sobj = (PySwigObject *)v; + PyObject *obj = sobj->own ? Py_True : Py_False; + if (val) { +#ifdef METH_NOARGS + if (PyObject_IsTrue(val)) { + PySwigObject_acquire(v); + } else { + PySwigObject_disown(v); + } +#else + if (PyObject_IsTrue(val)) { + PySwigObject_acquire(v,args); + } else { + PySwigObject_disown(v,args); + } +#endif + } + Py_INCREF(obj); + return obj; + } +} + +#ifdef METH_O +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, + {0, 0, 0, 0} +}; +#else +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, + {0, 0, 0, 0} +}; +#endif + +#if PY_VERSION_HEX < 0x02020000 +SWIGINTERN PyObject * +PySwigObject_getattr(PySwigObject *sobj,char *name) +{ + return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); +} +#endif + +SWIGRUNTIME PyTypeObject* +_PySwigObject_type(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods PySwigObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + (binaryfunc)0, /*nb_divide*/ + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ + (coercion)0, /*nb_coerce*/ + (unaryfunc)PySwigObject_long, /*nb_int*/ + (unaryfunc)PySwigObject_long, /*nb_long*/ + (unaryfunc)0, /*nb_float*/ + (unaryfunc)PySwigObject_oct, /*nb_oct*/ + (unaryfunc)PySwigObject_hex, /*nb_hex*/ +#if PY_VERSION_HEX >= 0x02020000 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ +#elif PY_VERSION_HEX >= 0x02000000 + 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ +#endif + }; + + static PyTypeObject pyswigobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *)"PySwigObject", /* tp_name */ + sizeof(PySwigObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)PySwigObject_dealloc, /* tp_dealloc */ + (printfunc)PySwigObject_print, /* tp_print */ +#if PY_VERSION_HEX < 0x02020000 + (getattrfunc)PySwigObject_getattr, /* tp_getattr */ +#else + (getattrfunc)0, /* tp_getattr */ +#endif + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)PySwigObject_compare, /* tp_compare */ + (reprfunc)PySwigObject_repr, /* tp_repr */ + &PySwigObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)PySwigObject_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + pyswigobject_type = tmp; + pyswigobject_type.ob_type = &PyType_Type; + type_init = 1; + } + return &pyswigobject_type; +} + +SWIGRUNTIME PyObject * +PySwigObject_New(void *ptr, swig_type_info *ty, int own) +{ + PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} PySwigPacked; + +SWIGRUNTIME int +PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +{ + char result[SWIG_BUFFER_SIZE]; + fputs("pack, v->size, 0, sizeof(result))) { + fputs("at ", fp); + fputs(result, fp); + } + fputs(v->ty->name,fp); + fputs(">", fp); + return 0; +} + +SWIGRUNTIME PyObject * +PySwigPacked_repr(PySwigPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return PyString_FromFormat("", result, v->ty->name); + } else { + return PyString_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +PySwigPacked_str(PySwigPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return PyString_FromFormat("%s%s", result, v->ty->name); + } else { + return PyString_FromString(v->ty->name); + } +} + +SWIGRUNTIME int +PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void); + +SWIGRUNTIME PyTypeObject* +PySwigPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type(); + return type; +} + +SWIGRUNTIMEINLINE int +PySwigPacked_Check(PyObject *op) { + return ((op)->ob_type == _PySwigPacked_type()) + || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); +} + +SWIGRUNTIME void +PySwigPacked_dealloc(PyObject *v) +{ + if (PySwigPacked_Check(v)) { + PySwigPacked *sobj = (PySwigPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +_PySwigPacked_type(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject pyswigpacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *)"PySwigPacked", /* tp_name */ + sizeof(PySwigPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)PySwigPacked_dealloc, /* tp_dealloc */ + (printfunc)PySwigPacked_print, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)PySwigPacked_compare, /* tp_compare */ + (reprfunc)PySwigPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)PySwigPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + pyswigpacked_type = tmp; + pyswigpacked_type.ob_type = &PyType_Type; + type_init = 1; + } + return &pyswigpacked_type; +} + +SWIGRUNTIME PyObject * +PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (PySwigPacked_Check(obj)) { + PySwigPacked *sobj = (PySwigPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIMEINLINE PyObject * +_SWIG_This(void) +{ + return PyString_FromString("this"); +} + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This(); + return swig_this; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +SWIGRUNTIME PySwigObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + if (PySwigObject_Check(pyobj)) { + return (PySwigObject *) pyobj; + } else { + PyObject *obj = 0; +#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } +#ifdef PyWeakref_CheckProxy + else if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + if (!obj) { + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !PySwigObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + PySwigObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (PySwigObject *)obj; + } +} + + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own) { + PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + if (!obj) return SWIG_ERROR; + if (obj == Py_None) { + if (ptr) *ptr = 0; + return SWIG_OK; + } else { + PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (PySwigObject *)sobj->next; + } else { + if (ptr) *ptr = SWIG_TypeCast(tc,vptr); + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) *own = sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + return SWIG_OK; + } else { + int res = SWIG_ERROR; + if (flags & SWIG_POINTER_IMPLICIT_CONV) { + PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + } + return res; + } + } +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + + /* here we get the method pointer for callbacks */ + char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) { + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) return SWIG_ERROR; + } + if (ty) { + swig_cast_info *tc = SWIG_TypeCheck(desc,ty); + if (!tc) return SWIG_ERROR; + *ptr = SWIG_TypeCast(tc,vptr); + } else { + *ptr = vptr; + } + return SWIG_OK; + } +} + +/* Convert a packed value value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, whitout calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this) +{ +#if (PY_VERSION_HEX >= 0x02020000) + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { + PyObject *dict = PyDict_New(); + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } + return inst; +#else + PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); + if (inst == NULL) { + return NULL; + } + inst->in_class = (PyClassObject *)data->newargs; + Py_INCREF(inst->in_class); + inst->in_dict = PyDict_New(); + if (inst->in_dict == NULL) { + Py_DECREF(inst); + return NULL; + } + PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); + return (PyObject *) inst; +#endif +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) { + if (!ptr) { + return SWIG_Py_Void(); + } else { + int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + PyObject *robj = PySwigObject_New(ptr, type, own); + PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0; + if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + if (inst) { + Py_DECREF(robj); + robj = inst; + } + } + return robj; + } +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else + type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +#if PY_MAJOR_VERSION < 2 +/* PyModule_AddObject function was introduced in Python 2.0. The following function + is copied out of Python/modsupport.c in python version 2.3.4 */ +SWIGINTERN int +PyModule_AddObject(PyObject *m, char *name, PyObject *o) +{ + PyObject *dict; + if (!PyModule_Check(m)) { + PyErr_SetString(PyExc_TypeError, + "PyModule_AddObject() needs module as first arg"); + return SWIG_ERROR; + } + if (!o) { + PyErr_SetString(PyExc_TypeError, + "PyModule_AddObject() needs non-NULL value"); + return SWIG_ERROR; + } + + dict = PyModule_GetDict(m); + if (dict == NULL) { + /* Internal error -- modules must have a dict! */ + PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", + PyModule_GetName(m)); + return SWIG_ERROR; + } + if (PyDict_SetItemString(dict, name, o)) + return SWIG_ERROR; + Py_DECREF(o); + return SWIG_OK; +} +#endif + +SWIGRUNTIME void +SWIG_Python_DestroyModule(void *vptr) +{ + swig_module_info *swig_module = (swig_module_info *) vptr; + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + PySwigClientData *data = (PySwigClientData *) ty->clientdata; + if (data) PySwigClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */ + + PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + swig_empty_runtime_method_table); + PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +} + + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); + } else { + PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); + } + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +PySwigObject_GetDesc(PyObject *self) +{ + PySwigObject *v = (PySwigObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : (char*)""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && PySwigObject_Check(obj)) { + const char *otype = (const char *) PySwigObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? PyString_AsString(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); + if (flags & SWIG_POINTER_EXCEPTION) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } + } + return result; +} + + +#ifdef __cplusplus +#if 0 +{ /* cc-mode */ +#endif +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_Cell swig_types[0] +#define SWIGTYPE_p_VarString swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_int swig_types[3] +#define SWIGTYPE_p_p_char swig_types[4] +static swig_type_info *swig_types[6]; +static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#if (PY_VERSION_HEX <= 0x02000000) +# if !defined(SWIG_PYTHON_CLASSIC) +# warning "This python version probably requires to use swig with the '-classic' option" +# endif +#endif + +/*----------------------------------------------- + @(target):= _xsb.so + ------------------------------------------------*/ +#define SWIG_init init_xsb + +#define SWIG_name "_xsb" + +#define SWIGVERSION 0x010328 + + +#define SWIG_as_voidptr(a) (void *)((const void *)(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) + + + /* Includes the header in the wrapper code */ + #include "swig_xsb.h" + + +#include +#ifndef LLONG_MIN +# define LLONG_MIN LONG_LONG_MIN +#endif +#ifndef LLONG_MAX +# define LLONG_MAX LONG_LONG_MAX +#endif +#ifndef ULLONG_MAX +# define ULLONG_MAX ULONG_LONG_MAX +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; + } else if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = (int)(v); + } + } + return res; +} + + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor() +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +SWIGINTERN int +SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) +{ + if (PyString_Check(obj)) { + char *cstr; int len; + PyString_AsStringAndSize(obj, &cstr, &len); + if (cptr) { + if (alloc) { + /* + In python the user should not be able to modify the inner + string representation. To warranty that, if you define + SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string + buffer is always returned. + + The default behavior is just to return the pointer value, + so, be careful. + */ +#if defined(SWIG_PYTHON_SAFE_CSTRINGS) + if (*alloc != SWIG_OLDOBJ) +#else + if (*alloc == SWIG_NEWOBJ) +#endif + { + *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1)); + *alloc = SWIG_NEWOBJ; + } + else { + *cptr = cstr; + *alloc = SWIG_OLDOBJ; + } + } else { + *cptr = PyString_AsString(obj); + } + } + if (psize) *psize = len + 1; + return SWIG_OK; + } else { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + if (pchar_descriptor) { + char* vptr = 0; + if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) { + if (cptr) *cptr = vptr; + if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0; + if (alloc) *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + } + } + return SWIG_TypeError; +} + + + + + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) +{ + if (PyInt_Check(obj)) { + long v = PyInt_AsLong(obj); + if (v >= 0) { + if (val) *val = v; + return SWIG_OK; + } else { + return SWIG_OverflowError; + } + } else if (PyLong_Check(obj)) { + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { + if (val) *val = (unsigned long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + if (carray) { + if (size > INT_MAX) { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + return pchar_descriptor ? + SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { + return PyString_FromStringAndSize(carray, (int)(size)); + } + } else { + return SWIG_Py_Void(); + } +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtr(const char *cptr) +{ + return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); +} + + + #define SWIG_From_long PyInt_FromLong + + +SWIGINTERNINLINE PyObject * +SWIG_From_int (int value) +{ + return SWIG_From_long (value); +} + + + #define SWIG_From_double PyFloat_FromDouble + + +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long (unsigned long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value)); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_short (short value) +{ + return SWIG_From_long (value); +} + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_create_string_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + char **result = 0 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:create_string_array",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "create_string_array" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (char **)create_string_array(arg1); + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_assign_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char **arg1 = (char **) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + char **result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:assign_string",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_char, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "assign_string" "', argument " "1"" of type '" "char **""'"); + } + arg1 = (char **)(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "assign_string" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "assign_string" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + result = (char **)assign_string(arg1,arg2,arg3); + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 ); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_print_string_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char **arg1 = (char **) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:print_string_array",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_char, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_string_array" "', argument " "1"" of type '" "char **""'"); + } + arg1 = (char **)(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_string_array" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + print_string_array(arg1,arg2); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_release_string_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char **arg1 = (char **) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:release_string_array",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_char, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "release_string_array" "', argument " "1"" of type '" "char **""'"); + } + arg1 = (char **)(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "release_string_array" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + release_string_array(arg1,arg2); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_pcharlist2string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + int arg2 ; + char *result = 0 ; + unsigned long val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:pcharlist2string",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pcharlist2string" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pcharlist2string" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (char *)pcharlist2string(arg1,arg2); + + resultobj = SWIG_FromCharPtr(result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intpointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int *result = 0 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:intpointer",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "intpointer" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int *)intpointer(arg1); + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ptoc_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int result; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ptoc_int",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ptoc_int" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)ptoc_int(arg1); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ptoc_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + double result; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ptoc_float",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ptoc_float" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (double)ptoc_float(arg1); + + resultobj = SWIG_From_double((double)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ptoc_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + char *result = 0 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ptoc_string",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ptoc_string" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (char *)ptoc_string(arg1); + + resultobj = SWIG_FromCharPtr(result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ptoc_longstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + char *result = 0 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ptoc_longstring",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ptoc_longstring" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (char *)ptoc_longstring(arg1); + + resultobj = SWIG_FromCharPtr(result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ctop_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ctop_int",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ctop_int" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ctop_int" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + ctop_int(arg1,arg2); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ctop_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + int val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ctop_float",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ctop_float" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ctop_float" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + ctop_float(arg1,arg2); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ctop_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + char *arg2 = (char *) 0 ; + int val1 ; + int ecode1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ctop_string",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ctop_string" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ctop_string" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + ctop_string(arg1,arg2); + + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_extern_ctop_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + char *arg2 = (char *) 0 ; + int val1 ; + int ecode1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:extern_ctop_string",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "extern_ctop_string" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "extern_ctop_string" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + extern_ctop_string(arg1,arg2); + + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_string_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + char *result = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:string_find",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_find" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "string_find" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (char *)string_find(arg1,arg2); + + resultobj = SWIG_FromCharPtr(result); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_reg_term(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + unsigned long result; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:reg_term",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "reg_term" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (unsigned long)reg_term(arg1); + + resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + unsigned long arg2 ; + short result; + int val1 ; + int ecode1 = 0 ; + unsigned long val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:c2p_int",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c2p_int" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c2p_int" "', argument " "2"" of type '" "unsigned long""'"); + } + arg2 = (unsigned long)(val2); + result = (short)c2p_int(arg1,arg2); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double arg1 ; + unsigned long arg2 ; + short result; + double val1 ; + int ecode1 = 0 ; + unsigned long val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:c2p_float",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c2p_float" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c2p_float" "', argument " "2"" of type '" "unsigned long""'"); + } + arg2 = (unsigned long)(val2); + result = (short)c2p_float(arg1,arg2); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + unsigned long arg2 ; + short result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + unsigned long val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:c2p_string",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c2p_string" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c2p_string" "', argument " "2"" of type '" "unsigned long""'"); + } + arg2 = (unsigned long)(val2); + result = (short)c2p_string(arg1,arg2); + + resultobj = SWIG_From_short((short)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:c2p_list",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c2p_list" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)c2p_list(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_nil(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:c2p_nil",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c2p_nil" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)c2p_nil(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ensure_heap_space(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ensure_heap_space",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ensure_heap_space" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ensure_heap_space" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + ensure_heap_space(arg1,arg2); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_functor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + unsigned long arg3 ; + short result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + unsigned long val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:c2p_functor",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c2p_functor" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c2p_functor" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c2p_functor" "', argument " "3"" of type '" "unsigned long""'"); + } + arg3 = (unsigned long)(val3); + result = (short)c2p_functor(arg1,arg2,arg3); + + resultobj = SWIG_From_short((short)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_setfree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:c2p_setfree",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "c2p_setfree" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + c2p_setfree(arg1); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_chars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + unsigned long arg3 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + unsigned long val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:c2p_chars",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c2p_chars" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "c2p_chars" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c2p_chars" "', argument " "3"" of type '" "unsigned long""'"); + } + arg3 = (unsigned long)(val3); + c2p_chars(arg1,arg2,arg3); + + resultobj = SWIG_Py_Void(); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2c_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + int result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2c_int",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2c_int" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (int)p2c_int(arg1); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2c_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + double result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2c_float",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2c_float" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (double)p2c_float(arg1); + + resultobj = SWIG_From_double((double)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2c_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + char *result = 0 ; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2c_string",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2c_string" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (char *)p2c_string(arg1); + + resultobj = SWIG_FromCharPtr(result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2c_functor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + char *result = 0 ; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2c_functor",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2c_functor" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (char *)p2c_functor(arg1); + + resultobj = SWIG_FromCharPtr(result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2c_arity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + int result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2c_arity",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2c_arity" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (int)p2c_arity(arg1); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2c_chars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + char *arg2 = (char *) 0 ; + int arg3 ; + char *result = 0 ; + unsigned long val1 ; + int ecode1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:p2c_chars",&obj0,&obj1,&obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2c_chars" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "p2c_chars" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "p2c_chars" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + result = (char *)p2c_chars(arg1,arg2,arg3); + + resultobj = SWIG_FromCharPtr(result); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2p_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + int arg2 ; + unsigned long result; + unsigned long val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:p2p_arg",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2p_arg" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "p2p_arg" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (unsigned long)p2p_arg(arg1,arg2); + + resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2p_car(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + unsigned long result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2p_car",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2p_car" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (unsigned long)p2p_car(arg1); + + resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2p_cdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + unsigned long result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2p_cdr",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2p_cdr" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (unsigned long)p2p_cdr(arg1); + + resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2p_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long result; + + if (!PyArg_ParseTuple(args,(char *)":p2p_new")) SWIG_fail; + result = (unsigned long)p2p_new(); + + resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2p_unify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + unsigned long arg2 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + unsigned long val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:p2p_unify",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2p_unify" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "p2p_unify" "', argument " "2"" of type '" "unsigned long""'"); + } + arg2 = (unsigned long)(val2); + result = (short)p2p_unify(arg1,arg2); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2p_deref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + unsigned long result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:p2p_deref",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p2p_deref" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (unsigned long)p2p_deref(arg1); + + resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_var(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_var",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_var" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_var(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_int",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_int" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_int(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_float(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_float",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_float" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_float(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_string",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_string" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_string(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_atom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_atom",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_atom" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_atom(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_list(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_list",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_list" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_list(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_nil(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_nil",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_nil" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_nil(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_functor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_functor",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_functor" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_functor(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_charlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + int *arg2 = (int *) 0 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:is_charlist",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_charlist" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_charlist" "', argument " "2"" of type '" "int *""'"); + } + arg2 = (int *)(argp2); + result = (short)is_charlist(arg1,arg2); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_is_attv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + short result; + unsigned long val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:is_attv",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "is_attv" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + result = (short)is_attv(arg1); + + resultobj = SWIG_From_short((short)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_c2p_term(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + unsigned long arg3 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + unsigned long val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:c2p_term",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "c2p_term" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "c2p_term" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "c2p_term" "', argument " "3"" of type '" "unsigned long""'"); + } + arg3 = (unsigned long)(val3); + result = (int)c2p_term(arg1,arg2,arg3); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p2c_term(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + unsigned long arg3 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + unsigned long val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:p2c_term",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "p2c_term" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "p2c_term" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "p2c_term" "', argument " "3"" of type '" "unsigned long""'"); + } + arg3 = (unsigned long)(val3); + result = (int)p2c_term(arg1,arg2,arg3); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + char **arg2 = (char **) 0 ; + int result; + int val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:xsb_init",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xsb_init" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xsb_init" "', argument " "2"" of type '" "char **""'"); + } + arg2 = (char **)(argp2); + result = (int)xsb_init(arg1,arg2); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_init_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:xsb_init_string",&obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_init_string" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + result = (int)xsb_init_string(arg1); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_command(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int result; + + if (!PyArg_ParseTuple(args,(char *)":xsb_command")) SWIG_fail; + result = (int)xsb_command(); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_command_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:xsb_command_string",&obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_command_string" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + result = (int)xsb_command_string(arg1); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int result; + + if (!PyArg_ParseTuple(args,(char *)":xsb_query")) SWIG_fail; + result = (int)xsb_query(); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_query_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:xsb_query_string",&obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_query_string" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + result = (int)xsb_query_string(arg1); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_query_string_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + VarString *arg2 = (VarString *) 0 ; + char *arg3 = (char *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:xsb_query_string_string",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_query_string_string" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_VarString, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xsb_query_string_string" "', argument " "2"" of type '" "VarString *""'"); + } + arg2 = (VarString *)(argp2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xsb_query_string_string" "', argument " "3"" of type '" "char *""'"); + } + arg3 = buf3; + result = (int)xsb_query_string_string(arg1,arg2,arg3); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_query_string_string_b(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int *arg4 = (int *) 0 ; + char *arg5 = (char *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int res5 ; + char *buf5 = 0 ; + int alloc5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:xsb_query_string_string_b",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_query_string_string_b" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xsb_query_string_string_b" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xsb_query_string_string_b" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xsb_query_string_string_b" "', argument " "4"" of type '" "int *""'"); + } + arg4 = (int *)(argp4); + res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xsb_query_string_string_b" "', argument " "5"" of type '" "char *""'"); + } + arg5 = buf5; + result = (int)xsb_query_string_string_b(arg1,arg2,arg3,arg4,arg5); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + if (alloc5 == SWIG_NEWOBJ) free((char*)buf5); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int result; + + if (!PyArg_ParseTuple(args,(char *)":xsb_next")) SWIG_fail; + result = (int)xsb_next(); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_next_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + VarString *arg1 = (VarString *) 0 ; + char *arg2 = (char *) 0 ; + int result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:xsb_next_string",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VarString, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_next_string" "', argument " "1"" of type '" "VarString *""'"); + } + arg1 = (VarString *)(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xsb_next_string" "', argument " "2"" of type '" "char *""'"); + } + arg2 = buf2; + result = (int)xsb_next_string(arg1,arg2); + + resultobj = SWIG_From_int((int)(result)); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_next_string_b(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + char *arg4 = (char *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:xsb_next_string_b",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_next_string_b" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xsb_next_string_b" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xsb_next_string_b" "', argument " "3"" of type '" "int *""'"); + } + arg3 = (int *)(argp3); + res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xsb_next_string_b" "', argument " "4"" of type '" "char *""'"); + } + arg4 = buf4; + result = (int)xsb_next_string_b(arg1,arg2,arg3,arg4); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_get_last_answer_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:xsb_get_last_answer_string",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_get_last_answer_string" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xsb_get_last_answer_string" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xsb_get_last_answer_string" "', argument " "3"" of type '" "int *""'"); + } + arg3 = (int *)(argp3); + result = (int)xsb_get_last_answer_string(arg1,arg2,arg3); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_close_query(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int result; + + if (!PyArg_ParseTuple(args,(char *)":xsb_close_query")) SWIG_fail; + result = (int)xsb_close_query(); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int result; + + if (!PyArg_ParseTuple(args,(char *)":xsb_close")) SWIG_fail; + result = (int)xsb_close(); + + resultobj = SWIG_From_int((int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_xsb_get_last_error_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int result; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:xsb_get_last_error_string",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xsb_get_last_error_string" "', argument " "1"" of type '" "char *""'"); + } + arg1 = buf1; + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xsb_get_last_error_string" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xsb_get_last_error_string" "', argument " "3"" of type '" "int *""'"); + } + arg3 = (int *)(argp3); + result = (int)xsb_get_last_error_string(arg1,arg2,arg3); + + resultobj = SWIG_From_int((int)(result)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return resultobj; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_print_pterm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Cell arg1 ; + int arg2 ; + VarString *arg3 = (VarString *) 0 ; + void *argp1 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:print_pterm",&obj0,&obj1,&obj2)) SWIG_fail; + { + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Cell, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_pterm" "', argument " "1"" of type '" "Cell""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_pterm" "', argument " "1"" of type '" "Cell""'"); + } else { + arg1 = *((Cell *)(argp1)); + } + } + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "print_pterm" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_VarString, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_pterm" "', argument " "3"" of type '" "VarString *""'"); + } + arg3 = (VarString *)(argp3); + print_pterm(arg1,arg2,arg3); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_p_charlist_to_c_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + unsigned long arg1 ; + VarString *arg2 = (VarString *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + char *result = 0 ; + unsigned long val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:p_charlist_to_c_string",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "p_charlist_to_c_string" "', argument " "1"" of type '" "unsigned long""'"); + } + arg1 = (unsigned long)(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_VarString, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "p_charlist_to_c_string" "', argument " "2"" of type '" "VarString *""'"); + } + arg2 = (VarString *)(argp2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "p_charlist_to_c_string" "', argument " "3"" of type '" "char *""'"); + } + arg3 = buf3; + res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "p_charlist_to_c_string" "', argument " "4"" of type '" "char *""'"); + } + arg4 = buf4; + result = (char *)p_charlist_to_c_string(arg1,arg2,arg3,arg4); + + resultobj = SWIG_FromCharPtr(result); + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + if (alloc4 == SWIG_NEWOBJ) free((char*)buf4); + return NULL; +} + + +static PyMethodDef SwigMethods[] = { + { (char *)"create_string_array", _wrap_create_string_array, METH_VARARGS, NULL}, + { (char *)"assign_string", _wrap_assign_string, METH_VARARGS, NULL}, + { (char *)"print_string_array", _wrap_print_string_array, METH_VARARGS, NULL}, + { (char *)"release_string_array", _wrap_release_string_array, METH_VARARGS, NULL}, + { (char *)"pcharlist2string", _wrap_pcharlist2string, METH_VARARGS, NULL}, + { (char *)"intpointer", _wrap_intpointer, METH_VARARGS, NULL}, + { (char *)"ptoc_int", _wrap_ptoc_int, METH_VARARGS, NULL}, + { (char *)"ptoc_float", _wrap_ptoc_float, METH_VARARGS, NULL}, + { (char *)"ptoc_string", _wrap_ptoc_string, METH_VARARGS, NULL}, + { (char *)"ptoc_longstring", _wrap_ptoc_longstring, METH_VARARGS, NULL}, + { (char *)"ctop_int", _wrap_ctop_int, METH_VARARGS, NULL}, + { (char *)"ctop_float", _wrap_ctop_float, METH_VARARGS, NULL}, + { (char *)"ctop_string", _wrap_ctop_string, METH_VARARGS, NULL}, + { (char *)"extern_ctop_string", _wrap_extern_ctop_string, METH_VARARGS, NULL}, + { (char *)"string_find", _wrap_string_find, METH_VARARGS, NULL}, + { (char *)"reg_term", _wrap_reg_term, METH_VARARGS, NULL}, + { (char *)"c2p_int", _wrap_c2p_int, METH_VARARGS, NULL}, + { (char *)"c2p_float", _wrap_c2p_float, METH_VARARGS, NULL}, + { (char *)"c2p_string", _wrap_c2p_string, METH_VARARGS, NULL}, + { (char *)"c2p_list", _wrap_c2p_list, METH_VARARGS, NULL}, + { (char *)"c2p_nil", _wrap_c2p_nil, METH_VARARGS, NULL}, + { (char *)"ensure_heap_space", _wrap_ensure_heap_space, METH_VARARGS, NULL}, + { (char *)"c2p_functor", _wrap_c2p_functor, METH_VARARGS, NULL}, + { (char *)"c2p_setfree", _wrap_c2p_setfree, METH_VARARGS, NULL}, + { (char *)"c2p_chars", _wrap_c2p_chars, METH_VARARGS, NULL}, + { (char *)"p2c_int", _wrap_p2c_int, METH_VARARGS, NULL}, + { (char *)"p2c_float", _wrap_p2c_float, METH_VARARGS, NULL}, + { (char *)"p2c_string", _wrap_p2c_string, METH_VARARGS, NULL}, + { (char *)"p2c_functor", _wrap_p2c_functor, METH_VARARGS, NULL}, + { (char *)"p2c_arity", _wrap_p2c_arity, METH_VARARGS, NULL}, + { (char *)"p2c_chars", _wrap_p2c_chars, METH_VARARGS, NULL}, + { (char *)"p2p_arg", _wrap_p2p_arg, METH_VARARGS, NULL}, + { (char *)"p2p_car", _wrap_p2p_car, METH_VARARGS, NULL}, + { (char *)"p2p_cdr", _wrap_p2p_cdr, METH_VARARGS, NULL}, + { (char *)"p2p_new", _wrap_p2p_new, METH_VARARGS, NULL}, + { (char *)"p2p_unify", _wrap_p2p_unify, METH_VARARGS, NULL}, + { (char *)"p2p_deref", _wrap_p2p_deref, METH_VARARGS, NULL}, + { (char *)"is_var", _wrap_is_var, METH_VARARGS, NULL}, + { (char *)"is_int", _wrap_is_int, METH_VARARGS, NULL}, + { (char *)"is_float", _wrap_is_float, METH_VARARGS, NULL}, + { (char *)"is_string", _wrap_is_string, METH_VARARGS, NULL}, + { (char *)"is_atom", _wrap_is_atom, METH_VARARGS, NULL}, + { (char *)"is_list", _wrap_is_list, METH_VARARGS, NULL}, + { (char *)"is_nil", _wrap_is_nil, METH_VARARGS, NULL}, + { (char *)"is_functor", _wrap_is_functor, METH_VARARGS, NULL}, + { (char *)"is_charlist", _wrap_is_charlist, METH_VARARGS, NULL}, + { (char *)"is_attv", _wrap_is_attv, METH_VARARGS, NULL}, + { (char *)"c2p_term", _wrap_c2p_term, METH_VARARGS, NULL}, + { (char *)"p2c_term", _wrap_p2c_term, METH_VARARGS, NULL}, + { (char *)"xsb_init", _wrap_xsb_init, METH_VARARGS, NULL}, + { (char *)"xsb_init_string", _wrap_xsb_init_string, METH_VARARGS, NULL}, + { (char *)"xsb_command", _wrap_xsb_command, METH_VARARGS, NULL}, + { (char *)"xsb_command_string", _wrap_xsb_command_string, METH_VARARGS, NULL}, + { (char *)"xsb_query", _wrap_xsb_query, METH_VARARGS, NULL}, + { (char *)"xsb_query_string", _wrap_xsb_query_string, METH_VARARGS, NULL}, + { (char *)"xsb_query_string_string", _wrap_xsb_query_string_string, METH_VARARGS, NULL}, + { (char *)"xsb_query_string_string_b", _wrap_xsb_query_string_string_b, METH_VARARGS, NULL}, + { (char *)"xsb_next", _wrap_xsb_next, METH_VARARGS, NULL}, + { (char *)"xsb_next_string", _wrap_xsb_next_string, METH_VARARGS, NULL}, + { (char *)"xsb_next_string_b", _wrap_xsb_next_string_b, METH_VARARGS, NULL}, + { (char *)"xsb_get_last_answer_string", _wrap_xsb_get_last_answer_string, METH_VARARGS, NULL}, + { (char *)"xsb_close_query", _wrap_xsb_close_query, METH_VARARGS, NULL}, + { (char *)"xsb_close", _wrap_xsb_close, METH_VARARGS, NULL}, + { (char *)"xsb_get_last_error_string", _wrap_xsb_get_last_error_string, METH_VARARGS, NULL}, + { (char *)"print_pterm", _wrap_print_pterm, METH_VARARGS, NULL}, + { (char *)"p_charlist_to_c_string", _wrap_p_charlist_to_c_string, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_Cell = {"_p_Cell", "Cell *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_VarString = {"_p_VarString", "VarString *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_Cell, + &_swigt__p_VarString, + &_swigt__p_char, + &_swigt__p_int, + &_swigt__p_p_char, +}; + +static swig_cast_info _swigc__p_Cell[] = { {&_swigt__p_Cell, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_VarString[] = { {&_swigt__p_VarString, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_Cell, + _swigc__p_VarString, + _swigc__p_char, + _swigc__p_int, + _swigc__p_p_char, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/************************************************************************* + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + + * The generated swig_type_info structures are assigned staticly to an initial + * array. We just loop though that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. +**/ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head; + static int init_run = 0; + + clientdata = clientdata; + + if (init_run) return; + init_run = 1; + + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (module_head) { + swig_module.next = module_head->next; + module_head->next = &swig_module; + } else { + /* This is the first module loaded */ + swig_module.next = &swig_module; + SWIG_SetModule(clientdata, &swig_module); + } + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %d\n", swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { + return PyString_FromString(""); + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); + return str; + } + + SWIGINTERN int + swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { + PyObject *str = swig_varlink_str(v); + fprintf(fp,"Swig global variables "); + fprintf(fp,"%s\n", PyString_AsString(str)); + Py_DECREF(str); + return 0; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { + PyObject_HEAD_INIT(NULL) + 0, /* Number of items in variable part (ob_size) */ + (char *)"swigvarlink", /* Type name (tp_name) */ + sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ + 0, /* Itemsize (tp_itemsize) */ + (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */ + (printfunc) swig_varlink_print, /* Print (tp_print) */ + (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ + (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc)swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + varlink_type = tmp; + varlink_type.ob_type = &PyType_Type; + type_init = 1; + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + strncpy(gv->name,name,size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals() { + static PyObject *_SWIG_globals = 0; + if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); + return _SWIG_globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + char *c = methods[i].ml_doc; + if (c && (c = strstr(c, "swig_ptr: "))) { + int j; + swig_const_info *ci = 0; + char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + strncpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + strncpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIG_init(void) { + PyObject *m, *d; + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + + m = Py_InitModule((char *) SWIG_name, SwigMethods); + d = PyModule_GetDict(m); + + SWIG_InitializeModule(0); + SWIG_InstallConstants(d,swig_const_table); + + +} + diff --git a/rp/xsb_swig/xsb.py b/rp/xsb_swig/xsb.py new file mode 100644 index 0000000..c9d8d4a --- /dev/null +++ b/rp/xsb_swig/xsb.py @@ -0,0 +1,173 @@ +# This file was created automatically by SWIG 1.3.28. +# Don't modify this file, modify the SWIG interface instead. +# This file is compatible with both classic and new-style classes. + +import _xsb +import new +new_instancemethod = new.instancemethod +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'PySwigObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError,name + +import types +try: + _object = types.ObjectType + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 +del types + + + +create_string_array = _xsb.create_string_array + +assign_string = _xsb.assign_string + +print_string_array = _xsb.print_string_array + +release_string_array = _xsb.release_string_array + +pcharlist2string = _xsb.pcharlist2string + +intpointer = _xsb.intpointer + +ptoc_int = _xsb.ptoc_int + +ptoc_float = _xsb.ptoc_float + +ptoc_string = _xsb.ptoc_string + +ptoc_longstring = _xsb.ptoc_longstring + +ctop_int = _xsb.ctop_int + +ctop_float = _xsb.ctop_float + +ctop_string = _xsb.ctop_string + +extern_ctop_string = _xsb.extern_ctop_string + +string_find = _xsb.string_find + +reg_term = _xsb.reg_term + +c2p_int = _xsb.c2p_int + +c2p_float = _xsb.c2p_float + +c2p_string = _xsb.c2p_string + +c2p_list = _xsb.c2p_list + +c2p_nil = _xsb.c2p_nil + +ensure_heap_space = _xsb.ensure_heap_space + +c2p_functor = _xsb.c2p_functor + +c2p_setfree = _xsb.c2p_setfree + +c2p_chars = _xsb.c2p_chars + +p2c_int = _xsb.p2c_int + +p2c_float = _xsb.p2c_float + +p2c_string = _xsb.p2c_string + +p2c_functor = _xsb.p2c_functor + +p2c_arity = _xsb.p2c_arity + +p2c_chars = _xsb.p2c_chars + +p2p_arg = _xsb.p2p_arg + +p2p_car = _xsb.p2p_car + +p2p_cdr = _xsb.p2p_cdr + +p2p_new = _xsb.p2p_new + +p2p_unify = _xsb.p2p_unify + +p2p_deref = _xsb.p2p_deref + +is_var = _xsb.is_var + +is_int = _xsb.is_int + +is_float = _xsb.is_float + +is_string = _xsb.is_string + +is_atom = _xsb.is_atom + +is_list = _xsb.is_list + +is_nil = _xsb.is_nil + +is_functor = _xsb.is_functor + +is_charlist = _xsb.is_charlist + +is_attv = _xsb.is_attv + +c2p_term = _xsb.c2p_term + +p2c_term = _xsb.p2c_term + +xsb_init = _xsb.xsb_init + +xsb_init_string = _xsb.xsb_init_string + +xsb_command = _xsb.xsb_command + +xsb_command_string = _xsb.xsb_command_string + +xsb_query = _xsb.xsb_query + +xsb_query_string = _xsb.xsb_query_string + +xsb_query_string_string = _xsb.xsb_query_string_string + +xsb_query_string_string_b = _xsb.xsb_query_string_string_b + +xsb_next = _xsb.xsb_next + +xsb_next_string = _xsb.xsb_next_string + +xsb_next_string_b = _xsb.xsb_next_string_b + +xsb_get_last_answer_string = _xsb.xsb_get_last_answer_string + +xsb_close_query = _xsb.xsb_close_query + +xsb_close = _xsb.xsb_close + +xsb_get_last_error_string = _xsb.xsb_get_last_error_string + +print_pterm = _xsb.print_pterm + +p_charlist_to_c_string = _xsb.p_charlist_to_c_string + + diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..a57f7ff --- /dev/null +++ b/setup.py @@ -0,0 +1,77 @@ +from distutils.core import setup, Extension + +import sys, os + +if __name__ == '__main__': + xsb_ok = False + platform_ok = False + flora2_ok = False + for i in sys.argv: + if i == '--xsb': + xsb_home = sys.argv[ sys.argv.index( i ) + 1 ] + xsb_ok = True + if i == '--platform': + platform = sys.argv[ sys.argv.index( i ) + 1 ] + if i == '--flora2': + flora2_home = sys.argv[ sys.argv.index( i ) + 1 ] + flora2_ok = True + if not xsb_ok and 'build' in sys.argv: + raise ValueError, 'Must supply --xsb /path/to/xsb/ in order to build Reasonable Python' + if not flora2_ok and 'build' in sys.argv: + raise ValueError, 'Must supply --flora2 /path/to/flora2/ in order to build Reasonable Python' + if not xsb_ok: + xsb_home = 'bogus' + else: + filestr = 'xsb_home = \'' + xsb_home + '\'\n' + sys.argv = sys.argv[ :-2 ] + if not flora2_ok: + flora2_home = 'bogus' + else: + filestr += 'flora2_home = \'' + flora2_home + '\'\n' + sys.argv = sys.argv[ :-2 ] + + if xsb_ok and flora2_ok: + libfile = open( os.path.join( 'rp', 'libs.py' ), 'a' ) + libfile.write( filestr ) + libfile.close() + + if not platform_ok: + platform = 'i686-pc-linux-gnu' + else: + sys.argv = sys.argv[ :-2 ] + + include1 = os.path.join( xsb_home, 'config', platform ) + include2 = os.path.join( xsb_home, 'emu' ) + xsb_obj = os.path.join( include1, 'saved.o', 'xsb.o' ) + + + + + + +setup(name='ReasonablePython', + version='0.1.2', + url='http://reasonablepy.sourcforge.net', + author='Markus Schatten', + author_email='markus.schatten@foi.hr', + py_modules = [ + 'rp.dbms', + 'rp.__init__', + 'rp.f', + 'rp.interface', + 'rp.py2f', + 'rp.f2py', + 'rp.reasonable', + 'rp.libs', + 'rp.xsb_swig.__init__', + 'rp.xsb_swig.xsb' ], + ext_modules=[ Extension( + "rp.xsb_swig._xsb", + [ "rp/xsb_swig/swig_xsb_wrap.c", "rp/xsb_swig/swig_xsb.c" ], + include_dirs = [ include1, include2 ], + extra_link_args =[ xsb_obj ] + ) + ] + + ) +