pax_global_header00006660000000000000000000000064132312327400014507gustar00rootroot0000000000000052 comment=ccd1a71dbca684eb4fab2da519d954cdd29e7110 valabind-1.5.0/000077500000000000000000000000001323123274000132725ustar00rootroot00000000000000valabind-1.5.0/.gitignore000066400000000000000000000000171323123274000152600ustar00rootroot00000000000000build valabind valabind-1.5.0/.travis.yml000066400000000000000000000003021323123274000153760ustar00rootroot00000000000000os: linux language: c compiler: gcc before_install: - sudo add-apt-repository ppa:vala-team/ppa -y - sudo apt-get update -qq - sudo apt-get install -qq libvala-dev valac script: - make valabind-1.5.0/AUTHORS000066400000000000000000000002551323123274000143440ustar00rootroot00000000000000Credits of Valabind =================== Author ------ Name: pancake Main developer and author of valabind. Contributors: ------------- See THANKS valabind-1.5.0/LICENSE000066400000000000000000001045131323123274000143030ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . valabind-1.5.0/Makefile000066400000000000000000000073101323123274000147330ustar00rootroot00000000000000_VERSION=? -include config.mk PWD:=$(shell pwd) #GIT_TIP=$(shell [ -d .git ] && git log HEAD^..HEAD 2>/dev/null |head -n1|cut -d ' ' -f2) GIT_TIP=$(shell git describe --tags) DESTDIR?= PREFIX?=/usr MANDIR?=$(PREFIX)/share/man CC?=gcc VALAFLAGS:=$(foreach w,$(CPPFLAGS) $(CFLAGS) $(LDFLAGS),-X $(w)) VALAC?=valac -g --cc="$(CC)" $(VALAFLAGS) RTLIBS=gobject-2.0 glib-2.0 VALAPKG:=lib$(shell ./getvv) BUILD?=build BIN=valabind SRC=config.vala main.vala valabindwriter.vala nodeffiwriter.vala utils.vala SRC+=girwriter.vala swigwriter.vala cxxwriter.vala ctypeswriter.vala dlangwriter.vala gowriter.vala VAPIS:=$(SRC:%.vala=$(BUILD)/%.vapi) CSRC:=$(SRC:%.vala=$(BUILD)/%.c) VALA_FILTER=$(filter %.vala,$?) TEMPS=$(addprefix --use-fast-vapi=,$(filter-out $(VALA_FILTER:%.vala=$(BUILD)/%.vapi),$(VAPIS))) TEMPS+=$(VALA_FILTER) $(patsubst %.vala,$(BUILD)/%.c,$(filter-out $?,$^)) ifneq ($(GIT_TIP),) SGIT_TIP=$(shell echo ${GIT_TIP} | sed -e s,${_VERSION},,) else SGIT_TIP=$(GIT_TIP) endif ifneq ($(SGIT_TIP),) VERSION=$(_VERSION)-$(SGIT_TIP) else VERSION=$(_VERSION) endif INSTALL_MAN?=install -m0644 INSTALL_PROGRAM?=install -m0755 ifneq ($(W32),) VALAFLAGS+=-D W32=1 PREFIX=/opt/gtk3w32/ PKG_CONFIG_PATH=$(W32_PREFIX)/lib/pkgconfig CFLAGS=-I$(PREFIX)/include/glib CFLAGS+=-I$(PREFIX)/include/glib LDFLAGS=-L$(PREFIX)/lib CC=i686-pc-mingw32-gcc all: $(BIN).exe else all: $(BIN) endif #VALASRC=$(HOME)/.config/radare2/r2pm/git/vala-0.39.2 #VALA040+=--vapidir=$(VALASRC)/ccode --pkg ccode -X -I$(VALASRC)/ccode #VALA040+=--vapidir=$(VALASRC)/codegen --pkg codegen -X -I$(VALASRC)/codegen VALA040=--pkg $(VALAPKG) VALA040+=--vapidir=$(PWD)/private --pkg ccode --pkg codegen -X -I$(PWD)/private VALA040+=-X -L/usr/local/lib/$(shell ./getvv) -X -lvalaccodegen w32: $(MAKE) W32=1 .PRECIOUS: $(BUILD)/%.c $(BUILD)/%.vapi $(BIN).exe: $(SRC) | $(VAPIS) @echo 'Compiling $(VALA_FILTER) -> $@' $(VALAC) --vapidir=. -D W32 -X "${CFLAGS}" -X "${LDFLAGS}" -o $@ --pkg $(VALAPKG) --save-temps ${TEMPS} windows.c --pkg windows @mv $(VALA_FILTER:%.vala=%.c) $(BUILD) $(BIN): $(SRC) | $(VAPIS) @echo 'Compiling $(VALA_FILTER) -> $@' ifeq ($(VALAPKG),libvala-0.40) $(VALAC) --vapidir=/usr/local/share/vala/vapi -o $@ --pkg posix $(VALA040) --save-temps ${TEMPS} else $(VALAC) -o $@ --pkg posix --pkg $(VALAPKG) --pkg valacodegen-0.40 --save-temps ${TEMPS} endif @mv $(VALA_FILTER:%.vala=%.c) $(BUILD) $(BUILD)/%.vapi: %.vala | $(BUILD) @echo 'Generating $< -> $@' @$(VALAC) $(VALAFLAGS) --fast-vapi=$@ $< @${MAKE} config.vala config.vala: Makefile @echo 'Generating $@' @echo 'const string version_string = "$(VERSION)";' > $@ $(BUILD): mkdir -p $@ install_dirs: mkdir -p $(DESTDIR)$(PREFIX)/bin mkdir -p $(DESTDIR)$(MANDIR)/man1 install: install_dirs $(INSTALL_MAN) $(BIN).1 $(DESTDIR)$(MANDIR)/man1 $(INSTALL_MAN) $(BIN)-cc.1 $(DESTDIR)$(MANDIR)/man1 $(INSTALL_PROGRAM) $(BIN) $(DESTDIR)$(PREFIX)/bin $(INSTALL_PROGRAM) $(BIN)-cc $(DESTDIR)$(PREFIX)/bin symstall: install_dirs chmod +x $(PWD)/$(BIN)-cc ln -fs $(PWD)/$(BIN).1 $(DESTDIR)$(MANDIR)/man1 ln -fs $(PWD)/$(BIN)-cc.1 $(DESTDIR)$(MANDIR)/man1 ln -fs $(PWD)/$(BIN) $(DESTDIR)$(PREFIX)/bin ln -fs $(PWD)/$(BIN)-cc $(DESTDIR)$(PREFIX)/bin dist: $(MAKE) shot GIT_TIP= shot: rm -rf valabind-$(VERSION) git clone . valabind-$(VERSION) cd valabind-$(VERSION) && $(MAKE) config.vala rm -rf valabind-$(VERSION)/.git tar czvf valabind-$(VERSION).tar.gz valabind-$(VERSION) mrproper clean: rm -f config.vala rm -rf $(BUILD) $(BIN) rm -rf $(CSRC) deinstall: uninstall uninstall: -rm $(DESTDIR)$(MANDIR)/man1/$(BIN).1 -rm $(DESTDIR)$(MANDIR)/man1/$(BIN)-cc.1 -rm $(DESTDIR)$(PREFIX)/bin/$(BIN) -rm $(DESTDIR)$(PREFIX)/bin/$(BIN)-cc .PHONY: all clean dist install symstall uninstall deinstall mrproper valabind-1.5.0/NOTES000066400000000000000000000032531323123274000141100ustar00rootroot00000000000000NOTES ===== Random notes taken from random .i files out there in the internets: https://svn.apache.org/repos/asf/subversion/trunk/subversion/bindings/swig/ /* ----------------------------------------------------------------------- The following struct members have to be read-only because otherwise strings assigned to then would never be freed, resulting in memory leaks. This prevents the swig warning "Warning(451): Setting const char * member may leak memory." */ %immutable svn_log_changed_path_t::copyfrom_path; %immutable svn_dirent_t::last_author; %immutable svn_error_t::message; %immutable svn_error_t::file; /* ### need to use freearg or somesuch to ensure the string is freed. ### watch out for 'return' anywhere in the binding code. */ #ifdef SWIGPYTHON %typemap(argout) (char *buffer, apr_size_t *len) { %append_output(PyString_FromStringAndSize($1, *$2)); free($1); } #endif #ifdef SWIGPERL %typemap(argout) (char *buffer, apr_size_t *len) { %append_output(sv_2mortal(newSVpvn($1, *$2))); free($1); } #endif #ifdef SWIGRUBY %typemap(argout) (char *buffer, apr_size_t *len) { %append_output(*$2 == 0 ? Qnil : rb_str_new($1, *$2)); free($1); } #endif %extend svn_commit_info_t { svn_commit_info_t(apr_pool_t *pool) { return svn_create_commit_info(pool); }; ~svn_commit_info_t() { }; svn_commit_info_t *dup(apr_pool_t *pool) { return svn_commit_info_dup(self, pool); }; } %init %{ #if defined(SVN_AVOID_CIRCULAR_LINKAGE_AT_ALL_COSTS_HACK) svn_swig_pl_bind_current_pool_fns (&svn_swig_pl_get_current_pool, &svn_swig_pl_set_current_pool); #endif %} %apply const char *NOT_NULL { const char *path }; valabind-1.5.0/README.md000066400000000000000000000013201323123274000145450ustar00rootroot00000000000000Valabind [![Build Status](https://travis-ci.org/radare/valabind.svg?branch=master)](https://travis-ci.org/radare/valabind) ======== Valabind is a tool to parse vala[1] or vapi files to transform them into swig[2] interface files, C++, NodeJS-ffi or GIR. With swig, you can create language bindings for any API written in vala or C with a vapi interface. It can also generate bindings for C++. Valabind mercurial repository is stored here: git clone https://github.com/radare/valabind This software is free, feel free to contribute, modify and report patches, ideas, bug reports, etc.. Contact ------- * e-mail: pancake@nopcode.org * twitter: @trufae [1] http://live.gnome.org/Vala [2] http://www.swig.org valabind-1.5.0/THANKS000066400000000000000000000012511323123274000142040ustar00rootroot00000000000000Thanks to: ---------- Name: Aitor P. Iturri Added -D flag Name: Anton Kochkov Support for Ruby Name: David Holm Fix `getvv` on MacOS X Lion Name: David Martínez Moreno Patches from Debian Name: Eduard Burtescu Implement Node-ffi bindings and some major refactorings Name: Ritesh Khadgaray Fix build for Vala 0.26 Name: Willi Ballenthin Work in progress Go bindings Name: dequis Refactor ctypeswriter Name: ditch Fix handling dependencies in ctypeswriter valabind-1.5.0/TODO.md000066400000000000000000000021511323123274000143600ustar00rootroot00000000000000valabind todo ============= beyond ------ [ ] Finish Go support [ ] Add support for Java using JNA [ ] Add support for unions (required for dynamic bindings) [ ] Unify all output modes --ctypes --swig --node ... those are should not be flags Use something like this: --mode=gir --mode=swig --mode=c++ --format=gir [ ] Add support to compile from C, do not generate (valabind-cc) [ ] Add support for destructors (class.get_destructor () .. [ ] Add support for varargs //%varargs(int mode = 0) open; int open(const char *path, int oflags, int mode = 0); [ ] Add support for contractual programming %contract Foo::bar(int x, int y) { require: x > 0; ensure: bar > 0; } [ ] Add support for exceptions (See %exception) [ ] Add support for properties [ ] Add support for %namespace foo { ... } [ ] Use templates in Swig? %template(intList) List; typedef int Integer void foo (vector *x); valabind-1.5.0/config.mk.acr000066400000000000000000000000761323123274000156370ustar00rootroot00000000000000PREFIX?=@PREFIX@ CC?=@CC@ CFLAGS+=@CFLAGS@ _VERSION=@VERSION@ valabind-1.5.0/config.vala000066400000000000000000000000661323123274000154060ustar00rootroot00000000000000const string version_string = "2.1-1.4.0-5-g700a887"; valabind-1.5.0/configure000077500000000000000000000245621323123274000152120ustar00rootroot00000000000000#!/bin/sh # This script was automatically generated by ACR v1.3 # @author: pancake # @url: http://www.nopcode.org # @repo: git clone https://github.com/radare/acr do_remove() { if [ "${ACR_RMFILES}" ]; then printf "cleaning temporally files... " rm -f ${ACR_RMFILES} echo "done" fi } control_c() { printf "\n\n^C control-c : script execution interrupted.\n" do_remove exit 1 } trap control_c 2 [ -z "${VALA}" ] && VALA="vala" [ -z "${VALAC}" ] && VALAC="valac" split_host() { S="$" while : ; do ENVWORDS="${ENVWORDS} $1_CPU $1_OS" STR=`eval "echo ${S}$1"` SPLIT_CPU="`echo "$STR" | cut -d - -f 1`" SPLIT_OS="`echo "$STR" | awk -F - '{ if ($2=="unknown"){ if (NF<3) { print $2; } else { print $3; } } else { if ($2=="linux") { print $2; } else if (NF<3) { print $2; } else { print $3; } } }'`" eval "$1_CPU=\"$SPLIT_CPU\"" eval "$1_OS=\"$SPLIT_OS\"" shift [ -z "$1" ] && break done } VPATH=`dirname ${0}` if [ "${VPATH}" = "." ]; then WODIS=current else if [ "${VPATH}" = "${PWD}" ]; then VPATH=. WODIS=current else WODIS=crosspath CURDIR=$PWD cd $VPATH VPATH="${PWD}/" cd $CURDIR fi fi guess_os() { if [ -e "${VPATH}/config.guess" ]; then sh ${VPATH}/config.guess return fi CPU="`uname -m|sed -e 's, ,,g'|cut -d - -f 1`" OS="`uname -s|tr A-Z a-z`" GNU="`uname --help 2>&1 | grep gnu`" [ "${GNU}" ] && OS="${OS}-gnu" [ "${CPU}" = ppc ] && CPU="powerpc" echo "${CPU}-unknown-${OS}" } SEARCHPATH="/usr /usr/local /usr/pkg /sw" : ${PREFIX:=/usr/local} CROSSBUILD=0 BUILD=`guess_os` HOST="${BUILD}" TARGET="${HOST}" SYSCONFDIR="" create_environ() { : ${EPREFIX:="${PREFIX}"} : ${SPREFIX:="${PREFIX}"} : ${BINDIR:="${SPREFIX}/bin"} : ${SBINDIR:="${PREFIX}/sbin"} : ${SYSCONFDIR:="${SPREFIX}/etc"} : ${LIBDIR:="${SPREFIX}/lib"} : ${LIBEXECDIR:="${SPREFIX}/libexec"} : ${INCLUDEDIR:="${SPREFIX}/include"} : ${DATADIR:="${SPREFIX}/share"} : ${INFODIR:="${DATADIR}/info"} : ${MANDIR:="${DATADIR}/man"} : ${DOCDIR:="${DATADIR}/doc/valabind"} : ${LOCALSTATEDIR:="${SPREFIX}/var"} for A in `echo ${PATH} | sed -e 's,:, ,g'` ; do [ -e "$A"/ginstall ] && : ${INSTALL:="$A"/ginstall} && break [ -e "$A"/install ] && : ${INSTALL:="$A"/install} && break done : ${INSTALL_DIR:=${INSTALL} -d} : ${INSTALL_DATA:=${INSTALL} -m 644} : ${INSTALL_SCRIPT:=${INSTALL} -m 755} : ${INSTALL_PROGRAM:=${INSTALL} -m 755} : ${INSTALL_PROGRAM_STRIP:=${INSTALL} -m 755 -s} : ${INSTALL_MAN:=${INSTALL} -m 444} : ${INSTALL_LIB:=${INSTALL} -m 755 -c} PKGNAME='valabind' ; VERSION='1.5' ; CONTACT_MAIL="pancake@nopcode.org" ; CONTACT_NAME="pancake" ; CONTACT="pancake " ; } show_usage() { cat < if you have libraries in a nonstandard directory CPPFLAGS C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor VALAC Vala compiler to be used. " printf " Report bugs to: pancake " echo "" exit 0 } take_environ() { : ${SH:=/bin/sh} : ${CPP:=cpp} : ${CC:=gcc} : ${VALAC:=valac} : ${PREFIX:=/usr/local/} } show_version() { echo "valabind-1.5 configuration script done with acr v1.3. The 'Free Software Foundation' message is only for autodetection. Originally written by pancake ." exit 0 } parse_options() { flag=`echo $1| cut -d = -f 1` value=`echo $1| awk 'BEGIN{FS="=";}{print $2}'` flag2=`echo $flag|cut -f2- -d -| sed -e 's,-,_,g' -e 's,^_,,g'|tr '[a-z]' '[A-Z]'` if [ "${TARGET_OS}" = "darwin" ]; then LIBPATH=-Wl,-install_name, else LIBPATH=-Wl,-R fi case $flag in -h|--help|--hel|--h|--he|-help) show_usage ; ;; -V|-version|--version) show_version ; ;; -r|--r|--report) echo "PKGNAME: valabind" echo "VERSION: 1.5" echo "LANGS: c vala" echo "FLAGS: --with-vala=vala --with-valac=valac" exit 0 ;; --cache-file) # ignored: acr have no cache ;; --build) BUILD="$value"; split_host BUILD ; ;; --host) CROSSBUILD=1 # XXX HOST="$value"; split_host HOST ; ;; --target) TARGET="$value"; split_host TARGET ; ;; --prefix) PREFIX="$value"; ;; --exec-prefix) EPREFIX="$value"; ;; --sandbox|--sprefix) SPREFIX="$value"; ;; --bindir) BINDIR="$value"; ;; --sbindir) SBINDIR="$value"; ;; --libexecdir) LIBEXECDIR="$value"; ;; --docdir) DOCDIR="$value"; ;; --datadir) DATADIR="$value"; ;; --sysconfdir) SYSCONFDIR="$value"; ;; --sharedstatedir) SHAREDSTATEDIR="$value"; ;; --localstatedir) LOCALSTATEDIR="$value"; ;; --libdir) LIBDIR="$value"; ;; --libpath) LDFLAGS="${LDFLAGS} ${LIBPATH}$value"; ;; --includedir) INCLUDEDIR="$value"; CFLAGS="${CFLAGS} -I$value"; ;; --infodir) INFODIR="$value"; ;; --mandir) MANDIR="$value"; ;; --with-vala) if [ -z "${value}" ]; then VALA="vala"; else VALA="${value}" ; fi ;; --with-valac) if [ -z "${value}" ]; then VALAC="valac"; else VALAC="${value}" ; fi ;; *) if [ "$value" ]; then eval "`echo $flag2=$value`" ; else echo ; echo "WARNING: Unknown flag '$flag'." >&2 ; echo ; fi ;; esac } # MAIN # take_environ split_host BUILD HOST TARGET [ -z "$ACRHOOK" ] && ACRHOOK=./configure.hook [ -e "$ACRHOOK" ] && . ${ACRHOOK} while : ; do [ -z "$1" ] && break parse_options "$1" shift done ENVWORDS="MANDIR INFODIR LIBDIR INCLUDEDIR LOCALSTATEDIR SYSCONFDIR DATADIR DOCDIR LIBEXECDIR SBINDIR BINDIR EPREFIX PREFIX SPREFIX TARGET HOST BUILD INSTALL INSTALL_LIB INSTALL_MAN INSTALL_PROGRAM INSTALL_PROGRAM_STRIP INSTALL_DIR INSTALL_SCRIPT INSTALL_DATA HOST_OS HOST_CPU BUILD_OS BUILD_CPU TARGET_OS TARGET_CPU PKGNAME VPATH VERSION CONTACT CONTACT_NAME CONTACT_MAIL CC CFLAGS CPPFLAGS LDFLAGS HAVE_LANG_C VALA VALAC" create_environ echo "checking build system type... ${BUILD}" echo "checking host system type... ${HOST}" echo "checking target system type... ${TARGET}" [ "${CROSSBUILD}" = 1 ] && echo "using crosscompilation mode." #split_host BUILD HOST TARGET [ -n "${prefix}" ] && PREFIX="${prefix}" echo "checking for working directories... ${WODIS}" echo "using prefix '${PREFIX}'" ACR_RMFILES=" test.c a.out a.exe .test.vala .test" COMPILER=CC printf "checking for c compiler... " HAVE_LANG_C=1 if [ "${CROSSBUILD}" = 1 ]; then (command -v ${HOST}-${CC} >/dev/null 2>&1) if [ $? = 0 ]; then CC="${HOST}-${CC}"; fi fi echo "int main(int argc, char **argv){return 0;}" > test.c (exec ${CC} ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} test.c >/dev/null 2>&1) if [ $? = 0 ]; then echo ${CC}; else echo no ; HAVE_LANG_C=0 do_remove echo "ERROR: ${CC} cannot create executables" >&2 ; exit 1 ; fi printf "checking vala compiler... " HAVE_LANG_VALA=1 HAVE_VALA=1 HAVE_VALAC=1 VALA_VERSION="" echo "void main(){}" > .test.vala ${VALAC} .test.vala 2>&1 >/dev/null if [ $? = 0 ]; then echo ${VALAC}; VALA_VERSION=$(${VALAC} --version | cut -d " " -f 2 | cut -d . -f 1,2); printf "checking vala... "; ${VALA} .test.vala 2>&1 >/dev/null if [ $? = 0 ]; then echo ${VALA}; else echo no ; HAVE_LANG_VALA=0 ; HAVE_VALA=0 fi else echo no ; HAVE_LANG_VALA=0 ; HAVE_VALAC=0 fi if [ "${HAVE_LANG_VALA}" = 0 ]; then echo "ERROR: ${VALAC} cannot create C code"; exit 1 fi rm -f .test.vala SEDFLAGS=" -e '" COUNT=0 for A in ${ENVWORDS} ; do [ "${A}" = VPATH ] && continue [ "${A}" = srcdir ] && continue eval "VAR=\$${A}" VAR="`echo ${VAR} | sed -e 's/\,/\\\,/g'`" [ $COUNT = 10 ] && COUNT=0 && SEDFLAGS="${SEDFLAGS}' -e '" COUNT=$(($COUNT+1)) SEDFLAGS="${SEDFLAGS}s,@${A}@,${VAR},g;" done SEDFLAGS="${SEDFLAGS}'" for A in ./config.mk ; do # SUBDIRS if [ -f "${VPATH}/${A}.acr" ]; then SD_TARGET=${A} else if [ -d "${VPATH}/${A}" ]; then SD_TARGET=${A}/Makefile mkdir -p ${A} else echo "ERROR: Cannot find ${VPATH}/${A}.acr" >&2 exit 1 fi fi echo "creating ${SD_TARGET}" mkdir -p $(echo ${A} | sed -e "s,/`basename ${A}`$,,g") cat ${VPATH}/${SD_TARGET}.acr | \ eval sed -e "s,@VPATH@,${VPATH}/${A},g" ${SEDFLAGS} > ${SD_TARGET}.tmp for A in ${ENVWORDS}; do VALUE=`eval echo "$"${A}` if [ "$VALUE" = 0 ]; then ## FALSE MARK="##${A}##" if [ -n "`grep \"${MARK}\" ${SD_TARGET}.tmp`" ]; then mv ${SD_TARGET}.tmp ${SD_TARGET}.tmp2 cat ${SD_TARGET}.tmp2 | MARK=$MARK awk 'BEGIN{a=0;}{if($1==ENVIRON["MARK"]){if(a)a=0;else a=1}else{if(!a)print;}}' > ${SD_TARGET}.tmp fi fi done mv ${SD_TARGET}.tmp ${SD_TARGET} && rm -f ${SD_TARGET}.tmp2 if [ ! $? = 0 ]; then echo Cannot write target file ; control_c ; fi done do_remove valabind-1.5.0/configure.acr000066400000000000000000000001561323123274000157440ustar00rootroot00000000000000PKGNAME valabind VERSION 1.5 CONTACT pancake ; pancake@nopcode.org LANG_C! LANG_VALA! SUBDIRS ./config.mk ; valabind-1.5.0/ctypeswriter.vala000066400000000000000000000443671323123274000167210ustar00rootroot00000000000000/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */ /* Copyright GPLv3 - 2009-2014 - pancake */ using Vala; private class CtypeCompiler { public GLib.SList classes; public CtypeClass cur; GLib.SList n; private bool sorted = false; public string to_string () { var str = ""; if (!this.sorted) this.sort (); foreach (var c in this.classes) str += c.to_string (); return str; } public CtypeCompiler() { this.cur = null; } public bool contains (string c) { foreach (var a in n) if (a.name == c) return true; return false; } public void sort () { uint count, count2 = 0; n = new GLib.SList(); do { count = classes.length (); foreach (var c in classes) { if (c.is_satisfied (this)) { n.append (c); classes.remove (c); } else { warning ("UNSATISFIED "+c.name); } } count2 = classes.length (); if (count2 > 0 && count == count2) { // detect infinite loop error ("Cannot compile, infinite loop dependency detected\n"); } } while (count2 > 0); /* refill */ foreach (var c in classes) { if (c.is_satisfied (this)) { n.prepend (c); classes.remove (c); } } this.classes = n.copy (); this.sorted = true; } public void add_class (string name, string text) { var cc = new CtypeClass (name); this.classes.append (cc); this.cur = cc; this.cur.append (text); this.sorted = false; } } private class CtypeClass { public string name; public string text; public GLib.SList deps; public bool is_satisfied (CtypeCompiler c) { foreach (var d in deps) { if (d == this.name) { stderr.printf ("==> "+d+"\n"); // break; } stderr.printf ("--> "+d+"\n"); if (!c.contains (d)) { return false; } } stderr.printf (" *** Yep. "+name+" is satisfied\n"); return true; } public CtypeClass(string? name) { this.deps = new SList(); this.name = name; this.text = ""; } public bool contains(SList a, string b) { if (b == this.name) { error ("Classes with self dependencies are not supported"); // return true; } foreach (var i in a) { if (i == b) return true; } return false; } public void add_dependency (string d) { if (!this.contains (deps, d)) deps.append (d); } /* public bool depends_on(string d) { foreach (var s in deps) if (s == d) return true; return false; } */ public string to_string() { return this.text; } public void append(string s) { this.text += s; } } public class CtypesWriter : ValabindWriter { public GLib.List includefiles = new GLib.List (); CtypeCompiler ctc = new CtypeCompiler (); string ?ns_pfx; string delegatestr = ""; public CtypesWriter () { } public override string get_filename (string base_name) { return base_name + ".py"; } // FIXME duplicate from NodeFFIWriter void add_includes (Symbol s) { foreach (string i in Vala.get_ccode_header_filenames (s).split (",")) { bool include = true; foreach (string j in includefiles) { if (i == j) { include = false; break; } } if (include) { includefiles.prepend (i); } } } // FIXME duplicate from NodeFFIWriter string sep (string str, string separator) { if (str.length != 0) { char last = str[str.length-1]; if (last != '(' && last != '[' && last != '{') { return str + separator; } } return str; } string get_alias (string oname) { string name = oname; switch (oname) { case "break": case "import": case "from": case "del": name = "_"+oname; break; case "continue": name = "cont"; break; } if (name != oname) { warning ("Method %s renamed to %s".printf (oname, name)); } return name; } string type_name (DataType type, bool retType=false, bool ignoreRef=false) { if (type == null) { warning ("Cannot resolve type"); return "__UNRESOLVED_TYPE_OH_PLEASE_KILL_ME__"; } // HACK is this required? if (type is EnumValueType) return "c_long"; // HACK needs proper generic support if (type is GenericType) return "c_void_p"; //return type.to_qualified_string (); if (type is PointerType) { var tn = type_name ((type as PointerType).base_type, retType, true); if (tn == "void") return "c_void_p"; return "POINTER("+tn+")"; } if (type is ArrayType) { ArrayType array = type as ArrayType; string element = type_name (array.element_type, retType); int len = array_length(array); if (len < 0) { return element; //+"*"; // FIXME should this be element+"[]"? } return "'"+element+"', * %d".printf (len); // FIXME will this work? } if (!ignoreRef && (type is ReferenceType)) { string unref_type = type_name (type, retType, true); // HACK just check for the string class instead (how?) if (unref_type == "char*" || unref_type == "const char*") { return unref_type; } // FIXME should it be & under C++? return unref_type; //+"_p"; //+"*"; } string generic = ""; foreach (DataType t in type.get_type_arguments ()) generic = sep (generic, ", ") + type_name (t); string _type = type.to_string (); // HACK find a better way to remove generic type args _type = _type.split ("<", 2)[0]; _type = _type.replace (ns_pfx, "").replace (".", ""); _type = _type.replace ("?",""); _type = _type.replace ("unsigned ", "u"); switch (_type) { case "bool": case "gboolean": return "c_bool"; case "gconstpointer": case "gpointer": return "c_void_p"; case "char": case "gchar": return "c_char"; case "gint": return "c_int"; case "uint": case "guint": return "c_uint"; case "glong": return "c_long"; case "ut8": case "uint8": case "guint8": return "c_ubyte"; case "guint16": case "uint16": return "c_ushort"; case "gint16": case "int16": case "short": return "c_short"; case "int": case "st32": case "int32": case "gint32": return "c_int"; case "ut32": case "uint32": case "guint32": return "c_uint"; case "st64": case "int64": case "gint64": return "c_longlong"; case "ut64": case "uint64": case "guint64": // HACK uint64_t doesn't work here because radare2 doesn't use the right type return "c_ulonglong"; case "gdouble": return "c_double"; case "gfloat": return "c_float"; case "string": return "c_char_p"; //case "const gchar*": // return "const char*"; // HACK needs proper generic support case "RList": return "RList"; case "SdbList": return "SdbList"; } return _type; } public override void visit_constant (Constant c) { warning ("Constants not yet supported on ctypes ("+c.name+")"); //var cname = Vala.get_ccode_name (c); //classes += c.name+" = "+cname+";\n"; } public override void visit_enum (Vala.Enum e) { add_includes (e); // TODO: copy from node } public override void visit_struct (Struct s) { string name = s.get_full_name ().replace (ns_pfx, "").replace (".", ""); visit_struct_or_class (s, name, s.get_fields (), s.get_methods (), null); } public override void visit_class (Class c) { string name = c.get_full_name ().replace (ns_pfx, "").replace (".", ""); visit_struct_or_class (c, name, c.get_fields (), c.get_methods (), c.get_delegates ()); /* walk nested structs and classes */ foreach (Struct s in c.get_structs ()) { s.accept (this); } foreach (Class k in c.get_classes ()) { k.accept (this); } /* TODO: add support for freefun in destructor string? freefun = null; if (Vala.is_reference_counting (c)) freefun = Vala.get_ccode_unref_function (c); else freefun = Vala.get_ccode_free_function (c); if (freefun == "") freefun = null; var methods = c.get_methods (); if (freefun != null || methods.size > 0) { ... */ } private string get_constructor_args(Vala.List methods) { foreach (Method m in methods) { if (m is CreationMethod) { var str = ""; add_includes (m); foreach (var foo in m.get_parameters ()) { str += ", "+get_alias (foo.name); } return str; } } return ""; } string wrappers; int n = 0; private void visit_struct_or_class (Symbol s, string name, Vala.List fields, Vala.List methods, Vala.List? delegates) { //string cname = Vala.get_ccode_name (s); add_includes (s); ctc.add_class (name, "class "+name+"(Structure): #"+n.to_string()+"\n"); stderr.printf ("--> "+name+" ("+n.to_string()+")\n"); n++; if (fields.size > 0) { ctc.cur.append ("\t_fields_ = [\n"); foreach (Field f in fields) f.accept (this); ctc.cur.append ("\t]\n"); } else { ctc.cur.append ("\t_fields_ = [\n\t]\n"); } if (methods.size > 0) { string call_args = get_constructor_args (methods); ctc.cur.append ("\tdef __init__(self"+call_args+"):\n"); ctc.cur.append ("\t\tStructure.__init__(self)\n"); // TODO: control how many methods and constructors there are // TODO: add support for more than one constructor /* constructors */ wrappers = ""; foreach (Method m in methods) if (m is CreationMethod) visit_method (m); /* helper function */ if (name == "RList") { ctc.cur.append ( "\tdef to_list(self,type):\n"+ "\t\treturn rlist2array(self,type)\n"); } if (name == "SdbList") { ctc.cur.append ( "\tdef to_list(self,type):\n"+ "\t\treturn sdblist2array(self,type)\n"); } /* delegates */ if (delegates != null) foreach (Delegate d in delegates) visit_delegate (d); ctc.cur.append ("\n\t_o = AddressHolder()\n\n"); /* methods */ foreach (Method m in methods) if (!(m is CreationMethod)) visit_method (m); ctc.cur.append (wrappers); ctc.cur.append ("\n"); } } public override void visit_field (Field f) { if (f.is_private_symbol ()) return; // HACK don't output fields with C++ keywords as names. if (f.name == "class") return; string field = ""; DataType type = f.variable_type; var stype = type.to_string (); if (type is ArrayType) { ArrayType array = type as ArrayType; string element = type_name (array.element_type); warning ("Arrays not yet supported in ctypes bindings"); int len = array_length(array); if (len < 0) { field = element + "* " + f.name; // FIXME should this be element+"[]"? } field = "'%s', %s * %d".printf (f.name, element, len); // warning ("Field is array " + element); // ctc.cur.add_dependency ("RRegItem"); // if dependency type is not a c one if (element[0] != 'c' && element[1] != '_') { ctc.cur.add_dependency (element); } else { warning ("NODEP " + element); } } else { /* HACK to support generics. this is r2 specific */ if (stype.index_of ("RListIter") != -1) { stype = "c_void_p"; // XXX RListIter*"; } else if (stype.index_of ("RList") != -1) { stype = "c_void_p"; // XXX "RList*"; } else if (stype.index_of ("SdbListIter") != -1) { stype = "c_void_p"; // XXX SdbListIter*"; } else if (stype.index_of ("SdbList") != -1) { stype = "c_void_p"; // XXX "SdbList*"; } else stype = type_name (type); field = "\"%s\", %s".printf (f.name, stype); } ctc.cur.append ("\t\t(" + field + "),\n"); if (stype[0].isupper () && !stype.has_prefix ("POINTER") && stype.index_of (".") == -1) { //stderr.printf ("ADD DEP : "+field+" "+stype+"\n"); ctc.cur.add_dependency (stype); } } public override void visit_delegate (Delegate d) { string cname = Vala.get_ccode_name (d); string args = ""; foreach (var p in d.get_parameters ()) { DataType? bar = p.variable_type; string? arg_type = type_name (bar); args += ", "+arg_type; } var cn = d.parent_symbol.get_full_name ().replace (ns_pfx, "").replace (".", ""); this.delegatestr += cname + " = CFUNCTYPE ("+cn+args+")\n"; } public override void visit_method (Method m) { if (m.is_private_symbol ()) return; add_includes (m); string cname = Vala.get_ccode_name (m); //string alias = get_alias (m.name); bool is_static = (m.binding & MemberBinding.STATIC) != 0; bool is_constructor = (m is CreationMethod); //var parent = m.parent_symbol; //bool parent_is_class = parent is Class || parent is Struct; // TODO: Implement contractual support // m.get_preconditions (); // m.get_postconditions (); string ret = type_name (m.return_type, true); string pyc_args = ""; string def_args = ""; string call_args = ""; string clears = ""; foreach (var foo in m.get_parameters ()) { //DataType? bar = foo.parameter_type; DataType? bar = foo.variable_type; if (bar == null) { warning ("Unknown datatype "+foo.name+"\n"); continue; } string arg_name = get_alias (foo.name); string? arg_type = type_name (bar); /* TODO: move to type_name */ if (foo.direction != ParameterDirection.IN) { var var_name = ""; if (foo.direction == ParameterDirection.OUT) var_name = "OUTPUT"; else if (foo.direction == ParameterDirection.REF) var_name = "INOUT"; if (arg_type.index_of ("*") == -1) arg_type = "POINTER("+arg_type+")"; //applys += "\t%%apply %s %s { %s %s };\n".printf (arg_type, var_name, arg_type, arg_name); clears += "\t%%clear %s %s;\n".printf (arg_type, arg_name); } call_args = sep (call_args, ", ") + arg_name; def_args = sep (def_args, ", ") + arg_type + " " + arg_name; pyc_args = sep (pyc_args, ", ") + arg_type; } if (is_constructor) { var text = "\t\t%s = lib.%s\n".printf (cname, cname); text += "\t\t%s.restype = c_void_p\n".printf (cname); text += "\t\tself._o = %s (%s)\n".printf (cname, call_args); // TODO: support constructor arguments #if 0 var classname = parent.get_full_name ().replace (ns_pfx, "").replace (".", ""); text += "\t%s (%s) {\n".printf (classname, def_args); if (context.is_defined ("GOBJECT")) text += "\t\tg_type_init ();\n"; text += "\t\treturn %s (%s);\n\t}\n".printf (cname, call_args); #endif text += clears; ctc.cur.append (text); } else { if (!is_static) { if (pyc_args == "") pyc_args = "c_void_p"; else pyc_args = "c_void_p, " + pyc_args; } if (ret == "RList") { wrappers +="\tdef %s(self%s):\n".printf (m.name, call_args); m.name = "_"+m.name; string gen = ""; var type = m.return_type; foreach (DataType t in type.get_type_arguments ()) gen = sep (gen, ", ") + type_name (t); ret = "RList<"+gen+">"; wrappers +="\t\treturn rlist2array(self.%s(%s),%s)\n".printf ( m.name, call_args, gen); } if (ret == "SdbList") { wrappers +="\tdef %s(self%s):\n".printf (m.name, call_args); m.name = "_"+m.name; string gen = ""; var type = m.return_type; foreach (DataType t in type.get_type_arguments ()) gen = sep (gen, ", ") + type_name (t); ret = "SdbList<"+gen+">"; wrappers +="\t\treturn sdblist2array(self.%s(%s),%s)\n".printf ( m.name, call_args, gen); } ret = (ret=="void")? "None": "'"+ret+"'"; ctc.cur.append ( "\t%s, %s = register('%s','%s',%s)\n".printf ( get_alias(m.name), cname, cname, pyc_args, ret)); } } public override void visit_namespace (Namespace ns) { string name = ns.get_full_name (); bool use = use_namespace (ns); if (use) ns_pfx = name+ "."; if (ns_pfx != null) add_includes (ns); foreach (var n in ns.get_namespaces ()) n.accept (this); if (ns_pfx != null) { foreach (Constant c in ns.get_constants ()) c.accept (this); foreach (Vala.Enum e in ns.get_enums ()) e.accept (this); foreach (Struct s in ns.get_structs ()) s.accept (this); foreach (Class c in ns.get_classes ()) c.accept (this); } if (use) ns_pfx = null; } public override void write (string file) { var stream = FileStream.open (file, "w"); if (stream == null) error ("Cannot open %s for writing".printf (file)); stream.printf ( "# this file has been automatically generated by valabind\n"+ "import sys\n"+ "from ctypes import *\n"+ "from ctypes.util import find_library\n"+ "if sys.platform.startswith('win'):\n"+ " lib = WinDLL (find_library ('%s'))\n"+ "else:\n"+ " lib = CDLL (find_library ('%s'))\n", library, library); stream.puts ( "def rlist2array(x,y):\n"+ " it = x.iterator ()\n"+ " ret = []\n"+ " while True:\n"+ " data = it.get_data ()\n"+ " ds = cast (data, POINTER(y)).contents\n"+ " ret.append (ds)\n"+ " if it.n == None:\n"+ " break\n"+ " it = it.get_next ()\n"+ " return ret\n"+ "\n"+ "class AddressHolder(object):\n"+ " def __get__(self, obj, type_):\n"+ " if getattr(obj, '_address', None) is None:\n"+ " obj._address = addressof(obj)\n"+ " return obj._address\n"+ "\n"+ " def __set__(self, obj, value):\n"+ " obj._address = value\n"+ "\n"+ "class WrappedRMethod(object):\n"+ " def __init__(self, cname, args, ret):\n"+ " self.cname = cname\n"+ " self.args = args\n"+ " self.ret = ret\n"+ " self.args_set = False\n"+ " self.method = getattr(lib, cname)\n"+ "\n"+ " def __call__(self, *a):\n"+ " if not self.args_set:\n"+ " if self.args:\n"+ " self.method.argtypes = [eval(x.strip()) for x in self.args.split(',')]\n"+ " self.method.restype = eval(self.ret) if self.ret else None\n"+ " self.args_set = True\n"+ " return self.method(*a)\n"+ "\n"+ "class WrappedApiMethod(object):\n"+ " def __init__(self, method, ret2, last):\n"+ " self.method = method\n"+ " self._o = None\n"+ " self.ret2 = ret2\n"+ " self.last = last\n"+ "\n"+ " def __call__(self, *a):\n"+ " result = self.method(self._o, *a)\n"+ " if self.ret2:\n"+ " result = eval(self.ret2)(result)\n"+ " if self.last:\n"+ " return getattr(result, self.last)\n"+ " return result\n"+ "\n"+ " def __get__(self, obj, type_):\n"+ " self._o = obj._o\n"+ " return self\n"+ "\n"+ "def register(cname, args, ret):\n"+ " ret2 = last = None\n"+ " if ret:\n"+ " if ret[0]>='A' and ret[0]<='Z':\n"+ " x = ret.find('<')\n"+ " if x != -1:\n"+ " ret = ret[0:x]\n"+ " last = 'contents'\n"+ " ret = 'POINTER('+ret+')'\n"+ " else:\n"+ " last = 'value'\n"+ " ret2 = ret\n"+ " \n"+ " method = WrappedRMethod(cname, args, ret)\n"+ " wrapped_method = WrappedApiMethod(method, ret2, last)\n"+ " return wrapped_method, method\n\n"); context.root.accept (this); stream.printf (ctc.to_string ()); stream.puts (delegatestr); } } valabind-1.5.0/cxxwriter.vala000066400000000000000000000306021323123274000161770ustar00rootroot00000000000000/* Copyright 2009-2015 -- pancake // nopcode.org */ using Vala; public class CxxWriter : ValabindWriter { public GLib.List includefiles = new GLib.List (); public GLib.List methods; string classname = ""; string classcname; string externs = ""; string statics = ""; string extends = ""; string enums = ""; string vectors = ""; string nspace; public CxxWriter () { } public override string get_filename (string base_name) { return base_name+".cxx"; } string get_alias (string name) { string oname = name; switch (name) { case "not_eq": case "or_eq": case "xor_eq": case "and_eq": case "or": case "xor": case "not": case "and": case "break": case "while": case "print": case "new": case "for": case "if": case "case": case "delete": case "continue": return "_"+name; } if (name != oname) warning ("%s.%s method renamed to %s.%s".printf ( classname, oname, classname, name)); return name; } string get_ctype (string _type) { string type = _type; string? iter_type = null; if (type == "null") error ("Cannot resolve type"); if (type.has_prefix (nspace)) type = type.substring (nspace.length) + "*"; type = type.replace (".", ""); if (is_generic (type)) { int ptr = type.index_of ("<"); iter_type = (ptr==-1)?type:type[ptr:type.length]; iter_type = iter_type.replace ("<", ""); iter_type = iter_type.replace (">", ""); iter_type = iter_type.replace (nspace, ""); type = type.split ("<", 2)[0]; } type = type.replace ("?",""); switch (type) { case "const gchar*": return "const char*"; case "G": /* generic type :: TODO: review */ case "gconstpointer": case "gpointer": return "void*"; case "gsize": return "size_t"; case "gdouble": return "double"; case "gfloat": return "float"; case "ut8": case "uint8": case "guint8": return "unsigned char"; case "gchar**": return "char **"; case "gchar": return "char"; case "gchar*": case "string": return "char *"; // ??? case "gint": return "int"; case "glong": return "long"; case "st64": case "int64": case "gint64": return "long long"; case "ut64": case "uint64": case "guint64": return "unsigned long long"; /* XXX swig does not support unsigned char* */ case "uint8*": case "guint8*": return "unsigned char*"; case "guint16": case "uint16": return "unsigned short"; case "ut32": case "uint32": case "guint32": return "unsigned int"; case "bool": // no conversion needed case "gboolean": return "bool"; // XXX bool? case "RFList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; case "RList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; case "SdbList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; } return type; } bool is_target_file (string path) { // FIXME implement the new method with use_namespace instead foreach (var file in source_files) if (file == path) return true; return false; } public override void visit_source_file (SourceFile source) { if (is_target_file (source.filename)) source.accept_children (this); } public void process_includes (Symbol s) { foreach (var foo in Vala.get_ccode_header_filenames (s).split (",")) { var include = true; foreach (var inc in includefiles) { if (inc == foo) { include = false; break; } } if (include) includefiles.prepend (foo); } } public void walk_field (Field f) { if (f.get_attribute_string ("CCode", "type") == null) { //warning ( // "Cannot resolve type for field '%s'".printf (f.get_cname ())); } else { warning ("Type for %s\n".printf ( Vala.get_ccode_name (f))); } //if (f.access == Accessibility.PRIVATE) // print ("---> field is private XXX\n"); //if (Vala.get_ccode_array_length (f)) // print ("---> array without length\n"); } HashTable defined_classes = new HashTable (str_hash, str_equal); public void walk_class (string pfx, Class c) { foreach (var k in c.get_classes ()) walk_class (c.name, k); classname = pfx+c.name; classcname = Vala.get_ccode_name (c); process_includes (c); bool has_constructor = false; foreach (var m in c.get_methods ()) if (m is CreationMethod) { has_constructor = true; break; } //bool is_static = (c.static_constructor != null); bool has_destructor = !c.is_compact; //stdout.printf ("class %s %s\n", // classname, c.is_compact.to_string () ); if (context.profile == Profile.GOBJECT) classname = "%s_%s".printf (nspace, classname); if (defined_classes.lookup (classname)) return; defined_classes.insert (classname, true); if (context.profile == Profile.GOBJECT) extends += "class %s_%s {\n".printf (modulename, classcname); else extends += "class %s_%s {\n".printf (modulename, classname); //if (has_destructor && has_constructor) extends += " %s *self;\n".printf (classname); extends += " public:\n"; foreach (var e in c.get_enums ()) walk_enum (e); foreach (var f in c.get_fields ()) walk_field (f); //c.static_destructor!=null?"true":"false"); if (has_destructor && has_constructor) { if (Vala.is_reference_counting (c)) { string? freefun = Vala.get_ccode_unref_function (c); if (freefun != null) extends += " ~%s_%s() {\n %s (self);\n }\n".printf (modulename, classname, freefun); } else { string? freefun = Vala.get_ccode_free_function (c); if (freefun != null) extends += " ~%s_%s() {\n %s (self);\n }\n".printf (modulename, classname, freefun); } } foreach (var m in c.get_methods ()) walk_method (m); extends += "};\n"; classname = ""; } public void walk_enum (Vala.Enum e) { #if not_required var enumname = classname + e.name; var tmp = "%{\n"; enums += "/* enum: %s (%s) */\n".printf ( e.name, Vala.get_ccode_name (e)); enums += "enum %s {\n".printf (enumname); tmp += "#define %s long int\n".printf (enumname); // XXX: Use cname? foreach (var v in e.get_values ()) { enums += " %s_%s,\n".printf (e.name, v.name); tmp += "#define %s_%s %s\n".printf (e.name, v.name, Vala.get_ccode_name (v)); } enums += "};\n"; enums += tmp + "%}\n"; #endif } inline bool is_generic(string type) { return (type.index_of ("<") != -1 && type.index_of (">") != -1); } public void walk_method (Method m) { bool first = true; string cname = Vala.get_ccode_name (m); string alias = get_alias (m.name); string ret; string def_args = ""; string call_args = ""; bool void_return; bool is_static = (m.binding & MemberBinding.STATIC) != 0; bool is_constructor = (m is CreationMethod); // TODO: Implement contractual support // m.get_preconditions (); // m.get_postconditions (); ret = m.return_type.to_string (); ret = get_ctype (is_generic (ret)? ret : Vala.get_ccode_name (m.return_type)); if (ret == null) error ("Cannot resolve return type for %s\n".printf (cname)); void_return = (ret == "void"); if (m.is_private_symbol ()) return; string applys = ""; string clears = ""; string pfx = ""; foreach (var foo in m.get_parameters ()) { string arg_name = foo.name; //DataType? bar = foo.parameter_type; DataType? bar = foo.variable_type; if (bar == null) continue; string? arg_type = get_ctype (Vala.get_ccode_name (bar)); if (first) { pfx = ""; first = false; } else pfx = ", "; /* TODO: move to get_ctype */ if (foo.direction != ParameterDirection.IN) { var var_name = ""; if (foo.direction == ParameterDirection.OUT) var_name = "OUTPUT"; else if (foo.direction == ParameterDirection.REF) var_name = "INOUT"; if (arg_type.index_of ("*") == -1) arg_type += "*"; applys += " %%apply %s %s { %s %s };\n".printf ( arg_type, var_name, arg_type, arg_name); //clears += " %%clear %s %s;\n".printf (arg_type, arg_name); } call_args += "%s%s".printf (pfx, arg_name); def_args += "%s%s %s".printf (pfx, arg_type, arg_name); } /* object oriented shit */ if (classname == "") { externs += "extern %s %s (%s);\n".printf (ret, cname, def_args); is_constructor = false; is_static = true; classname = nspace; } //else { if (nspace == classname) alias = nspace+"_"+alias; if (is_constructor) { externs += "extern %s* %s (%s);\n".printf (classcname, cname, def_args); //extends += applys; extends += " %s_%s (%s) {\n".printf (modulename, classname, def_args); if (context.profile == Profile.GOBJECT) extends += " g_type_init ();\n"; extends += " self = %s (%s);\n }\n".printf (cname, call_args); extends += clears; } else { if (!is_static) call_args = (call_args == "")? "self": "self, " + call_args; // externs += "extern %s %s (%s*, %s);\n".printf (ret, cname, classname, def_args); // extends += applys; if (is_static) extends += " static %s %s (%s) {\n".printf (ret, alias, def_args); else extends += " %s %s (%s) {\n".printf (ret, alias, def_args); if (ret.index_of ("std::vector") != -1) { int ptr = ret.index_of ("<"); string iter_type = (ptr==-1)?ret:ret[ptr:ret.length]; iter_type = iter_type.replace ("<", ""); iter_type = iter_type.replace (">", ""); // TODO: Check if iter type exists before failing // instead of hardcoding the most common type '' // TODO: Do not construct a generic class if not supported // instead of failing. if (iter_type == "G*") /* No generic */ error ("Pancake's fault, no type support.\n"); // TODO: Do not recheck the return_type if (m.return_type.to_string ().index_of ("RFList") != -1) { extends += " %s ret;\n".printf (ret); extends += " void** array;\n"; extends += " %s *item;\n".printf (iter_type); extends += " array = %s (%s);\n".printf (cname, call_args); extends += " r_flist_rewind (array);\n"; extends += " while (*array != 0 && (item = (%s*)(*array++)))\n".printf (iter_type); extends += " ret.push_back(*item);\n"; extends += " return ret;\n"; extends += " }\n"; } else if (m.return_type.to_string ().index_of ("RList") != -1) { extends += " %s ret;\n".printf (ret); extends += " RList *list;\n"; extends += " RListIter *iter;\n"; extends += " %s *item;\n".printf (iter_type); extends += " list = %s (%s);\n".printf (cname, call_args); extends += " if (list)\n"; extends += " for (iter = list->head; iter && (item = (%s*)iter->data); iter = iter->n)\n".printf (iter_type); extends += " ret.push_back(*item);\n"; extends += " return ret;\n"; extends += " }\n"; } vectors += " %%template(%sVector) std::vector<%s>;\n".printf ( iter_type, iter_type); } else { extends += " %s %s (%s);\n }\n".printf ( void_return?"":"return", cname, call_args); } extends += clears; } //} } public override void visit_namespace (Namespace ns) { if (ns.name == null) return; classname = ""; SourceReference? sr = ns.source_reference; if (sr != null && !is_target_file (sr.file.filename)) return; nspace = ns.name; process_includes (ns); /* if (pkgmode && sr.file.filename.index_of (pkgname) == -1) return; */ foreach (var f in ns.get_fields ()) walk_field (f); foreach (var e in ns.get_enums ()) walk_enum (e); foreach (var c in ns.get_structs ()) { /* TODO: refactor to walk_struct */ foreach (var m in c.get_methods ()) walk_method (m); foreach (var f in c.get_fields ()) walk_field (f); } foreach (var m in ns.get_methods ()) walk_method (m); var classprefix = ns.name == modulename? ns.name: ""; foreach (var c in ns.get_classes ()) walk_class (classprefix, c); //ns.name, c); //ns.accept_children (this); } public override void write (string file) { var stream = FileStream.open (file, "w"); if (stream == null) error ("Cannot open %s for writing".printf (file)); context.accept (this); if (includefiles.length () > 0) { stream.printf ("extern \"C\" {\n"); foreach (var inc in includefiles) stream.printf ("#include <%s>\n", inc); stream.printf ("}\n#include \n"); } foreach (var inc in includefiles) stream.printf ("#include <%s>\n", inc); /* if (vectors != "") stream.printf ("namespace std {\n%s}\n", vectors); */ stream.printf ("%s\n", enums); stream.printf ("%s\n", statics); stream.printf ("%s\n", extends); } } valabind-1.5.0/dlangwriter.vala000066400000000000000000000325301323123274000164640ustar00rootroot00000000000000/* Copyright 2013-2015 -- pancake */ using Vala; public class DlangWriter : ValabindWriter { public GLib.List includefiles = new GLib.List (); public GLib.List methods; string classname = ""; string classcname; string defs = ""; string statics = ""; string extends = ""; string enums = ""; string vectors = ""; string nspace; public DlangWriter () { } public override string get_filename (string base_name) { return base_name+".d"; } string get_alias (string name) { string oname = name; switch (name) { case "not_eq": case "or_eq": case "xor_eq": case "and_eq": case "or": case "xor": case "not": case "and": case "break": case "while": case "print": case "new": case "for": case "if": case "case": case "delete": case "continue": return "_"+name; } if (name != oname) warning ("%s.%s method renamed to %s.%s".printf ( classname, oname, classname, name)); return name; } string get_ctype (string _type) { string type = _type; string? iter_type = null; if (type == "null") error ("Cannot resolve type"); if (type.has_prefix (nspace)) type = type.substring (nspace.length) + "*"; type = type.replace (".", ""); if (is_generic (type)) { int ptr = type.index_of ("<"); iter_type = (ptr==-1)?type:type[ptr:type.length]; iter_type = iter_type.replace ("<", ""); iter_type = iter_type.replace (">", ""); iter_type = iter_type.replace (nspace, ""); type = type.split ("<", 2)[0]; } type = type.replace ("?",""); switch (type) { case "G": /* generic type :: TODO: review */ case "gconstpointer": case "gpointer": case "void*": return "void*"; case "gsize": return "size_t"; case "gdouble": return "double"; case "gfloat": return "float"; case "ut8": case "uint8": case "guint8": return "byte"; case "gchar**": return "char **"; case "char": case "gchar": return "char"; case "gchar*": case "string": case "const gchar*": return "string"; // XXX lost const? case "void": return "void"; case "int[]": case "int": case "gint": return "int"; case "guint": return "uint"; case "glong": return "long"; case "st64": case "int64": case "gint64": return "long"; case "ut64": case "uint64": case "guint64": return "ulong"; /* XXX swig does not support unsigned char* */ case "uint8*": case "guint8*": return "byte*"; case "guint16": case "uint16": return "ushort"; case "ut32": case "uint32": case "guint32": return "unsigned int"; case "bool": // no conversion needed case "gboolean": return "bool"; // XXX bool? case "RFList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; case "RList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; case "SdbList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; default: type = "_"+type; break; } return type; } bool is_target_file (string path) { // FIXME implement the new method with use_namespace instead foreach (var file in source_files) if (file == path) return true; return false; } public override void visit_source_file (SourceFile source) { if (is_target_file (source.filename)) source.accept_children (this); } public void process_includes (Symbol s) { foreach (var foo in Vala.get_ccode_header_filenames (s).split (",")) { var include = true; foreach (var inc in includefiles) { if (inc == foo) { include = false; break; } } if (include) includefiles.prepend (foo); } } public void walk_field (Field f) { if (f.get_attribute_string ("CCode", "type") == null) { //warning ( // "Cannot resolve type for field '%s'".printf (f.get_cname ())); } else { warning ("Type for %s\n".printf ( Vala.get_ccode_name (f))); } string type = f.variable_type.to_string (); string name = f.name; if (type != "G") if (type.index_of ("<") == -1) { type = get_ctype (type); if (f.variable_type is ArrayType) { ArrayType array = f.variable_type as ArrayType; int len = array_length(array); int sz = len < 0 ? 0 : len; defs += " %s %s[%d];\n".printf (type, name, sz); } else { defs += " %s %s;\n".printf (type, name); } } //if (f.access == Accessibility.PRIVATE) // print ("---> field is private XXX\n"); //if (Vala.get_ccode_array_length (f)) // print ("---> array without length\n"); } HashTable defined_classes = new HashTable (str_hash, str_equal); public void walk_struct (string pfx, Struct s) { defs += "struct _%s%s {\n".printf (pfx, s.name); foreach (var f in s.get_fields ()) walk_field (f); defs += "}\n"; } public void walk_class (string pfx, Class c) { foreach (var k in c.get_structs ()) { walk_struct (c.name, k); } foreach (var k in c.get_classes ()) walk_class (c.name, k); classname = pfx+c.name; classcname = "_"+Vala.get_ccode_name (c); process_includes (c); bool has_constructor = false; foreach (var m in c.get_methods ()) if (m is CreationMethod) { has_constructor = true; break; } //bool is_static = (c.static_constructor != null); bool has_destructor = !c.is_compact; //stdout.printf ("class %s %s\n", // classname, c.is_compact.to_string () ); /* if (context.profile == Profile.GOBJECT) classname = "%s_%s".printf (nspace, classname); */ if (defined_classes.lookup (classname)) return; defined_classes.insert (classname, true); //extends += "struct %s {\n".printf (classcname); // TODO: add fields here //extends += "}\n"; defs += "struct %s {\n".printf (classcname); foreach (var f in c.get_fields ()) walk_field (f); defs += "}\n"; extends += "class %s {\n".printf (classname); extends += " %s *self;\n".printf (classcname); //extends += " public:\n"; foreach (var e in c.get_enums ()) walk_enum (e); //c.static_destructor!=null?"true":"false"); if (has_destructor && has_constructor) { if (Vala.is_reference_counting (c)) { string? freefun = Vala.get_ccode_unref_function (c); if (freefun != null && freefun != "") extends += " ~this() { %s (o); }\n".printf (freefun); } else { string? freefun = Vala.get_ccode_free_function (c); if (freefun != null) extends += " ~this() { %s (o); }\n".printf (freefun); } } foreach (var m in c.get_methods ()) walk_method (m); extends += "};\n"; classname = ""; } public void walk_enum (Vala.Enum e) { #if not_required var enumname = classname + e.name; var tmp = "%{\n"; enums += "/* enum: %s (%s) */\n".printf ( e.name, Vala.get_ccode_name (e)); enums += "enum %s {\n".printf (enumname); tmp += "#define %s long int\n".printf (enumname); // XXX: Use cname? foreach (var v in e.get_values ()) { enums += " %s_%s,\n".printf (e.name, v.name); tmp += "#define %s_%s %s\n".printf (e.name, v.name, Vala.get_ccode_name (v)); } enums += "};\n"; enums += tmp + "%}\n"; #endif } inline bool is_generic(string type) { return (type.index_of ("<") != -1 && type.index_of (">") != -1); } public void walk_method (Method m) { bool first = true; string cname = Vala.get_ccode_name (m); string alias = get_alias (m.name); string ret; string def_args = ""; string cdef_args = ""; string call_args = ""; bool void_return; bool is_static = (m.binding & MemberBinding.STATIC) != 0; bool is_constructor = (m is CreationMethod); // TODO: Implement contractual support // m.get_preconditions (); // m.get_postconditions (); ret = m.return_type.to_string (); ret = get_ctype (is_generic (ret)? ret : Vala.get_ccode_name (m.return_type)); if (ret == null) error ("Cannot resolve return type for %s\n".printf (cname)); void_return = (ret == "void"); if (m.is_private_symbol ()) return; string pfx = ""; string cpfx = ""; //cdef_args += "%s%s".printf (pfx, "void*"); if (!is_static) { cdef_args += classcname+"*"; cpfx = ", "; pfx = ""; } foreach (var foo in m.get_parameters ()) { string arg_name = foo.name; //DataType? bar = foo.parameter_type; DataType? bar = foo.variable_type; if (bar == null) continue; string? arg_type = get_ctype (Vala.get_ccode_name (bar)); if (first) { first = false; } else cpfx = pfx = ", "; /* TODO: move to get_ctype */ if (foo.direction != ParameterDirection.IN) { var var_name = ""; if (foo.direction == ParameterDirection.OUT) var_name = "ref"; else if (foo.direction == ParameterDirection.REF) var_name = "ref"; if (arg_type.index_of ("*") == -1) arg_type += "*"; } if (arg_type=="string") { call_args += "%s toStringz(%s)".printf (pfx, arg_name); cdef_args += "%s%s %s".printf (cpfx, "immutable(char*)", arg_name); def_args += "%s%s %s".printf (pfx, arg_type, arg_name); } else { call_args += "%s%s".printf (pfx, arg_name); def_args += "%s%s %s".printf (pfx, arg_type, arg_name); cdef_args += "%s%s %s".printf (cpfx, arg_type, arg_name); } } /* object oriented shit */ if (classname == "") { //defs += " %s* %s(%s);\n".printf (ret, cname, cdef_args); is_constructor = false; is_static = true; classname = nspace; } if (nspace == classname) alias = nspace+"_"+alias; if (is_constructor) { defs += " %s* %s(%s);\n".printf (classcname, cname, def_args.replace("string","immutable(char*)")); extends += " this (%s) {\n".printf (def_args); extends += " self = %s (%s);\n }\n".printf (cname, call_args); } else { if (!is_static) call_args = (call_args == "")? "self": "self, " + call_args; if (is_static) { extends += " %s %s (%s) {\n".printf (ret, alias, def_args); //extends += " static %s %s (%s) {\n".printf (ret, alias, def_args); } else { string fret = ""; if (alias == "free") { alias= "~this"; } else fret = ret; extends += " %s %s (%s) {\n".printf (fret, alias, def_args); } if (ret.index_of ("std::vector") != -1) { int ptr = ret.index_of ("<"); string iter_type = (ptr==-1)?ret:ret[ptr:ret.length]; iter_type = iter_type.replace ("<", ""); iter_type = iter_type.replace (">", ""); // TODO: Check if iter type exists before failing // instead of hardcoding the most common type '' // TODO: Do not construct a generic class if not supported // instead of failing. if (iter_type == "G*") /* No generic */ error ("Pancake's fault, no type support.\n"); // TODO: Do not recheck the return_type if (m.return_type.to_string ().index_of ("RFList") != -1) { extends += " %s ret;\n".printf (ret); extends += " void** array;\n"; extends += " %s *item;\n".printf (iter_type); extends += " array = %s (%s);\n".printf (cname, call_args); extends += " r_flist_rewind (array);\n"; extends += " while (*array != 0 && (item = (%s*)(*array++)))\n".printf (iter_type); extends += " ret.push_back(*item);\n"; extends += " return ret;\n"; extends += " }\n"; } else if (m.return_type.to_string ().index_of ("RList") != -1) { extends += " %s ret;\n".printf (ret); extends += " RList *list;\n"; extends += " RListIter *iter;\n"; extends += " %s *item;\n".printf (iter_type); extends += " list = %s (%s);\n".printf (cname, call_args); extends += " if (list)\n"; extends += " for (iter = list->head; iter && (item = (%s*)iter->data); iter = iter->n)\n".printf (iter_type); extends += " ret.push_back(*item);\n"; extends += " return ret;\n"; extends += " }\n"; } vectors += " %%template(%sVector) std::vector<%s>;\n".printf ( iter_type, iter_type); } else { defs += " %s %s(%s);\n".printf (ret, cname, cdef_args); extends += " %s %s (%s);\n }\n".printf ( void_return?"":"return", cname, call_args); } } } public override void visit_namespace (Namespace ns) { if (ns.name == null) return; classname = ""; SourceReference? sr = ns.source_reference; if (sr != null && !is_target_file (sr.file.filename)) return; nspace = ns.name; process_includes (ns); /* if (pkgmode && sr.file.filename.index_of (pkgname) == -1) return; */ foreach (var f in ns.get_fields ()) walk_field (f); foreach (var e in ns.get_enums ()) walk_enum (e); foreach (var c in ns.get_structs ()) { /* TODO: refactor to walk_struct */ foreach (var m in c.get_methods ()) walk_method (m); foreach (var f in c.get_fields ()) walk_field (f); } foreach (var m in ns.get_methods ()) walk_method (m); var classprefix = ns.name == modulename? ns.name: ""; foreach (var c in ns.get_classes ()) walk_class (classprefix, c); //ns.name, c); //ns.accept_children (this); } public override void write (string file) { var stream = FileStream.open (file, "w"); if (stream == null) error ("Cannot open %s for writing".printf (file)); defs = "extern(C) {\n"; context.accept (this); defs += " alias int function(int, int) _RNumCallback;\n"; // HACK defs += "}\n"; stream.printf ("/* valabind autogenerated D bindings for %s */\n".printf (modulename)); stream.printf ("pragma(lib,\"%s\");\n".printf (modulename)); stream.printf ("pragma(lib,\"r_util\");\n"); stream.printf ("import std.string;\n"); stream.printf ("%s\n", defs); stream.printf ("%s\n", enums); stream.printf ("%s\n", statics); stream.printf ("%s\n", extends); } } valabind-1.5.0/getvv000077500000000000000000000004371323123274000143570ustar00rootroot00000000000000#!/bin/sh IFS=: [ -z "${VALAC}" ] && VALAC=valac for a in $PATH; do if [ -e "$a/valac" ]; then v=$(cat $a/${VALAC} | strings | grep vala- | grep -v lib | head -n1) if [ -n "$v" ]; then printf $v exit 0 fi fi done echo "Cannot find valac version string" >/dev/stderr exit 1 valabind-1.5.0/girwriter.vala000066400000000000000000000257631323123274000161720ustar00rootroot00000000000000/* Copyright 2011-2015 -- pancake */ using Vala; public class GirWriter : ValabindWriter { public GLib.List includefiles = new GLib.List (); public GLib.List methods; string classname = ""; string classcname; string externs = ""; string statics = ""; string extends = ""; string enums = ""; string nspace; public GirWriter () { } public override string get_filename (string base_name) { return base_name+".gir"; } string get_alias (string name) { string oname = name; switch (name) { /* case "use": return "_use"; */ case "cmd": name = "_cmd"; break; case "def": name = "_def"; break; case "print": name = "_print"; break; case "del": name = "_del"; break; case "from": name = "_from"; break; case "continue": name = "cont"; break; } if (name != oname) warning ("%s.%s method renamed to %s.%s".printf ( classname, oname, classname, name)); return name; } string get_ctype (string _type) { string type = _type; string? iter_type = null; if (type == "null") error ("Cannot resolve type"); if (type.has_prefix (nspace)) type = type.substring (nspace.length) + "*"; type = type.replace (".", ""); if (is_generic (type)) { int ptr = type.index_of ("<"); iter_type = (ptr==-1)?type:type[ptr:type.length]; iter_type = iter_type.replace ("<", ""); iter_type = iter_type.replace (">", ""); iter_type = iter_type.replace (nspace, ""); type = type.split ("<", 2)[0]; } type = type.replace ("?", ""); switch (type) { case "const gchar*": return "const char*"; case "G": /* generic type :: TODO: review */ case "gconstpointer": case "gpointer": return "void*"; case "gdouble": return "double"; case "gfloat": return "float"; case "break": return "_break"; case "ut8": case "uint8": case "guint8": return "unsigned char"; case "gchar**": return "char **"; case "gchar": return "char"; case "gchar*": case "string": return "char *"; //return "char *"; // ??? case "gint": return "int"; case "glong": return "long"; case "st64": case "int64": case "gint64": return "long long"; case "ut64": case "uint64": case "guint64": return "unsigned long long"; /* XXX swig does not support unsigned char* */ case "uint8*": case "guint8*": return "unsigned char*"; case "guint16": case "uint16": return "unsigned short"; case "ut32": case "uint32": case "guint32": return "unsigned int"; case "bool": // no conversion needed case "gboolean": return "gboolean"; case "RFList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; case "RList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; case "SdbList": if (iter_type != null) return "std::vector<"+iter_type+">"; break; } return type; } static string girtype(string ret) { switch (ret) { case "int[]": return "gpointer"; // XXX case "string?": case "string": case "char*": case "char *": case "const char*": ret = "utf8"; break; case "uint": case "uint32": case "unsigned int": ret = "guint"; break; case "int": case "int32": ret = "gint"; break; case "unsigned long long": case "uint64": ret = "guint64"; break; case "void*": case "unsigned char*": case "uint8*": ret = "gpointer"; break; case "bool": ret = "gboolean"; break; } if (ret[ret.length-1] == '*') return "gpointer"; return ret; } bool is_target_file (string path) { // FIXME implement the new method with use_namespace instead foreach (var file in source_files) if (file == path) return true; return false; } public void walk_constant (Constant f) { var cname = Vala.get_ccode_name (f); var cvalue = "TODO"; var ctype = get_ctype (f.type_reference.to_string ()); var gtype = girtype (f.type_reference.to_string ()); extends += "\n"; extends += " \n"; extends += "\n"; //extends += "static const char *"+f.name+" = "+cname+";\n"; } public override void visit_source_file (SourceFile source) { if (is_target_file (source.filename)) source.accept_children (this); } public void process_includes (Symbol s) { foreach (var foo in Vala.get_ccode_header_filenames (s).split (",")) { var include = true; foreach (var inc in includefiles) { if (inc == foo) { include = false; break; } } if (include) includefiles.prepend (foo); } } public void walk_field (Field f) { var name = Vala.get_ccode_name (f); var type = f.variable_type.to_string (); type = get_ctype (type); externs += " \n"; externs += " \n"; externs += " \n"; } public void walk_struct (string pfx, Struct s) { var name = s.name; externs += " \n"; // TODO: parent="" type-name="" get-type="" /* TODO: refactor to walk_struct */ foreach (var m in s.get_methods ()) walk_method (m); foreach (var f in s.get_fields ()) walk_field (f); externs += " \n"; } public void walk_class (string pfx, Class c) { foreach (var k in c.get_classes ()) walk_class (c.name, k); classname = pfx+c.name; classcname = Vala.get_ccode_name (c); process_includes (c); if (context.profile == Profile.GOBJECT) classname = "%s%s".printf (nspace, classname); externs += " \n"; // TODO: parent="" type-name="" get-type="" // TODO: print ("PARENT FOR "+classname+" IS: "+c.parent_node.type_name+"\n"); // parent=\"\" foreach (var e in c.get_enums ()) walk_enum (e); foreach (var f in c.get_fields ()) walk_field (f); /* if (c.is_reference_counting ()) { string? freefun = c.get_unref_function (); if (freefun != null) extends += " ~%s%s() {\n %s (self);\n }\n".printf (modulename, classname, freefun); } else { string? freefun = c.get_free_function (); if (freefun != null) extends += " ~%s%s() {\n %s (self);\n }\n".printf (modulename, classname, freefun); } */ foreach (var m in c.get_methods ()) walk_method (m); externs += " \n"; classname = ""; } public void walk_enum (Vala.Enum e) { #if NOT_YET_IMPLEMENTED var enumname = classname + e.name; var tmp = " \n"; // type-name=\""+e.name+"\" get-type=\"\">\n"; //enums += "/* enum: %s (%s) */\n".printf ( e.name, e.get_cname ()); //enums += "enum %s {\n".printf (enumname); //tmp += "#define %s long int\n".printf (enumname); // XXX: Use cname? foreach (var v in e.get_values ()) { tmp += " \n"; //enums += " %s_%s,\n".printf (e.name, v.name); //tmp += "#define %s_%s %s\n".printf (e.name, v.name, v.get_cname ()); } tmp += " \n"; enums = tmp + "\n" + enums; #endif } inline bool is_generic(string type) { return (type.index_of ("<") != -1 && type.index_of (">") != -1); } public void walk_method (Method m) { //bool first = true; string cname = Vala.get_ccode_name (m); string alias = get_alias (m.name); string ret, vret; bool void_return; bool is_static = (m.binding & MemberBinding.STATIC) != 0; bool is_constructor = (m is CreationMethod); // TODO: Implement contractual support // m.get_preconditions (); // m.get_postconditions (); ret = vret = m.return_type.to_string (); if (is_generic (ret)) ret = get_ctype (vret); else ret = get_ctype (Vala.get_ccode_name (m.return_type)); if (ret == null) error ("Cannot resolve return type for %s\n".printf (cname)); void_return = (ret == "void"); if (m.is_private_symbol ()) return; string type = is_static?"function":"method"; if (classname != "" && !is_static) type = "method"; if (is_constructor) { type = "constructor"; alias = "new"; void_return = false; ret = nspace+"."+classname; } //externs += "<"+type+" name=\""+alias+"\" c:identifier=\""+cname+"\">\n"; externs += "<"+type+" name=\""+alias+"\" c:identifier=\""+cname+"\">\n"; //externs += " \n"; externs += " \n"; if (!void_return) { var rtype = get_ctype (ret); externs += " \n"; } else externs += " \n"; externs += " \n"; var parameters = m.get_parameters (); if (parameters.size>0) { externs += " \n"; foreach (var foo in parameters) { string arg_name = foo.name; DataType? bar = foo.variable_type; if (bar == null) continue; string? arg_type = girtype (bar.to_string ()); string? arg_ctype = get_ctype (Vala.get_ccode_name (bar)); externs += " \n"; externs += " \n"; externs += " \n"; } externs += " \n"; } externs += "\n"; //function>\n"; } public override void visit_namespace (Namespace ns) { if (ns.name == null) return; SourceReference? sr = ns.source_reference; if (sr != null && !is_target_file (sr.file.filename)) return; nspace = ns.name; process_includes (ns); //externs += "\n"; //if (pkgmode && sr.file.filename.index_of (pkgname) == -1) // return; foreach (var f in ns.get_constants ()) walk_constant (f); foreach (var f in ns.get_fields ()) walk_field (f); foreach (var e in ns.get_enums ()) walk_enum (e); foreach (var s in ns.get_structs ()) walk_struct ("", s); foreach (var m in ns.get_methods ()) walk_method (m); foreach (var c in ns.get_classes ()) walk_class ("", c); //ns.accept_children (this); //externs += "\n"; } public void write_file (string file) { var stream = FileStream.open (file, "w"); if (stream == null) error ("Cannot open %s for writing".printf (file)); context.accept (this); stream.printf ("\n"); stream.printf ("\n"); stream.printf ("\n"); stream.printf ("\n"); stream.printf (" \n"); if (includefiles.length () > 0) foreach (var inc in includefiles) stream.printf (" \n", inc); stream.printf (" \n"); stream.printf ("%s\n", enums); stream.printf ("%s\n", externs); stream.printf ("%s\n", statics); stream.printf ("%s\n", extends); stream.printf (" \n"); stream.printf ("\n"); } } valabind-1.5.0/gowriter.vala000066400000000000000000000705371323123274000160150ustar00rootroot00000000000000/* Copyleft 2014 -- williballenthin */ using Vala; // walks all the datatypes and collects instances of generic classes // we need this because i cannot figure out how to fetch the "is_generic" attribute // from a Vala.Class node object. // this way, we have to inspect all instances of objects to find what's actually used, // and then parse the type name (which includes the <...> specializer). public class GenericClassFinder : ValabindWriter { // map(base_class -> map(specialized instance string -> list(DataType))) // see: http://stackoverflow.com/questions/24072692/how-can-i-use-a-hashmap-of-string-in-vala GLib.HashTable>> generic_classes = new GLib.HashTable>> (GLib.str_hash, GLib.str_equal); inline bool is_generic(DataType d) { return (d.get_type_arguments().size > 0); } inline bool is_glib(DataType d) { // maybe should be .starts_with return d.to_string().index_of("GLib.") != -1; } // the base class name, no namespace inline string get_class_name(DataType d) { string s = d.to_string(); return s.substring(0, s.index_of_char('<')); } // `s` should not contain a specializer (<...>) inline string strip_namespace(string s) { int i1 = s.last_index_of_char('.') + 1; return s.substring(i1); } public override void visit_data_type(DataType d) { if (is_generic(d) && ( ! is_glib(d))) { string c = strip_namespace(get_class_name(d)); unowned GLib.HashTable>? inner_set = generic_classes[c]; if (inner_set == null) { var v = new GLib.HashTable> (GLib.str_hash, GLib.str_equal); inner_set = v; generic_classes.insert ((owned) c, (owned) v); } GLib.List args = new GLib.List(); foreach (var t in d.get_type_arguments()) { args.append(t); } inner_set.replace(d.to_string(), (owned) args); } } public override void visit_method(Method m) { m.accept_children (this); } public override void visit_field(Field f) { f.accept_children (this); } public override void visit_source_file (SourceFile source) { source.accept_children (this); } public override void visit_namespace(Namespace ns) { ns.accept_children (this); } public override void visit_class(Class c) { c.accept_children (this); } // `.write` is the method that actually does things in a ValabindWriter public override void write(string file) { context.accept (this); } // careful, the return object is mutable // you probably want to call this after `.write` // TODO: should use @get public GLib.HashTable>> get_generic_class_instances() { return this.generic_classes; } } // This class is responsible for figuring out *what* to call things, // like, what an appropriate Go symbol name is, or the source C symbol in a struct. // The GoWriter decides *where* to place the names generated by this class. public class GoNamer { private string pfx; private GLib.HashTable specializations = new GLib.HashTable(GLib.str_hash, GLib.str_equal); private GLib.List ordered_specializations = new GLib.List(); public GoNamer(string pfx) { this.pfx = pfx; } public void add_specialization(TypeParameter t, DataType d) { specializations.insert(t.name, d); ordered_specializations.append(d); } // converts symbol names with underscores to camelCase. // this function should not be called directly. See `camelcase`. // allows trailing '_' characters. private static string cleanup_underscores(string name) { if (name.length == 0) { return ""; } else if (name.length == 1) { // accept trailing '_' return name; } else if (name.index_of("_") == -1) { return name; } else { // there is a '_' here somewhere int i = name.index_of("_"); if (i == name.length - 1) { // accept trailing '_' return name; } // there must be at least one more character // everything before the '_' string before = ""; if (i != 0) { before = name.substring(0, i); } // find next non-'_' character uppercase, or all '_' if thats all thats left // j will be the index of this character string next; int j = i + 1; while (true) { before = name.substring(0, i); if (name[j] != '_') { next = name.substring(j, 1).up(); break; } j++; if (j == name.length) { // only '_' remain next = name.substring(i, j - i); // so catch them all break; } } if (j >= name.length - 1) { return before + next; } else { // do rest of string return before + next + cleanup_underscores(name.substring(j + 1)); } } } // see tests t/go/camelcase.vapi private static string camelcase(string name) { if (name.length == 0) { return ""; } else if (name.length == 1) { return name.up(); } else { return name.substring(0, 1).up() + cleanup_underscores(name.substring(1, name.length - 1)); } } public string get_field_name(Field f) { return camelcase(f.name); } // renames the C symbol for a field // useful because Go convention is to rename "type" --> "_type" public string get_field_cname(Field f) { string n = Vala.get_ccode_name(f); if (n == "type") { return "_type"; } else { return n; } } public string get_method_name(Method m) { return camelcase(m.name); } public string get_method_cname(Method m) { return Vala.get_ccode_name(m); } public string get_parameter_name(Vala.Parameter p) { return camelcase(p.name); } public string get_enum_name(Enum e) { return e.name; } public string get_enum_value_name(Vala.EnumValue v) { return v.name; } public string get_enum_value_cname(Vala.EnumValue v) { return v.name; } public string get_constructor_name(Class c, Method m) { string postfix = ""; if (m.name != ".new") { postfix = camelcase(m.name); } return "New%s%s".printf(get_class_name(c), postfix); } private string mangle_datatype(DataType d) { string ret = d.data_type.name; // i think should unify with get_type_declaration? if (d.get_type_arguments().size > 0) { foreach(var dd in d.get_type_arguments()) { ret += "_"; ret += mangle_datatype(dd); } } return ret; } // get the name of a class. If its a generic class, then // we use the set of specializations in our local context // to mangle the name. // this must keep in sync with get_specialized_type_declaration public string get_class_name(Class c) { bool has_specializations = false; foreach(var s in ordered_specializations) { has_specializations = true; break; } string postfix = ""; if (has_specializations) { foreach(DataType d in ordered_specializations) { postfix += "_"; postfix += mangle_datatype(d); } } return "%s%s%s".printf(this.pfx, camelcase(c.name), postfix); } // get the name of an already specialized generic class. That is, // turning something like vapi: List into go: List_int. // this must be kept in sync with get_class_name public string get_specialized_type_declaration(DataType d) { return mangle_datatype(d); } public string get_class_cname(Class c) { return Vala.get_ccode_name(c); } public string get_struct_name(Struct s) { return "%s%s".printf(this.pfx, camelcase(s.name)); } public string get_struct_cname(Struct s) { return Vala.get_ccode_name(s); } public string get_namespace_name(Namespace ns) { return ns.name; } inline bool is_generic(string type) { // TODO: fix things so we don't need this return (type.index_of ("<") != -1 && type.index_of (">") != -1); } private string get_ctype (string _type) { string type = _type; string? iter_type = null; if (type == "null") { error ("Cannot resolve type"); } if (is_generic (type)) { int ptr = type.index_of ("<"); iter_type = (ptr==-1)?type:type[ptr:type.length]; iter_type = iter_type.replace ("<", ""); iter_type = iter_type.replace (">", ""); type = type.split ("<", 2)[0]; } type = type.replace ("?",""); switch (type) { case "gconstpointer": case "gpointer": case "void*": return "void*"; case "gsize": return "size_t"; case "gdouble": return "double"; case "gfloat": return "float"; case "ut8": case "uint8": case "guint8": return "byte"; case "gchar**": return "char **"; case "char": case "gchar": return "char"; case "gchar*": case "string": case "const gchar*": return "string"; // XXX lost const? case "void": return "void"; case "int[]": case "int": case "gint": return "int"; case "guint": return "uint"; case "glong": return "long"; case "st64": case "int64": case "gint64": return "long"; case "ut64": case "uint64": case "guint64": return "ulong"; /* XXX swig does not support unsigned char* */ case "uint8*": case "guint8*": return "byte*"; case "guint16": case "uint16": return "ushort"; case "ut32": case "uint32": case "guint32": return "unsigned int"; case "bool": // no conversion needed case "gboolean": return "bool"; // XXX bool? default: break; } return type; } private inline string strip_non_class_name(string s) { return s.substring(0, s.index_of_char('<')); } // `s` should not contain a specializer (<...>) private inline string strip_namespace(string s) { int i1 = s.last_index_of_char('.') + 1; return s.substring(i1); } // given a DataType symbol, return a string that contains the Go source code for // a type specifier of that type. private string get_type_declaration(DataType type) { string basic_name = type.to_string(); if (specializations.lookup(basic_name) != null) { // replace type specializations (things like "public G member1;" // NOTE: doesn't support some complex specializations, like public List member1;" DataType dt = specializations.lookup(basic_name); basic_name = dt.to_string(); } else if (type.to_string().index_of ("<") != -1) { basic_name = get_specialized_type_declaration(type); } // guess basic_name = strip_namespace(strip_non_class_name(basic_name)); string typename = get_ctype (basic_name); // TODO: why are we using ctype here? // we can typecheck to determine if this is a pointer, so throw away '*' typename = typename.replace("*", "").strip(); // if `type` is a pointer, then this will contain the appropriate '*' string maybe_pointer_sym = ""; // if `type` is an array, then this will contain the appropriate "[]" string maybe_array_sym = ""; if (type is PointerType) { // I suspect we don't support pointer-to-pointer if (typename == "void") { typename = "unsafe.Pointer"; // go specific hack type for void * // TODO: need to re-enable this somehow // this.needs_unsafe = true; maybe_pointer_sym = ""; } else { maybe_pointer_sym = "*"; } } if (type is ArrayType) { maybe_array_sym = "[]"; } return "%s%s%s".printf(maybe_array_sym, maybe_pointer_sym, typename); } public string get_field_type_declaration(Field f) { return get_type_declaration(f.variable_type); } public string get_parameter_type_declaration(Vala.Parameter p) { return get_type_declaration(p.variable_type); } public string get_method_return_type_declaration(Method m) { return get_type_declaration(m.return_type); } } public class GoSrcWriter : ValabindWriter { public GLib.List includefiles = new GLib.List (); HashTable defined_classes = new HashTable (str_hash, str_equal); GLib.HashTable>> generic_classes = new GLib.HashTable>> (GLib.str_hash, GLib.str_equal); string classname = ""; string classcname; string defs = ""; string statics = ""; string extends = ""; string enums = ""; string nspace; bool needs_unsafe = false; // set to true if the 'unsafe' package needs to be imported because a void* pointer was encountered public GoSrcWriter () {} string _indent = ""; // TODO(wb): removeme void debug(string s) { notice(_indent + s); } void indent() { _indent = _indent + " "; } void dedent() { _indent = _indent.substring(0, _indent.length - 2); } public void set_generic_class_instances(GLib.HashTable>> generic_classes) { this.generic_classes = generic_classes; } private bool is_target_file (string path) { foreach (var file in source_files) if (file == path) return true; return false; } public override void visit_source_file (SourceFile source) { if (is_target_file (source.filename)) { source.accept_children (this); } } private void process_includes (Symbol s) { debug("process_includes(sym: %s)".printf(s.name)); indent(); foreach (var foo in Vala.get_ccode_header_filenames (s).split (",")) { debug("include(%s)".printf(foo)); var include = true; foreach (var inc in includefiles) { if (inc == foo) { include = false; break; } } if (include) { includefiles.prepend (foo); } } dedent(); } private bool is_string(CodeNode t) { if (t is DataType) { DataType a = t as DataType; return a.to_string() == "string"; } else if (t is Field) { Field a = t as Field; return a.variable_type.to_string() == "string"; } else if (t is Vala.Parameter) { Vala.Parameter a = t as Vala.Parameter; return a.variable_type.to_string() == "string"; } else { warning("unexpected type to is_string"); return false; } } // here, we use explicit accessors and mutators to fixup accessibility. private string walk_field (GoNamer namer, string owner_name, Field f) { string ret = ""; debug("walk_field(name: %s)".printf(f.name)); indent(); if (f.is_private_symbol()) { debug("private."); dedent(); return ret; } // TODO: handle generics. ATM, type of `public G data` becomes `func ... GetData() void` // TODO: make this a function `is_string` if (is_string(f)) { ret += "func (s %s) Get%s() %s {\n".printf(owner_name, namer.get_field_name(f), namer.get_field_type_declaration(f)); ret += " return C.GoString(s.%s)\n".printf(namer.get_field_cname(f)); ret += "}\n"; ret += "func (s *%s) Set%s(a %s) {\n".printf(owner_name, namer.get_field_name(f), namer.get_field_type_declaration(f)); ret += " s.%s = C.CString(a)\n".printf(namer.get_field_cname(f)); ret += " return\n"; ret += "}\n"; } else { ret += "func (s %s) Get%s() %s {\n".printf(owner_name, namer.get_field_name(f), namer.get_field_type_declaration(f)); ret += " return s.%s\n".printf(namer.get_field_cname(f)); ret += "}\n"; ret += "func (s *%s) Set%s(a %s) {\n".printf(owner_name, namer.get_field_name(f), namer.get_field_type_declaration(f)); ret += " s.%s = a\n".printf(namer.get_field_cname(f)); ret += " return\n"; ret += "}\n"; } dedent(); return ret; } private string walk_class_field(GoNamer namer, Class c, Field f) { return walk_field(namer, namer.get_class_name(c), f); } private string walk_struct_field(GoNamer namer, Struct s, Field f) { return walk_field(namer, namer.get_struct_name(s), f); } private string walk_namespace_field(GoNamer namer, Namespace ns, Field f) { return walk_field(namer, "nsimp" + namer.get_namespace_name(ns), f); } private string walk_struct (GoNamer namer, Struct s) { string ret = ""; debug("walk_struct(name: %s)".printf(s.name)); indent(); ret += "type %s C.%s\n".printf(namer.get_struct_name(s), namer.get_struct_cname(s)); foreach (var f in s.get_fields()) { ret += walk_struct_field(namer, s, f); } ret += "\n"; dedent(); return ret; } private string walk_enum (GoNamer namer, Vala.Enum e) { string ret = ""; var pfx = Vala.get_ccode_prefix(e); debug("walk_enum(pfx: %s, name: %s)".printf(pfx, e.name)); indent(); ret += "const (\n"; foreach (var v in e.get_values()) { debug("enum(name: %s)".printf(v.name)); ret += " %s%s = C.%s%s\n".printf(pfx, namer.get_enum_value_name(v), pfx, namer.get_enum_value_cname(v)); } ret += ")\n"; ret += "type %s int\n\n".printf(namer.get_enum_name(e)); dedent(); return ret; } // is_string: if the parameter is a string // arg_name: the C symbol parameter name // maybe_pointer_sym: might contain a '*' if needed for the Go symbol. Useful for `out` parameters. // arg_type: the parameter type in all its glory delegate string parameter_visitor(bool is_string, string maybe_pointer_sym, Vala.Parameter p); private string get_function_parameters(GoNamer namer, Method f, parameter_visitor v) { string args = ""; bool first = true; foreach (var p in f.get_parameters ()) { string maybe_pointer_sym = ""; if (p.direction != ParameterDirection.IN) { // TODO: exploit multiple return values? if (p.direction == ParameterDirection.OUT) { if (! is_string(p)) { maybe_pointer_sym = "*"; } } else if (p.direction == ParameterDirection.REF) { if (! is_string(p)) { maybe_pointer_sym = "*"; } } } if (first) { first = false; } else { args += ", "; } // TODO: consider special handling of `uint8 *buf, int len`? args += v(is_string(p), maybe_pointer_sym, p); } return args; } // BUG: doesn't support '...' parameters private string get_function_declaration_parameters(GoNamer namer, Method f) { parameter_visitor formatter = (is_string, maybe_pointer_sym, p) => { // what about array of char *? I think we have to let the caller deal with it // hopefully overflows don't happen here? return "%s %s%s".printf (namer.get_parameter_name(p), maybe_pointer_sym, namer.get_parameter_type_declaration(p)); }; return get_function_parameters(namer, f, formatter); } // BUG: doesn't support '...' parameters private string get_function_call_parameters(GoNamer namer, Method f) { parameter_visitor formatter = (is_string, maybe_pointer_sym, p) => { if (is_string) { // what about array of char *? I think we have to let the caller deal with it // hopefully overflows don't happen here? return "C.CString(%s)".printf (namer.get_parameter_name(p)); } else { return "%s".printf (namer.get_parameter_name(p)); } }; return get_function_parameters(namer, f, formatter); } private bool is_void_function(Method f) { return f.return_type.to_string() == "void"; } // see tests t/go/namespace_functions.vapi private string walk_function(GoNamer namer, Namespace ns, Method f) { string ret = ""; string nsname = namer.get_namespace_name(ns); string cname = namer.get_method_cname(f); debug("walk_function(ns: %s, name: %s)".printf(nsname, cname)); indent(); if (f is CreationMethod) { warning("constructor where function expected"); } if (f.is_private_symbol ()) { debug("private."); dedent(); return ret; } string def_args = get_function_declaration_parameters(namer, f); string call_args = get_function_call_parameters(namer, f); if ( ! is_void_function(f)) { ret += "func (_ nsimp%s) %s(%s) %s {\n".printf (nsname, namer.get_method_name(f), def_args, namer.get_method_return_type_declaration(f)); if (is_string(f.return_type)) { // we have to let the caller deal with array of char * // what happens if there are embedded nulls? ret += " return C.GoString(%s(%s))\n".printf (cname, call_args); } else { // TODO: what about void*? ret += " return %s(%s)\n".printf (cname, call_args); } } else { ret += "func (_ nsimp%s) %s(%s) {\n".printf (nsname, namer.get_method_name(f), def_args); ret += " %s(%s)\n".printf (cname, call_args); } ret += "}\n"; dedent(); return ret; } private string walk_method (GoNamer namer, Class c, Method m) { string ret = ""; string classname = namer.get_class_name(c); string cname = namer.get_method_cname(m); debug("walk_method(ns: %s, name: %s)".printf(classname, cname)); indent(); // TODO: "unowned"/static methods if (m is CreationMethod) { warning("constructor where function expected"); } if (m.is_private_symbol ()) { debug("private."); dedent(); return ret; } string def_args = get_function_declaration_parameters(namer, m); string call_args = get_function_call_parameters(namer, m); ret += "func (this *%s) %s(".printf(classname, namer.get_method_name(m)); if (def_args != "") { ret += "%s".printf(def_args); } ret += ") "; if ( ! is_void_function(m)) { ret += "%s ".printf(namer.get_method_return_type_declaration(m)); } ret += "{\n"; ret += " "; if ( ! is_void_function(m)) { ret += "return "; if (is_string(m.return_type)) { // TODO: use wrap_type function ret += "C.GoString("; } ret += "%s(this".printf(cname); if (call_args != "") { ret += ", %s".printf(call_args); } ret += ")"; if (is_string(m.return_type)) { ret += ")"; } ret += "\n"; } else { ret += "%s(this".printf(cname); if (call_args != "") { ret += ", %s".printf(call_args); } ret += ")\n"; } ret += "}\n"; dedent(); return ret; } private string walk_constructor(GoNamer namer, Class c, Method m, string free_function) { string ret = ""; string classname = namer.get_class_name(c); string cname = namer.get_method_cname(m); debug("walk_method(ns: %s, name: %s)".printf(classname, cname)); indent(); // TODO: "unowned"/static methods if (m.is_private_symbol ()) { debug("private."); dedent(); return ret; } ret += "func %s(".printf(namer.get_constructor_name(c, m)); ret += "%s".printf(get_function_declaration_parameters(namer, m)); ret += ") *%s {\n".printf(classname); ret += " var ret *%s\n".printf(classname); ret += " ret = C.%s(".printf(cname); ret += "%s".printf(get_function_call_parameters(namer, m)); ret += ")\n"; if (free_function != "") { ret += " SetFinalizer(ret, func(r *%s) {\n".printf(classname); ret += " C.%s(r)\n".printf(free_function); ret += " })\n"; } ret += " return ret\n"; ret += "}\n"; dedent(); return ret; } private string get_class_src(GoNamer namer, Class c) { string ret = ""; foreach (var k in c.get_structs ()) { ret += walk_struct (namer, k); } foreach (var k in c.get_classes ()) { ret += walk_class (k); } classname = namer.get_class_name(c); classcname = namer.get_class_cname(c); process_includes (c); if (defined_classes.lookup (classname)) { debug("already defined"); dedent(); return ret; } defined_classes.insert (classname, true); bool has_constructor = false; foreach (var m in c.get_methods ()) { if (m is CreationMethod) { has_constructor = true; break; } } ret += "type %s C.%s\n".printf(classname, classcname); foreach (var f in c.get_fields()) { ret += walk_class_field(namer, c, f); } foreach (var e in c.get_enums ()) { ret += walk_enum (namer, e); } foreach (var m in c.get_methods ()) { if ( ! (m is CreationMethod)) { ret += walk_method (namer, c, m); } else { string free_function = ""; if (Vala.is_reference_counting (c)) { string? freefun = Vala.get_ccode_unref_function (c); if (freefun != null && freefun != "") { free_function = freefun; } } else { // BUG?: this method always seems to return a free function (default: ${cprefix}_free) // even if there is no `free_function` defined in the `CCode` block // see test in t/go/classes.vapi string? freefun = Vala.get_ccode_free_function (c); if (freefun != null) { free_function = freefun; } } ret += walk_constructor(namer, c, m, free_function); } } ret += "\n"; dedent(); return ret; } private string walk_class (Class c) { string ret = ""; debug("walk_class(name: %s)".printf(c.name)); indent(); if (this.generic_classes.contains(c.name)) { debug("generic class"); indent(); unowned GLib.HashTable> specializations; specializations = this.generic_classes.lookup(c.name); specializations.foreach((k, v) => { debug("specialization: %s".printf(k)); indent(); // TODO: might need to change the prefix GoNamer namer = new GoNamer(""); GLib.List vv = v.copy(); foreach(var t in c.get_type_parameters()) { debug("%s -> %s".printf(t.name, vv.nth_data(0).to_string())); namer.add_specialization(t, vv.nth_data(0)); vv.delete_link(vv.nth(0)); // pop(0) } ret += "// %s<".printf(c.name); foreach(var t in v.copy()) { ret += t.to_string(); ret += ", "; } ret += ">\n"; ret += get_class_src(namer, c); dedent(); }); dedent(); } else { // TODO: might need to change the prefix GoNamer namer = new GoNamer(""); ret += get_class_src(namer, c); } dedent(); return ret; } // go doesn't really support namespaces. Often code is namespaced by // directory hierarchy, but thats for code organization. // we eat namespaces here, as they don't generate anything besides their children. public override void visit_namespace (Namespace ns) { string ret = ""; debug("walk_namespace(name: %s)".printf(ns.name)); indent(); if (ns.name == "") { return; } classname = ""; SourceReference? sr = ns.source_reference; if (sr == null || !is_target_file (sr.file.filename)) { // TODO: should this be &&? dedent(); return; } nspace = ns.name; process_includes (ns); foreach (var e in ns.get_enums ()) { // enums will float to the top-level "namespace" in Go, since we aren't doing namespaces. ret += walk_enum (new GoNamer(ns.name == modulename ? ns.name : ""), e); } foreach (var c in ns.get_structs()) { ret += walk_struct(new GoNamer(ns.name == modulename ? ns.name : ""), c); } if (ns.get_methods().size + ns.get_fields().size > 0) { // Go only does namespacing through file system paths, whish is // probably not appropriate/feasible here // so we fake it by creating a new type, and one instance of it, // and attach the functions to it. // Note, this doesn't work for nested namespaces, but its better than nothing. // // for example: // namespace N { public static void fn1(); } // // becomes: // type nsimptN int // func (_ nsimpN) Fn1() { fn1() } // var N nsimpN // // so a user can do: // import "/some/path/test" // test.N.Fn() string fake_ns_name = "nsimp%s".printf(ns.name); ret += "type %s int\n".printf(fake_ns_name); foreach (var c in ns.get_fields()) { ret += walk_namespace_field(new GoNamer(ns.name == modulename ? ns.name : ""), ns, c); } foreach (var m in ns.get_methods()) { ret += walk_function(new GoNamer(ns.name == modulename ? ns.name : ""), ns, m); } ret += "var %s %s\n".printf(ns.name, fake_ns_name); ret += "\n"; } foreach (var c in ns.get_classes ()) { ret += walk_class (c); //ns.name, c); } dedent(); defs += ret; } public override void write (string file) { var stream = FileStream.open (file, "w"); if (stream == null) { error ("Cannot open %s for writing".printf (file)); } // before the `pre` stuff because we need `includefiles` to be populated. context.accept (this); var pre = "package %s\n".printf(modulename); pre += "\n"; pre += "// #cgo LDFLAGS: -l%s\n".printf(modulename); // TODO(wb): how2get library name? foreach (var inc in includefiles) { pre += "// #include \"%s\"\n".printf(inc); } pre += "import \"C\"\n"; if (this.needs_unsafe) { pre += "import \"unsafe\"\n"; } stream.printf ("/* valabind autogenerated Go bindings for %s */\n".printf (modulename)); stream.printf ("%s\n", pre); stream.printf ("%s\n", enums); stream.printf ("%s\n", statics); stream.printf ("%s\n", defs); stream.printf ("%s\n", extends); } } public class GoWriter : ValabindWriter { public GoWriter() {} public override string get_filename (string base_name) { return base_name + ".go"; } private void clone_writer_config(ValabindWriter w) { w.modulename = this.modulename; w.library = this.library; w.include_dirs = this.include_dirs; w.namespaces = this.namespaces; w.init(this.vapidir, this.glibmode); foreach (var pkg in this.packages) { w.add_external_package(pkg); } foreach (var def in this.defines) { w.add_define(def); } foreach (var f in this.source_files) { w.add_source_file(f); } } public override void write (string file) { var f = new GenericClassFinder(); this.clone_writer_config(f); f.parse(); f.write(file); var g = new GoSrcWriter(); this.clone_writer_config(g); g.set_generic_class_instances(f.get_generic_class_instances()); g.parse(); g.write(file); } } valabind-1.5.0/main.vala000066400000000000000000000121411323123274000150620ustar00rootroot00000000000000/* Copyright GPL3 - 2009-2013 -- pancake */ private static string[] files; private static string vapidir; private static string library; private static bool show_version; private static bool glibmode; private static bool camelgetters; private static bool cxxmode; private static bool dlangoutput; private static bool cxxoutput; private static bool nodeoutput; private static bool swigoutput; private static bool ctypesoutput; private static bool giroutput; private static bool gooutput; private static string modulename; private static string? output; [CCode (array_length = false, array_null_terminated = true)] private static string[] packages; [CCode (array_length = false, array_null_terminated = true)] private static string[] include_dirs; [CCode (array_length = false, array_null_terminated = true)] private static string[] namespaces; [CCode (array_length = false, array_null_terminated = true)] private static string[] defines; private const OptionEntry[] options = { { "define", 'D', 0, OptionArg.STRING_ARRAY, ref defines, "define SYMBOL", "SYMBOL" }, { "pkg", 0, 0, OptionArg.STRING_ARRAY, ref packages, "include binding for PACKAGE", "PACKAGE..." }, { "vapidir", 'V', 0, OptionArg.STRING, ref vapidir, "define alternative vapi directory", "VAPIDIR" }, { "include-dir", 'I', 0, OptionArg.STRING_ARRAY, ref include_dirs, "add include path", "INCLUDEDIR" }, { "version", 'v', 0, OptionArg.NONE, ref show_version, "show version information", null }, { "output", 'o', 0, OptionArg.STRING, ref output, "specify output file name", "OUTPUT" }, { "module", 'm', 0, OptionArg.STRING, ref modulename, "specify module name", "NAME" }, { "namespace", 'N', 0, OptionArg.STRING_ARRAY, ref namespaces, "include namespace in the output", "NSPACE" }, { "cxx-swig", 'x', 0, OptionArg.NONE, ref cxxmode, "generate C++ code for SWIG", null }, { "glib", 0, 0, OptionArg.NONE, ref glibmode, "call g_type_init before any constructor", null }, { "swig", 0, 0, OptionArg.NONE, ref swigoutput, "generate swig interface code", null }, { "camel-getters", 0, 0, OptionArg.NONE, ref camelgetters, "translate {get,set}_foo into {get,set}Foo", null }, { "node-ffi", 0, 0, OptionArg.NONE, ref nodeoutput, "generate node-ffi interface", null }, { "library", 'l', 0, OptionArg.STRING, ref library, "library to link", null }, { "ctypes", 0, 0, OptionArg.NONE, ref ctypesoutput, "generate python ctypes interface", null }, { "gir", 0, 0, OptionArg.NONE, ref giroutput, "generate GIR (GObject-Introspection-Runtime)", null }, { "cxx", 0, 0, OptionArg.NONE, ref cxxoutput, "generate C++ interface code", null }, { "dlang", 0, 0, OptionArg.NONE, ref dlangoutput, "generate D bindings", null }, { "go", 0, 0, OptionArg.NONE, ref gooutput, "generate Go bindings", null }, { "", 0, 0, OptionArg.FILENAME_ARRAY, ref files, "vala/vapi input files", "FILE FILE .." }, { null } }; int main (string[] args) { output = null; vapidir = "."; files = { "" }; try { var opt_context = new OptionContext ("- valabind"); opt_context.set_help_enabled (true); opt_context.add_main_entries (options, null); opt_context.parse (ref args); } catch (OptionError e) { stderr.printf ("%s\nTry --help\n", e.message); return 1; } if (show_version) { print ("%s\n", version_string); return 0; } if (modulename == null) error ("No modulename specified. Use --module or --help"); if (files.length == 0) error ("No files given"); ValabindWriter writer = null; int count = 0; if (swigoutput && count++ == 0) { writer = new SwigWriter (cxxmode); writer.add_define ("VALABIND_SWIG"); } if (nodeoutput && count++ == 0) { writer = new NodeFFIWriter (); writer.add_define ("VALABIND_NODEJS"); } if (ctypesoutput && count++ == 0) { writer = new CtypesWriter (); writer.add_define ("VALABIND_CTYPES"); } if (giroutput && count++ == 0) { writer = new GirWriter (); writer.add_define ("VALABIND_GIR"); } if (dlangoutput && count++ == 0) { writer = new DlangWriter (); writer.add_define ("VALABIND_DLANG"); } if (cxxoutput && count++ == 0) { writer = new CxxWriter (); writer.add_define ("VALABIND_CXX"); } if (gooutput && count++ == 0) { writer = new GoWriter (); writer.add_define ("VALABIND_GO"); } if (count == 0) error ("No output mode specified. Try --help\n"); else if (count > 1) error ("Cannot specify more than one output mode\n"); writer.modulename = modulename; writer.library = (library != null)? library: modulename; writer.include_dirs = include_dirs; writer.namespaces = namespaces; writer.camelgetters = camelgetters; writer.init (vapidir, glibmode); if (packages != null) foreach (var pkg in packages) writer.add_external_package (pkg); if (defines != null) { foreach (string define in defines) { writer.add_define (define); } } // TODO: passing more than one source doesnt seems to work :/ foreach (var file in files) { if (file.index_of (".vapi") == -1) { writer.pkgmode = true; writer.pkgname = file; } writer.add_source_file (file); } writer.parse (); if (output == null) output = writer.get_filename (modulename); writer.write (output); return 0; } valabind-1.5.0/meson.build000066400000000000000000000011721323123274000154350ustar00rootroot00000000000000project('valabind', 'c', 'vala') add_project_arguments([ '--vapidir', join_paths(meson.current_source_dir(), 'vapi')], language: 'vala') files = [ 'config.vala', 'ctypeswriter.vala', 'cxxwriter.vala', 'dlangwriter.vala', 'girwriter.vala', 'gowriter.vala', 'nodeffiwriter.vala', 'swigwriter.vala', 'utils.vala', 'valabindwriter.vala', 'main.vala', ] vala_dep = dependency('libvala-0.36') glib_dep = dependency('glib-2.0') gobject_dep = dependency('gobject-2.0') executable( 'valabind', files, dependencies: [glib_dep, gobject_dep, vala_dep], vala_args: ['--pkg', 'posix'] ) valabind-1.5.0/nodeffiwriter.vala000066400000000000000000000351401323123274000170110ustar00rootroot00000000000000/* Copyright 2012-2015 -- pancake, eddyb, ritesh */ using Vala; public class NodeFFIWriter : ValabindWriter { GLib.List includefiles = new GLib.List (); string ?ns_pfx; string bind = ""; string enum_fmt = ""; string enum_vals = ""; public NodeFFIWriter () { } public override string get_filename (string base_name) { return base_name+".js"; } void add_includes (Symbol s) { foreach (string i in Vala.get_ccode_header_filenames (s).split (",")) { bool include = true; foreach (string j in includefiles) { if (i == j) { include = false; break; } } if (include) includefiles.prepend (i); } } string sep (string str, string separator) { if (str.length == 0) return str; char last = str[str.length-1]; if (last != '(' && last != '[' && last != '{') return str+separator; return str; } string type_name (DataType type, bool ignoreRef=false) { if (type == null) { warning ("Cannot resolve type"); return "throw TypeError('Unresolved type')"; } if (type is EnumValueType) return "_.int"; if (type is GenericType) return type.to_qualified_string (); if (type is DelegateType) { DelegateType _delegate = type as DelegateType; string ret = type_name (_delegate.get_return_type ()), args = ""; foreach (var param in _delegate.get_parameters ()) args = sep (args, ", ")+type_name (param.variable_type); return "_.delegate(%s, [%s])".printf (ret, args); } if (type is PointerType) return "_.ptr("+type_name ((type as PointerType).base_type, true)+")"; if (type is ArrayType) { ArrayType array = type as ArrayType; string element = type_name (array.element_type); int len = array_length(array); if (len < 0) return "_.ptr("+element+")"; return "_.array("+element+", %d)".printf (len); } if (!ignoreRef && (type is ReferenceType)) { string unref_type = type_name (type, true); // HACK just check for the string class instead (how?) if (unref_type == "_.CString") return unref_type; return "_.ref("+unref_type+")"; } string generic = ""; foreach (DataType t in type.get_type_arguments ()) generic = sep (generic, ", ") + type_name (t); string _type = type.to_string (); string local_ns_pfx = ns_pfx; if (type.data_type != null && type.data_type.parent_symbol is Namespace) { Namespace local_ns = (Namespace)type.data_type.parent_symbol; if (use_namespace(local_ns)) local_ns_pfx = local_ns.get_full_name()+"."; } // HACK find a better way to remove generic type args _type = _type.split ("<", 2)[0]; _type = _type.replace (local_ns_pfx, "").replace (".", ""); _type = _type.replace ("?",""); _type = _type.replace ("unsigned ", "u"); switch (_type) { case "gconstpointer": case "gpointer": return "_.ptr(_.void)"; case "gboolean": return "_.bool"; case "gchar": return "_.char"; case "gint": return "_.int"; case "guint": return "_.uint"; case "glong": return "_.long"; case "ut8": case "guint8": return "_.uint8"; case "ut16": case "guint16": return "_.uint16"; case "st32": case "gint32": return "_.int32"; case "ut32": case "guint32": return "_.uint32"; case "st64": case "gint64": return "_.int64"; case "ut64": case "guint64": return "_.uint64"; case "gfloat": return "_.float"; case "gdouble": return "_.double"; case "string": return "_.CString"; } _type = "_."+_type; if (generic != "") _type += "("+generic+")"; return _type; } new void visit_enum (Vala.Enum e, string pfx="") { add_includes (e); notice (">\x1b[1menum\x1b[0m "+e.get_full_name ()); if (pfx == "") enum_fmt += "exports.%s = {}/*types.Enum*/;\\n".printf (e.name); else bind = sep (bind, ",")+"\n\t\t$%s: {}/*types.Enum*/".printf (e.name); foreach (var v in e.get_values ()) { enum_fmt += "exports.%s%s.%s = %%d;\\n".printf (pfx, e.name, v.name); enum_vals += ","+Vala.get_ccode_name (v); } } public override void visit_struct (Struct s) { add_includes (s); notice (">\x1b[1mstruct\x1b[0m "+s.get_full_name ()); string name = s.get_full_name ().replace (ns_pfx, "").replace (".", ""); bind = sep (bind, ",\n")+"\t%s: function() {return [{".printf (name); foreach (Field f in s.get_fields ()) f.accept (this); bind = sep (bind, "\n\t")+"}, {"; // NOTE if m.accept (this) is used, it might try other functions than visit_method foreach (Method m in s.get_methods ()) m.accept (this); bind = sep (bind, "\n\t")+"}];}"; } public override void visit_class (Class c) { bool is_generic = false; add_includes (c); notice (">\x1b[1mclass\x1b[0m "+c.get_full_name ()); string name = c.get_full_name ().replace (ns_pfx, "").replace (".", ""); foreach (Struct s in c.get_structs ()) s.accept (this); foreach (Class k in c.get_classes ()) k.accept (this); bind = sep (bind, ",\n")+"\t%s: function(".printf (name); foreach (TypeParameter t in c.get_type_parameters ()) { is_generic = true; bind = sep (bind, ", ")+t.name; } bind += ") {return [{"; foreach (Field f in c.get_fields ()) f.accept (this); bind = sep (bind, "\n\t")+"}, {"; foreach (Vala.Enum e in c.get_enums ()) visit_enum (e, name+"."); // TODO use node-weak to call the free function on GC string? freefun = null; if (Vala.is_reference_counting (c)) freefun = Vala.get_ccode_unref_function (c); else freefun = Vala.get_ccode_free_function (c); if (freefun != null && freefun != "") { if (is_generic) name = name +"(G)"; bind = sep (bind, ",")+"\n\t\tdelete: ['%s', _.void, [_.ref(_.%s)]]".printf (freefun, name); } // NOTE if m.accept (this) is used, it might try other functions than visit_method foreach (Method m in c.get_methods ()) visit_method (m); bind = sep (bind, "\n\t")+"}];}"; } public override void visit_field (Field f) { string name = f.name; // HACK cannot use buffer as a field name with latest ref. if (name == "buffer") name = "buf"; bind = sep (bind, ",")+"\n\t\t%s: %s".printf (name, type_name (f.variable_type)); } public override void visit_method (Method m) { if (m.is_private_symbol () || m.name == "cast") return; add_includes (m); //notice (">\x1b[1mmethod\x1b[0m "+m.get_full_name ()); var parent = m.parent_symbol; string cname = Vala.get_ccode_name (m), name = m.name; bool is_static = (m.binding & MemberBinding.STATIC) != 0, is_constructor = (m is CreationMethod); bool parent_is_class = parent is Class || parent is Struct; // TODO: Implement contractual support // m.get_preconditions (); // m.get_postconditions (); if (parent_is_class && is_static) name = "$"+name; DataType this_type = m.this_parameter == null ? null : m.this_parameter.variable_type; string func = "\n\t\t"; if (is_constructor) { func += "$constructor: ['%s', %s, [".printf (cname, type_name (this_type)); } else { func += "%s: ['%s', %s, [".printf (name, cname, type_name (m.return_type)); if (this_type != null) func += type_name (this_type); } bool variadic = false; foreach (Vala.Parameter param in m.get_parameters ()) { // HACK is this the right way to detect variadic functions? if (param.ellipsis) { variadic = true; continue; } func = sep (func, ", ")+type_name (param.variable_type); } func += variadic ? "], 'variadic']" : "]]"; bind = sep (bind, ",")+func; if (parent_is_class && name == "iterator") bind += ",\n\t\tforEach: defaults.forEach"; } public override void visit_namespace (Namespace ns) { string name = ns.get_full_name (); bool use = use_namespace (ns); if (use) ns_pfx = name+"."; if (ns_pfx != null) { notice (">\x1b[1mns\x1b[0m "+name); add_includes (ns); } foreach (Namespace n in ns.get_namespaces ()) n.accept (this); if (ns_pfx != null) { if (!use) { name = name.replace (ns_pfx, "").replace (".", ""); bind = sep (bind, ",\n")+"\t$%s: function() {return {".printf (name); foreach (Method m in ns.get_methods ()) m.accept (this); foreach (Vala.Enum e in ns.get_enums ()) visit_enum (e, name+"."); bind = sep (bind, "\n\t")+"};}"; } else foreach (Vala.Enum e in ns.get_enums ()) visit_enum (e); foreach (Struct s in ns.get_structs ()) s.accept (this); foreach (Class c in ns.get_classes ()) c.accept (this); } //if (ns_pfx != null) // notice ("<\x1b[1mns\x1b[0m "+name); if (use) ns_pfx = null; } public override void write (string file) { var stream = FileStream.open (file, "w"); if (stream == null) error ("Cannot open %s for writing".printf (file)); context.root.accept (this); stream.puts (" /* DO NOT EDIT. Automatically generated by valabind from "+modulename+" */ var ffi = require('ffi'), ref = require('ref'), Struct = require('ref-struct'); var lib = new ffi.DynamicLibrary('lib"+modulename+"'+ffi.LIB_EXT); function Tname(T) { return T.hasOwnProperty('$name') ? T.$name : T.name; } var types = exports.type = {}; for(var i in ref.types) if(i != 'Utf8String') // Try not to trip the deprecated warning. types[i] = ref.types[i]; types.staticCString = function staticCString(N) { var r = Object.create(types.char); r.name = 'char['+N+']'; r.size *= N; r.get = function get(buf, offset) { if(buf.isNull()) return null; // TODO enforce maxLength of N return buf.readCString(offset); }; r.set = function set(buf, offset, val) { // TODO enforce maxLength of N return buf.writeCString(val, offset); }; return r; }; var ptrCache = [], ptrCacheTo = []; types.ptr = function PointerType(T) { T = ref.coerceType(T); if(T == types.char) return types.CString; var i = ptrCache.indexOf(T); return i === -1 ? ptrCacheTo[ptrCache.push(T)-1] = ref.refType(T) : ptrCacheTo[i]; }; var refCache = [], refCacheTo = []; types.ref = function ReferenceType(T) { T = ref.coerceType(T); var i = refCache.indexOf(T); if(i !== -1) return refCacheTo[i]; var p = types.ptr(T), r = refCacheTo[refCache.push(T)-1] = Object.create(p); r.indirection = 1; r.size = ref.sizeof.pointer; r.alignment = ref.alignof.pointer; r.name = Tname(T)+'&'; r.ffi_type = ffi.FFI_TYPES.pointer; r.get = function get(buf, offset) { buf = ref.get(buf, offset, p); if(buf.isNull()) return null; return buf.deref(); }; r.set = function set(buf, offset, val) { if(!val) return ref.set(buf, offset, null, p); if(!val.buffer) throw new TypeError('valabind ['+r.name+']#set got a bad value'); return ref.set(buf, offset, val.buffer, p); }; return r; }; types.array = function ArrayType(T, N) { T = ref.coerceType(T); if(T == types.char) return types.staticCString(N); var r = Object.create(T); r.size *= N; r.name = Tname(T)+'['+N+']'; function ArrayType(buffer, base) { this.buffer = buffer; this._base = base; } ArrayType.prototype = []; ArrayType.prototype.constructor = ArrayType; for(var i = 0; i < N; i++) Object.defineProperty(ArrayType.prototype, i, { get: function get() { return ref.get(this.buffer, this._base+T.size*i, T); }, set: function set(val) { return ref.set(this.buffer, this._base+T.size*i, val, T); }, enumerable: true }); r.get = function get(buf, offset) { return new ArrayType(buf, offset); }; r.set = function set(buf, offset, val) { for(var i in val) { if(isNaN(i = +i) || i >= N) continue; ref.set(buf, offset+T.size*i, val[i], T); } }; return r; }; types.delegate = function DelegateType(ret, args) { var p = types.ptr(types.void), r = Object.create(p); r.indirection = 1; r.name = Tname(ret)+'('+args.map(function(T) {return Tname(T);}).join(', ')+')'; r.get = function get(buf, offset) { buf = ref.get(buf, offset, p); if(buf.isNull()) return null; return ffi.ForeignFunction(buf, ret, args); }; r.set = function set(buf, offset, val) { return ref.set(buf, offset, ffi.Callback(ret, args, void(0), val)); }; return r; }; var defaults = { forEach: function forEach(callback, thisArg) { if({}.toString.call(callback) != '[object Function]') throw new TypeError(callback + ' is not a function'); for(var T = thisArg || T, iter = this.iterator(); iter; iter = iter.get_next()) callback.call(T, iter.get_data(), iter, this); } }; function bindings(s) { function method(name, ret, args, static, more) { var f = (more == 'variadic' ? ffi.VariadicForeignFunction : ffi.ForeignFunction)(lib.get(name), ret, args); if(static) return f; return function() { [].unshift.call(arguments, this); return f.apply(null, arguments); }; } function define(base, n, m) { var static = n[0] == '$' && ((n = n.slice(1)), true); static = static || base[0] == '$' && ((base = base.slice(1)), true); if(Array.isArray(m)) m = method(m[0], m[1], m[2], static, m[3]); static ? exports[base][n] = m : types[base].prototype[n] = m; } function makeGeneric(G, n) { var cache = [], cacheTo = []; types[n] = function() { var l = arguments.length, args = [], c; // Coerce all type arguments. for(var i = 0; i < l; i++) args[i] = ref.coerceType(arguments[i].$type || arguments[i]); // Look in the cache, if the generic was already built. for(var i = 0; i < cache.length; i++) { if((c = cache[i]).length !== l) continue; for(var j = 0; j < l && c[j] === args[j]; j++); if(j === l) return cacheTo[i]; } // Create the new generic. var generic = cacheTo[cache.push(args)-1] = Struct(), g = G.apply(null, args); generic.$name = n+'<'+args.map(function(T) {return Tname(T);}).join(', ')+'>'; // Define all the generic's propoerties. for(var i in g[0]) generic.defineProperty(i, g[0][i]); // Insert all the generic's methods. if(g[1]) for(var i in g[1]) { var m = g[1][i]; if(Array.isArray(m)) m = method(m[0], m[1], m[2], false, m[3]); generic.prototype[i] = m; } return generic; }; } for(var i in s) { if(s[i].length) makeGeneric(s[i], i); else if(i[0] == '$') exports[i.slice(1)] = {}; else exports[i] = types[i] = Struct(), types[i].$name = i; } for(var i in s) { if(s[i].length) { // TODO insert constructor delete s[i]; continue; } s[i] = s[i](); if(Array.isArray(s[i])) { for(var j in s[i][0]) types[i].defineProperty(j, s[i][0][j]); s[i] = s[i][1]; } } for(var i in s) { if('$constructor' in s[i]) { var ctor = s[i].$constructor; exports[i] = method(ctor[0], ctor[1], ctor[2], true, ctor[3]), exports[i].$type = types[i]; delete s[i].$constructor; } for(var j in s[i]) define(i, j, s[i][j]); } } var _ = types; bindings({\n"+bind+"\n}); " ); if (enum_fmt != "") { string enums_out = get_enums_for ("printf(\"%s\"%s)".printf ( enum_fmt, enum_vals), includefiles); stream.puts (enums_out); } } } valabind-1.5.0/private/000077500000000000000000000000001323123274000147445ustar00rootroot00000000000000valabind-1.5.0/private/ccode.vapi000066400000000000000000000516031323123274000167070ustar00rootroot00000000000000/* ccode.vapi generated by valac, do not modify. */ namespace Vala { [CCode (cheader_filename = "valaccode.h")] public class CCodeAssignment : Vala.CCodeExpression { public CCodeAssignment (Vala.CCodeExpression l, Vala.CCodeExpression r, Vala.CCodeAssignmentOperator op = CCodeAssignmentOperator.SIMPLE); public override void write (Vala.CCodeWriter writer); public override void write_inner (Vala.CCodeWriter writer); public Vala.CCodeExpression left { get; set; } public Vala.CCodeAssignmentOperator operator { get; set; } public Vala.CCodeExpression right { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeBinaryExpression : Vala.CCodeExpression { public CCodeBinaryExpression (Vala.CCodeBinaryOperator op, Vala.CCodeExpression l, Vala.CCodeExpression r); public override void write (Vala.CCodeWriter writer); public override void write_inner (Vala.CCodeWriter writer); public Vala.CCodeExpression left { get; set; } public Vala.CCodeBinaryOperator operator { get; set; } public Vala.CCodeExpression right { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeBlock : Vala.CCodeStatement { public CCodeBlock (); public void add_statement (Vala.CCodeNode statement); public void prepend_statement (Vala.CCodeNode statement); public override void write (Vala.CCodeWriter writer); public bool suppress_newline { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeBreakStatement : Vala.CCodeStatement { public CCodeBreakStatement (); public override void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeCaseStatement : Vala.CCodeStatement { public CCodeCaseStatement (Vala.CCodeExpression expression); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression expression { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeCastExpression : Vala.CCodeExpression { public CCodeCastExpression (Vala.CCodeExpression expr, string type); public override void write (Vala.CCodeWriter writer); public override void write_inner (Vala.CCodeWriter writer); public Vala.CCodeExpression inner { get; set; } public string type_name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeCommaExpression : Vala.CCodeExpression { public CCodeCommaExpression (); public void append_expression (Vala.CCodeExpression expr); public Vala.List get_inner (); public void set_expression (int index, Vala.CCodeExpression expr); public override void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeComment : Vala.CCodeNode { public CCodeComment (string _text); public override void write (Vala.CCodeWriter writer); public string text { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeConditionalExpression : Vala.CCodeExpression { public CCodeConditionalExpression (Vala.CCodeExpression cond, Vala.CCodeExpression true_expr, Vala.CCodeExpression false_expr); public override void write (Vala.CCodeWriter writer); public override void write_inner (Vala.CCodeWriter writer); public Vala.CCodeExpression condition { get; set; } public Vala.CCodeExpression false_expression { get; set; } public Vala.CCodeExpression true_expression { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeConstant : Vala.CCodeExpression { public CCodeConstant (global::string _name); public CCodeConstant.string (global::string _name); public override void write (Vala.CCodeWriter writer); public global::string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeContinueStatement : Vala.CCodeStatement { public CCodeContinueStatement (); public override void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeDeclaration : Vala.CCodeStatement { public CCodeDeclaration (string type_name); public void add_declarator (Vala.CCodeDeclarator decl); public override void write (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); public string type_name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public abstract class CCodeDeclarator : Vala.CCodeNode { public CCodeDeclarator (); public virtual void write_initialization (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeDeclaratorSuffix { public CCodeDeclaratorSuffix (); public CCodeDeclaratorSuffix.with_array (Vala.CCodeExpression? array_length = null); public void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeDoStatement : Vala.CCodeStatement { public CCodeDoStatement (Vala.CCodeStatement stmt, Vala.CCodeExpression cond); public override void write (Vala.CCodeWriter writer); public Vala.CCodeStatement body { get; set; } public Vala.CCodeExpression condition { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeElementAccess : Vala.CCodeExpression { public CCodeElementAccess (Vala.CCodeExpression cont, Vala.CCodeExpression i); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression container { get; set; } public Vala.CCodeExpression index { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeEmptyStatement : Vala.CCodeStatement { public CCodeEmptyStatement (); public override void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeEnum : Vala.CCodeNode { public CCodeEnum (string? name = null); public void add_value (Vala.CCodeEnumValue value); public override void write (Vala.CCodeWriter writer); public string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeEnumValue : Vala.CCodeNode { public CCodeEnumValue (string name, Vala.CCodeExpression? value = null); public override void write (Vala.CCodeWriter writer); public string name { get; set; } public Vala.CCodeExpression? value { get; set; } } [CCode (cheader_filename = "valaccode.h")] public abstract class CCodeExpression : Vala.CCodeNode { public CCodeExpression (); public virtual void write_inner (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeExpressionStatement : Vala.CCodeStatement { public CCodeExpressionStatement (Vala.CCodeExpression expr); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression expression { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeFile { public CCodeFile (); public void add_comment (Vala.CCodeComment comment); public void add_constant_declaration (Vala.CCodeNode node); public bool add_declaration (string name); public void add_function (Vala.CCodeFunction func); public void add_function_declaration (Vala.CCodeFunction func); public void add_include (string filename, bool local = false); public void add_type_declaration (Vala.CCodeNode node); public void add_type_definition (Vala.CCodeNode node); public void add_type_member_declaration (Vala.CCodeNode node); public void add_type_member_definition (Vala.CCodeNode node); public Vala.List get_symbols (); public bool store (string filename, string? source_filename, bool write_version, bool line_directives, string? begin_decls = null, string? end_decls = null); public bool is_header { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeForStatement : Vala.CCodeStatement { public CCodeForStatement (Vala.CCodeExpression? condition, Vala.CCodeStatement? body = null); public void add_initializer (Vala.CCodeExpression expr); public void add_iterator (Vala.CCodeExpression expr); public override void write (Vala.CCodeWriter writer); public Vala.CCodeStatement body { get; set; } public Vala.CCodeExpression? condition { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeFragment : Vala.CCodeNode { public CCodeFragment (); public void append (Vala.CCodeNode node); public Vala.List get_children (); public override void write (Vala.CCodeWriter writer); public override void write_combined (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeFunction : Vala.CCodeNode { public CCodeFunction (string name, string return_type = "void"); public void add_assignment (Vala.CCodeExpression left, Vala.CCodeExpression right); public void add_break (); public void add_case (Vala.CCodeExpression expression); public void add_continue (); public void add_declaration (string type_name, Vala.CCodeDeclarator declarator, Vala.CCodeModifiers modifiers = 0); public void add_default (); public void add_else (); public void add_expression (Vala.CCodeExpression expression); public void add_goto (string target); public void add_label (string label); public void add_parameter (Vala.CCodeParameter param); public void add_return (Vala.CCodeExpression? expression = null); public void add_statement (Vala.CCodeNode stmt); public void close (); public Vala.CCodeFunction copy (); public void else_if (Vala.CCodeExpression condition); public Vala.CCodeParameter get_parameter (int position); public int get_parameter_count (); public void insert_parameter (int position, Vala.CCodeParameter param); public void open_block (); public void open_for (Vala.CCodeExpression? initializer, Vala.CCodeExpression condition, Vala.CCodeExpression? iterator); public void open_if (Vala.CCodeExpression condition); public void open_switch (Vala.CCodeExpression expression); public void open_while (Vala.CCodeExpression condition); public override void write (Vala.CCodeWriter writer); public Vala.CCodeBlock block { get; set; } public Vala.CCodeBlock current_block { get; set; } public Vala.CCodeLineDirective current_line { get; set; } public bool is_declaration { get; set; } public string name { get; set; } public string return_type { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeFunctionCall : Vala.CCodeExpression { public CCodeFunctionCall (Vala.CCodeExpression? call = null); public void add_argument (Vala.CCodeExpression expr); public Vala.List get_arguments (); public void insert_argument (int index, Vala.CCodeExpression expr); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression? call { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeFunctionDeclarator : Vala.CCodeDeclarator { public CCodeFunctionDeclarator (string name); public void add_parameter (Vala.CCodeParameter param); public override void write (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); public string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeGGnucSection : Vala.CCodeFragment { public CCodeGGnucSection (Vala.GGnucSectionType t); public override void write (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); public Vala.GGnucSectionType section_type { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeGotoStatement : Vala.CCodeStatement { public CCodeGotoStatement (string name); public override void write (Vala.CCodeWriter writer); public string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeIdentifier : Vala.CCodeExpression { public CCodeIdentifier (string _name); public override void write (Vala.CCodeWriter writer); public string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeIfSection : Vala.CCodeFragment { public CCodeIfSection (string expr); public override void write (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); public string expression { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeIfStatement : Vala.CCodeStatement { public CCodeIfStatement (Vala.CCodeExpression cond, Vala.CCodeStatement true_stmt, Vala.CCodeStatement? false_stmt = null); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression condition { get; set; } public bool else_if { get; set; } public Vala.CCodeStatement? false_statement { get; set; } public Vala.CCodeStatement true_statement { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeIncludeDirective : Vala.CCodeNode { public CCodeIncludeDirective (string _filename, bool _local = false); public override void write (Vala.CCodeWriter writer); public string filename { get; set; } public bool local { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeInitializerList : Vala.CCodeExpression { public CCodeInitializerList (); public void append (Vala.CCodeExpression expr); public override void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeInvalidExpression : Vala.CCodeExpression { public CCodeInvalidExpression (); public override void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public class CCodeLabel : Vala.CCodeStatement { public CCodeLabel (string name); public override void write (Vala.CCodeWriter writer); public string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeLineDirective : Vala.CCodeNode { public CCodeLineDirective (string _filename, int _line); public override void write (Vala.CCodeWriter writer); public string filename { get; set; } public int line_number { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeMacroReplacement : Vala.CCodeNode { public CCodeMacroReplacement (string name, string replacement); public CCodeMacroReplacement.with_expression (string name, Vala.CCodeExpression replacement_expression); public override void write (Vala.CCodeWriter writer); public string name { get; set; } public string replacement { get; set; } public Vala.CCodeExpression replacement_expression { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeMemberAccess : Vala.CCodeExpression { public CCodeMemberAccess (Vala.CCodeExpression container, string member, bool pointer = false); public CCodeMemberAccess.pointer (Vala.CCodeExpression container, string member); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression inner { get; set; } public bool is_pointer { get; set; } public string member_name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeNewline : Vala.CCodeNode { public CCodeNewline (); public override void write (Vala.CCodeWriter writer); } [CCode (cheader_filename = "valaccode.h")] public abstract class CCodeNode { public CCodeNode (); public abstract void write (Vala.CCodeWriter writer); public virtual void write_combined (Vala.CCodeWriter writer); public virtual void write_declaration (Vala.CCodeWriter writer); public Vala.CCodeLineDirective line { get; set; } public Vala.CCodeModifiers modifiers { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeOnceSection : Vala.CCodeFragment { public CCodeOnceSection (string def); public override void write (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); public string define { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeParameter : Vala.CCodeNode { public CCodeParameter (string n, string type); public CCodeParameter.with_ellipsis (); public override void write (Vala.CCodeWriter writer); public bool ellipsis { get; set; } public string name { get; set; } public string type_name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeParenthesizedExpression : Vala.CCodeExpression { public CCodeParenthesizedExpression (Vala.CCodeExpression expr); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression inner { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeReturnStatement : Vala.CCodeStatement { public CCodeReturnStatement (Vala.CCodeExpression? expr = null); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression? return_expression { get; set; } } [CCode (cheader_filename = "valaccode.h")] public abstract class CCodeStatement : Vala.CCodeNode { public CCodeStatement (); } [CCode (cheader_filename = "valaccode.h")] public class CCodeStruct : Vala.CCodeNode { public CCodeStruct (string name); public void add_declaration (Vala.CCodeDeclaration decl); public void add_field (string type_name, string name, Vala.CCodeModifiers modifiers = 0, Vala.CCodeDeclaratorSuffix? declarator_suffix = null); public override void write (Vala.CCodeWriter writer); public bool is_empty { get; } public string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeSwitchStatement : Vala.CCodeBlock { public CCodeSwitchStatement (Vala.CCodeExpression expression); public override void write (Vala.CCodeWriter writer); public Vala.CCodeExpression expression { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeTypeDefinition : Vala.CCodeNode { public CCodeTypeDefinition (string type, Vala.CCodeDeclarator decl); public override void write (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); public Vala.CCodeDeclarator declarator { get; set; } public string type_name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeUnaryExpression : Vala.CCodeExpression { public CCodeUnaryExpression (Vala.CCodeUnaryOperator op, Vala.CCodeExpression expr); public override void write (Vala.CCodeWriter writer); public override void write_inner (Vala.CCodeWriter writer); public Vala.CCodeExpression inner { get; set; } public Vala.CCodeUnaryOperator operator { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeVariableDeclarator : Vala.CCodeDeclarator { public CCodeVariableDeclarator (string name, Vala.CCodeExpression? initializer = null, Vala.CCodeDeclaratorSuffix? declarator_suffix = null); public override void write (Vala.CCodeWriter writer); public override void write_declaration (Vala.CCodeWriter writer); public override void write_initialization (Vala.CCodeWriter writer); public CCodeVariableDeclarator.zero (string name, Vala.CCodeExpression? initializer, Vala.CCodeDeclaratorSuffix? declarator_suffix = null); public Vala.CCodeDeclaratorSuffix? declarator_suffix { get; set; } public bool init0 { get; set; } public Vala.CCodeExpression? initializer { get; set; } public string name { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeWhileStatement : Vala.CCodeStatement { public CCodeWhileStatement (Vala.CCodeExpression cond, Vala.CCodeStatement? stmt = null); public override void write (Vala.CCodeWriter writer); public Vala.CCodeStatement body { get; set; } public Vala.CCodeExpression condition { get; set; } } [CCode (cheader_filename = "valaccode.h")] public class CCodeWriter { public CCodeWriter (string filename, string? source_filename = null); public void close (); public bool open (bool write_version); public void write_begin_block (); public void write_comment (string text); public void write_end_block (); public void write_indent (Vala.CCodeLineDirective? line = null); public void write_newline (); public void write_nspaces (uint n); public void write_string (string s); public bool bol { get; } public string filename { get; set; } public bool line_directives { get; set; } } [CCode (cheader_filename = "valaccode.h")] public enum CCodeAssignmentOperator { SIMPLE, BITWISE_OR, BITWISE_AND, BITWISE_XOR, ADD, SUB, MUL, DIV, PERCENT, SHIFT_LEFT, SHIFT_RIGHT } [CCode (cheader_filename = "valaccode.h")] public enum CCodeBinaryOperator { PLUS, MINUS, MUL, DIV, MOD, SHIFT_LEFT, SHIFT_RIGHT, LESS_THAN, GREATER_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN_OR_EQUAL, EQUALITY, INEQUALITY, BITWISE_AND, BITWISE_OR, BITWISE_XOR, AND, OR } [CCode (cheader_filename = "valaccode.h")] [Flags] public enum CCodeModifiers { NONE, STATIC, REGISTER, EXTERN, INLINE, VOLATILE, DEPRECATED, THREAD_LOCAL, INTERNAL, CONST, UNUSED, CONSTRUCTOR, DESTRUCTOR, FORMAT_ARG, PRINTF, SCANF } [CCode (cheader_filename = "valaccode.h")] public enum CCodeUnaryOperator { PLUS, MINUS, LOGICAL_NEGATION, BITWISE_COMPLEMENT, POINTER_INDIRECTION, ADDRESS_OF, PREFIX_INCREMENT, PREFIX_DECREMENT, POSTFIX_INCREMENT, POSTFIX_DECREMENT } [CCode (cheader_filename = "valaccode.h")] public enum GGnucSectionType { IGNORE_DEPRECATIONS; public unowned string to_string (); } } valabind-1.5.0/private/codegen.vapi000066400000000000000000001476211323123274000172440ustar00rootroot00000000000000/* codegen.vapi generated by valac, do not modify. */ namespace Vala { [CCode (cheader_filename = "valacodegen.h")] public class CCodeArrayModule : Vala.CCodeMethodCallModule { public CCodeArrayModule (); public override string? append_struct_array_free (Vala.Struct st); public override void append_vala_array_free (); public override void append_vala_array_length (); public override void append_vala_array_move (); public override Vala.TargetValue? copy_value (Vala.TargetValue value, Vala.CodeNode node); public override Vala.CCodeExpression destroy_value (Vala.TargetValue value, bool is_macro_definition = false); public override Vala.CCodeParameter generate_parameter (Vala.Parameter param, Vala.CCodeFile decl_space, Vala.Map cparam_map, Vala.Map? carg_map); public override Vala.CCodeExpression get_array_length_cexpression (Vala.Expression array_expr, int dim = -1); public override string get_array_length_cname (string array_cname, int dim); public override Vala.CCodeExpression get_array_length_cvalue (Vala.TargetValue value, int dim = -1); public override string get_array_size_cname (string array_cname); public override Vala.CCodeExpression? get_dup_func_expression (Vala.DataType type, Vala.SourceReference? source_reference, bool is_chainup); public override string get_parameter_array_length_cname (Vala.Parameter param, int dim); public override void visit_array_creation_expression (Vala.ArrayCreationExpression expr); public override void visit_assignment (Vala.Assignment assignment); public override void visit_element_access (Vala.ElementAccess expr); public override void visit_slice_expression (Vala.SliceExpression expr); } [CCode (cheader_filename = "valacodegen.h")] public class CCodeAssignmentModule : Vala.CCodeMemberAccessModule { public CCodeAssignmentModule (); public override void store_field (Vala.Field field, Vala.TargetValue? instance, Vala.TargetValue value, Vala.SourceReference? source_reference = null); public override void store_local (Vala.LocalVariable local, Vala.TargetValue value, bool initializer, Vala.SourceReference? source_reference = null); public override void store_parameter (Vala.Parameter param, Vala.TargetValue _value, bool capturing_parameter = false, Vala.SourceReference? source_reference = null); public override void store_value (Vala.TargetValue lvalue, Vala.TargetValue value, Vala.SourceReference? source_reference = null); public override void visit_assignment (Vala.Assignment assignment); } [CCode (cheader_filename = "valacodegen.h")] public class CCodeAttribute : Vala.AttributeCache { public CCodeAttribute (Vala.CodeNode node); public bool array_length { get; } public string? array_length_expr { get; private set; } public string? array_length_name { get; private set; } public string? array_length_type { get; private set; } public bool array_null_terminated { get; } public string const_name { get; } public string copy_function { get; } public string ctype { get; } public string default_value { get; } public bool delegate_target { get; private set; } public string delegate_target_name { get; } public string destroy_function { get; } public string dup_function { get; } public bool finish_instance { get; } public string finish_name { get; } public string finish_real_name { get; } public string finish_vfunc_name { get; } public string free_function { get; } public bool free_function_address_of { get; } public string get_value_function { get; } public string header_filenames { get; } public string lower_case_prefix { get; } public string lower_case_suffix { get; } public string marshaller_type_name { get; } public string name { get; } public string param_spec_function { get; } public double pos { get; } public string prefix { get; } public string real_name { get; } public string ref_function { get; } public bool ref_function_void { get; } public string ref_sink_function { get; } public string sentinel { get; private set; } public string set_value_function { get; } public string take_value_function { get; } public string type_id { get; } public string type_name { get; } public string unref_function { get; } public string vfunc_name { get; } } [CCode (cheader_filename = "valacodegen.h")] public abstract class CCodeBaseModule : Vala.CodeGenerator { public class EmitContext { public Vala.CCodeFunction ccode; public Vala.ArrayList ccode_stack; public Vala.Map closure_variable_clash_map; public Vala.Map closure_variable_count_map; public Vala.CatchClause current_catch; public bool current_method_inner_error; public bool current_method_return; public Vala.Symbol? current_symbol; public Vala.TryStatement current_try; public int next_coroutine_state; public int next_temp_var_id; public Vala.ArrayList symbol_stack; public Vala.ArrayList temp_ref_values; public Vala.Map variable_name_map; public EmitContext (Vala.Symbol? symbol = null); public void pop_symbol (); public void push_symbol (Vala.Symbol symbol); } public Vala.CCodeBaseModule.EmitContext base_finalize_context; public Vala.CCodeBaseModule.EmitContext base_init_context; public Vala.DataType bool_type; public static int ccode_attribute_cache_index; public Vala.CCodeFile cfile; public Vala.DataType char_type; public Vala.CCodeBaseModule.EmitContext class_finalize_context; public Vala.CCodeBaseModule.EmitContext class_init_context; public Vala.CCodeStruct closure_struct; public Vala.CCodeLineDirective? current_line; public Vala.TypeSymbol dbus_proxy_type; public Vala.DataType double_type; public Vala.CCodeBaseModule.EmitContext emit_context; public Vala.DataType float_type; public Vala.TypeSymbol garray_type; public Vala.TypeSymbol gbytearray_type; public Vala.Struct gcond_type; public Vala.DataType gdestroynotify_type; public Vala.ErrorType gerror_type; public Vala.Class glist_type; public Vala.Struct gmutex_type; public Vala.Class gnode_type; public Vala.TypeSymbol gobject_type; public Vala.TypeSymbol gptrarray_type; public Vala.DataType gquark_type; public Vala.Class gqueue_type; public Vala.Struct grecmutex_type; public Vala.Struct grwlock_type; public Vala.Class gslist_type; public Vala.Class gsource_type; public Vala.TypeSymbol gstringbuilder_type; public Vala.TypeSymbol gthreadpool_type; public Vala.Class gtk_widget_type; public Vala.TypeSymbol gtype_type; public Vala.Struct gvalue_type; public Vala.Class gvaluearray_type; public bool gvaluecollector_h_needed; public Vala.Class gvariant_type; public Vala.CCodeFile header_file; public bool in_plugin; public Vala.CCodeBaseModule.EmitContext instance_finalize_context; public Vala.CCodeBaseModule.EmitContext instance_init_context; public Vala.DataType int16_type; public Vala.DataType int32_type; public Vala.DataType int64_type; public Vala.DataType int8_type; public Vala.DataType int_type; public Vala.CCodeFile internal_header_file; public Vala.DataType long_type; public string module_init_param_name; public Vala.Struct mutex_type; public int next_regex_id; public Vala.CCodeStruct param_spec_struct; public Vala.Set predefined_marshal_set; public Vala.CCodeEnum prop_enum; public Vala.DataType regex_type; public bool requires_array_free; public bool requires_array_length; public bool requires_array_move; public bool requires_assert; public bool requires_clear_mutex; public Vala.Symbol root_symbol; public Vala.DataType short_type; public Vala.CCodeEnum signal_enum; public Vala.DataType string_type; public Vala.TypeSymbol type_module_type; public Vala.DataType uchar_type; public Vala.DataType uint16_type; public Vala.DataType uint32_type; public Vala.DataType uint64_type; public Vala.DataType uint8_type; public Vala.DataType uint_type; public Vala.DataType ulong_type; public Vala.DataType? unichar_type; public Vala.Set user_marshal_set; public Vala.DataType ushort_type; public Vala.DataType void_type; public Vala.Set wrappers; public CCodeBaseModule (); public bool add_generated_external_symbol (Vala.Symbol external_symbol); public void add_generic_type_arguments (Vala.Map arg_map, Vala.List type_args, Vala.CodeNode expr, bool is_chainup = false, Vala.List? type_parameters = null); public virtual void add_simple_check (Vala.CodeNode node, bool always_fails = false); public bool add_symbol_declaration (Vala.CCodeFile decl_space, Vala.Symbol sym, string name); public bool add_wrapper (string wrapper_name); public void append_array_length (Vala.Expression expr, Vala.CCodeExpression size); public void append_local_free (Vala.Symbol sym, bool stop_at_loop = false, Vala.CodeNode? stop_at = null); protected virtual void append_scope_free (Vala.Symbol sym, Vala.CodeNode? stop_at = null); public virtual string? append_struct_array_free (Vala.Struct st); public virtual void append_vala_array_free (); public virtual void append_vala_array_length (); public virtual void append_vala_array_move (); public void append_vala_clear_mutex (string typename, string funcprefix); public void check_type (Vala.DataType type); public void check_type_arguments (Vala.MemberAccess access); public Vala.CCodeExpression convert_from_generic_pointer (Vala.CCodeExpression cexpr, Vala.DataType actual_type); public Vala.CCodeExpression convert_to_generic_pointer (Vala.CCodeExpression cexpr, Vala.DataType actual_type); public virtual Vala.TargetValue? copy_value (Vala.TargetValue value, Vala.CodeNode node); public void create_postcondition_statement (Vala.Expression postcondition); public Vala.TargetValue create_temp_value (Vala.DataType type, bool init, Vala.CodeNode node_reference, bool? value_owned = null); public virtual void create_type_check_statement (Vala.CodeNode method_node, Vala.DataType ret_type, Vala.TypeSymbol t, bool non_null, string var_name); public Vala.CCodeExpression? default_value_for_type (Vala.DataType type, bool initializer_expression); public virtual Vala.CCodeExpression? deserialize_expression (Vala.DataType type, Vala.CCodeExpression variant_expr, Vala.CCodeExpression? expr, Vala.CCodeExpression? error_expr = null, out bool may_fail = null); public Vala.CCodeExpression destroy_field (Vala.Field field, Vala.TargetValue? instance); public Vala.CCodeExpression destroy_local (Vala.LocalVariable local); public Vala.CCodeExpression destroy_parameter (Vala.Parameter param); public virtual Vala.CCodeExpression destroy_value (Vala.TargetValue value, bool is_macro_definition = false); public override void emit (Vala.CodeContext context); public void emit_temp_var (Vala.LocalVariable local); public virtual void generate_class_declaration (Vala.Class cl, Vala.CCodeFile decl_space); public virtual void generate_class_struct_declaration (Vala.Class cl, Vala.CCodeFile decl_space); public void generate_constant_declaration (Vala.Constant c, Vala.CCodeFile decl_space, bool definition = false); public virtual void generate_cparameters (Vala.Method m, Vala.CCodeFile decl_space, Vala.Map cparam_map, Vala.CCodeFunction func, Vala.CCodeFunctionDeclarator? vdeclarator = null, Vala.Map? carg_map = null, Vala.CCodeFunctionCall? vcall = null, int direction = 3); public virtual void generate_delegate_declaration (Vala.Delegate d, Vala.CCodeFile decl_space); protected string generate_dup_func_wrapper (Vala.DataType type); public virtual void generate_dynamic_method_wrapper (Vala.DynamicMethod method); public virtual bool generate_enum_declaration (Vala.Enum en, Vala.CCodeFile decl_space); public virtual void generate_error_domain_declaration (Vala.ErrorDomain edomain, Vala.CCodeFile decl_space); public void generate_field_declaration (Vala.Field f, Vala.CCodeFile decl_space); protected string generate_free_func_wrapper (Vala.DataType type); protected string generate_free_function_address_of_wrapper (Vala.DataType type); public Vala.CCodeFunctionCall generate_instance_cast (Vala.CCodeExpression expr, Vala.TypeSymbol type); public virtual void generate_interface_declaration (Vala.Interface iface, Vala.CCodeFile decl_space); public virtual void generate_method_declaration (Vala.Method m, Vala.CCodeFile decl_space); public void generate_property_accessor_declaration (Vala.PropertyAccessor acc, Vala.CCodeFile decl_space); public virtual string generate_ready_function (Vala.Method m); public virtual void generate_struct_declaration (Vala.Struct st, Vala.CCodeFile decl_space); public void generate_type_declaration (Vala.DataType type, Vala.CCodeFile decl_space); public Vala.CCodeExpression get_array_length_cexpr (Vala.TargetValue value); public virtual Vala.CCodeExpression get_array_length_cexpression (Vala.Expression array_expr, int dim = -1); public virtual string get_array_length_cname (string array_cname, int dim); public virtual Vala.CCodeExpression get_array_length_cvalue (Vala.TargetValue value, int dim = -1); public Vala.List? get_array_lengths (Vala.Expression expr); public bool get_array_null_terminated (Vala.TargetValue value); public virtual string get_array_size_cname (string array_cname); public Vala.CCodeExpression? get_array_size_cvalue (Vala.TargetValue value); public int get_block_id (Vala.Block b); public Vala.CCodeDeclaratorSuffix? get_ccode_declarator_suffix (Vala.DataType type); public Vala.CCodeExpression? get_ccodenode (Vala.Expression node); public string? get_ctype (Vala.TargetValue value); public Vala.CCodeExpression? get_cvalue (Vala.Expression expr); public Vala.CCodeExpression? get_cvalue_ (Vala.TargetValue value); public static Vala.DataType get_data_type_for_symbol (Vala.TypeSymbol sym); public Vala.CCodeExpression? get_delegate_target (Vala.Expression expr); public virtual Vala.CCodeExpression get_delegate_target_cexpression (Vala.Expression delegate_expr, out Vala.CCodeExpression delegate_target_destroy_notify); public virtual string get_delegate_target_cname (string delegate_cname); public virtual Vala.CCodeExpression get_delegate_target_cvalue (Vala.TargetValue value); public Vala.CCodeExpression? get_delegate_target_destroy_notify (Vala.Expression expr); public virtual string get_delegate_target_destroy_notify_cname (string delegate_cname); public virtual Vala.CCodeExpression get_delegate_target_destroy_notify_cvalue (Vala.TargetValue value); public Vala.CCodeExpression? get_destroy0_func_expression (Vala.DataType type, bool is_chainup = false); public Vala.CCodeExpression? get_destroy_func_expression (Vala.DataType type, bool is_chainup = false); public virtual Vala.CCodeExpression? get_dup_func_expression (Vala.DataType type, Vala.SourceReference? source_reference, bool is_chainup = false); public virtual string get_dynamic_property_getter_cname (Vala.DynamicProperty node); public virtual string get_dynamic_property_setter_cname (Vala.DynamicProperty node); public virtual string get_dynamic_signal_cname (Vala.DynamicSignal node); public virtual string get_dynamic_signal_connect_after_wrapper_name (Vala.DynamicSignal node); public virtual string get_dynamic_signal_connect_wrapper_name (Vala.DynamicSignal node); public virtual string get_dynamic_signal_disconnect_wrapper_name (Vala.DynamicSignal node); public static Vala.CCodeConstant get_enum_value_canonical_cconstant (Vala.EnumValue ev); public abstract Vala.TargetValue get_field_cvalue (Vala.Field field, Vala.TargetValue? instance); public virtual Vala.CCodeExpression get_implicit_cast_expression (Vala.CCodeExpression source_cexpr, Vala.DataType? expression_type, Vala.DataType? target_type, Vala.CodeNode? node); public Vala.CCodeExpression get_local_cexpression (Vala.LocalVariable local); public string get_local_cname (Vala.LocalVariable local); public abstract Vala.TargetValue get_local_cvalue (Vala.LocalVariable local); public bool get_lvalue (Vala.TargetValue value); public bool get_non_null (Vala.TargetValue value); public int get_param_pos (double param_pos, bool ellipsis = false); public virtual Vala.CCodeExpression get_param_spec (Vala.Property prop); public virtual Vala.CCodeExpression get_param_spec_cexpression (Vala.Property prop); public virtual string get_parameter_array_length_cname (Vala.Parameter param, int dim); public abstract Vala.TargetValue get_parameter_cvalue (Vala.Parameter param); public Vala.CCodeConstant get_property_canonical_cconstant (Vala.Property prop); public Vala.CCodeExpression get_result_cexpression (string cname = "result"); public Vala.CCodeConstant get_signal_canonical_constant (Vala.Signal sig, string? detail = null); public virtual Vala.CCodeExpression get_signal_creation (Vala.Signal sig, Vala.TypeSymbol type); public bool get_signal_has_emitter (Vala.Signal sig); public string get_symbol_lock_name (string symname); public Vala.LocalVariable get_temp_variable (Vala.DataType type, bool value_owned = true, Vala.CodeNode? node_reference = null, bool init = false); public Vala.CCodeExpression get_this_cexpression (); public Vala.DataType? get_this_type (); public Vala.CCodeExpression get_type_id_expression (Vala.DataType type, bool is_chainup = false); public Vala.CCodeIdentifier get_value_setter_function (Vala.DataType type_reference); public Vala.CCodeIdentifier get_value_taker_function (Vala.DataType type_reference); public Vala.CCodeExpression get_variable_cexpression (string name); public string get_variable_cname (string name); public Vala.CCodeExpression? handle_struct_argument (Vala.Parameter? param, Vala.Expression arg, Vala.CCodeExpression? cexpr); public bool is_constant_ccode_expression (Vala.CCodeExpression cexpr); public virtual bool is_gobject_property (Vala.Property prop); public bool is_in_constructor (); public bool is_in_coroutine (); public bool is_in_destructor (); public bool is_lvalue_access_allowed (Vala.DataType type); public bool is_pure_ccode_expression (Vala.CCodeExpression cexpr); public bool is_simple_struct_creation (Vala.Variable variable, Vala.Expression expr); public Vala.TargetValue load_temp_value (Vala.TargetValue lvalue); public abstract Vala.TargetValue load_this_parameter (Vala.TypeSymbol sym); public abstract Vala.TargetValue load_variable (Vala.Variable variable, Vala.TargetValue value); public virtual bool method_has_wrapper (Vala.Method method); public unowned Vala.Block? next_closure_block (Vala.Symbol sym); public bool no_implicit_copy (Vala.DataType type); public void pop_context (); public void pop_function (); public void pop_line (); public void push_context (Vala.CCodeBaseModule.EmitContext emit_context); public void push_function (Vala.CCodeFunction func); public void push_line (Vala.SourceReference? source_reference); public virtual void register_dbus_info (Vala.CCodeBlock block, Vala.ObjectTypeSymbol bindable); public bool requires_copy (Vala.DataType type); public bool requires_destroy (Vala.DataType type); public void return_default_value (Vala.DataType return_type); public void return_out_parameter (Vala.Parameter param); public virtual Vala.CCodeExpression? serialize_expression (Vala.DataType type, Vala.CCodeExpression expr); public void set_array_size_cvalue (Vala.TargetValue value, Vala.CCodeExpression? cvalue); public void set_cvalue (Vala.Expression expr, Vala.CCodeExpression? cvalue); public void set_delegate_target (Vala.Expression expr, Vala.CCodeExpression? delegate_target); public void set_delegate_target_destroy_notify (Vala.Expression expr, Vala.CCodeExpression? destroy_notify); public void store_property (Vala.Property prop, Vala.Expression? instance, Vala.TargetValue value); public Vala.TargetValue store_temp_value (Vala.TargetValue initializer, Vala.CodeNode node_reference, bool? value_owned = null); public abstract void store_value (Vala.TargetValue lvalue, Vala.TargetValue value, Vala.SourceReference? source_reference = null); public Vala.TargetValue transform_value (Vala.TargetValue value, Vala.DataType? target_type, Vala.CodeNode node); public Vala.CCodeExpression? try_cast_value_to_type (Vala.CCodeExpression ccodeexpr, Vala.DataType from, Vala.DataType to, Vala.Expression? expr = null); public Vala.TargetValue? try_cast_variant_to_type (Vala.TargetValue value, Vala.DataType to, Vala.CodeNode? node = null); public bool variable_accessible_in_finally (Vala.LocalVariable local); public override void visit_addressof_expression (Vala.AddressofExpression expr); public override void visit_base_access (Vala.BaseAccess expr); public override void visit_binary_expression (Vala.BinaryExpression expr); public override void visit_block (Vala.Block b); public override void visit_boolean_literal (Vala.BooleanLiteral expr); public override void visit_cast_expression (Vala.CastExpression expr); public override void visit_character_literal (Vala.CharacterLiteral expr); public override void visit_class (Vala.Class cl); public override void visit_constant (Vala.Constant c); public override void visit_declaration_statement (Vala.DeclarationStatement stmt); public override void visit_delete_statement (Vala.DeleteStatement stmt); public override void visit_destructor (Vala.Destructor d); public override void visit_end_full_expression (Vala.Expression expr); public override void visit_enum (Vala.Enum en); public override void visit_expression (Vala.Expression expr); public override void visit_expression_statement (Vala.ExpressionStatement stmt); public override void visit_field (Vala.Field f); public override void visit_formal_parameter (Vala.Parameter p); public override void visit_initializer_list (Vala.InitializerList list); public override void visit_integer_literal (Vala.IntegerLiteral expr); public override void visit_lambda_expression (Vala.LambdaExpression lambda); public override void visit_local_variable (Vala.LocalVariable local); public override void visit_lock_statement (Vala.LockStatement stmt); public void visit_member (Vala.Symbol m); public override void visit_named_argument (Vala.NamedArgument expr); public override void visit_null_literal (Vala.NullLiteral expr); public override void visit_object_creation_expression (Vala.ObjectCreationExpression expr); public override void visit_pointer_indirection (Vala.PointerIndirection expr); public override void visit_postfix_expression (Vala.PostfixExpression expr); public override void visit_property (Vala.Property prop); public override void visit_property_accessor (Vala.PropertyAccessor acc); public override void visit_real_literal (Vala.RealLiteral expr); public override void visit_reference_transfer_expression (Vala.ReferenceTransferExpression expr); public override void visit_regex_literal (Vala.RegexLiteral expr); public override void visit_return_statement (Vala.ReturnStatement stmt); public override void visit_sizeof_expression (Vala.SizeofExpression expr); public override void visit_source_file (Vala.SourceFile source_file); public override void visit_string_literal (Vala.StringLiteral expr); public override void visit_type_check (Vala.TypeCheck expr); public override void visit_typeof_expression (Vala.TypeofExpression expr); public override void visit_unary_expression (Vala.UnaryExpression expr); public override void visit_unlock_statement (Vala.UnlockStatement stmt); public Vala.CCodeFunction ccode { get; } public Vala.CodeContext context { get; set; } public Vala.CatchClause current_catch { get; set; } public Vala.Class? current_class { get; } public Vala.Block? current_closure_block { get; } public Vala.Constructor? current_constructor { get; } public Vala.Destructor? current_destructor { get; } public Vala.Method? current_method { get; } public bool current_method_inner_error { get; set; } public bool current_method_return { get; set; } public Vala.PropertyAccessor? current_property_accessor { get; } public Vala.DataType? current_return_type { get; } public Vala.Symbol current_symbol { get; } public Vala.TryStatement current_try { get; set; } public Vala.TypeSymbol? current_type_symbol { get; } public bool in_creation_method { get; } public int next_temp_var_id { get; set; } public Vala.ArrayList temp_ref_values { get; } public Vala.Map variable_name_map { get; } } [CCode (cheader_filename = "valacodegen.h")] public class CCodeCompiler { public CCodeCompiler (); public void compile (Vala.CodeContext context, string? cc_command, string[] cc_options, string? pkg_config_command = null); } [CCode (cheader_filename = "valacodegen.h")] public abstract class CCodeControlFlowModule : Vala.CCodeMethodModule { public CCodeControlFlowModule (); public override void visit_break_statement (Vala.BreakStatement stmt); public override void visit_continue_statement (Vala.ContinueStatement stmt); public override void visit_foreach_statement (Vala.ForeachStatement stmt); public override void visit_if_statement (Vala.IfStatement stmt); public override void visit_loop (Vala.Loop stmt); public override void visit_switch_label (Vala.SwitchLabel label); public override void visit_switch_statement (Vala.SwitchStatement stmt); } [CCode (cheader_filename = "valacodegen.h")] public class CCodeDelegateModule : Vala.CCodeArrayModule { public CCodeDelegateModule (); public override void generate_delegate_declaration (Vala.Delegate d, Vala.CCodeFile decl_space); public string generate_delegate_wrapper (Vala.Method m, Vala.DelegateType dt, Vala.CodeNode? node); public override Vala.CCodeParameter generate_parameter (Vala.Parameter param, Vala.CCodeFile decl_space, Vala.Map cparam_map, Vala.Map? carg_map); public override Vala.CCodeExpression get_delegate_target_cexpression (Vala.Expression delegate_expr, out Vala.CCodeExpression delegate_target_destroy_notify); public override string get_delegate_target_cname (string delegate_cname); public override Vala.CCodeExpression get_delegate_target_cvalue (Vala.TargetValue value); public override string get_delegate_target_destroy_notify_cname (string delegate_cname); public override Vala.CCodeExpression get_delegate_target_destroy_notify_cvalue (Vala.TargetValue value); public override Vala.CCodeExpression get_implicit_cast_expression (Vala.CCodeExpression source_cexpr, Vala.DataType? expression_type, Vala.DataType? target_type, Vala.CodeNode? node); public override void visit_delegate (Vala.Delegate d); } [CCode (cheader_filename = "valacodegen.h")] public abstract class CCodeMemberAccessModule : Vala.CCodeControlFlowModule { public CCodeMemberAccessModule (); public override Vala.TargetValue get_field_cvalue (Vala.Field field, Vala.TargetValue? instance); public override Vala.TargetValue get_local_cvalue (Vala.LocalVariable local); public override Vala.TargetValue get_parameter_cvalue (Vala.Parameter param); public override Vala.TargetValue load_field (Vala.Field field, Vala.TargetValue? instance); public override Vala.TargetValue load_local (Vala.LocalVariable local); public override Vala.TargetValue load_parameter (Vala.Parameter param); public override Vala.TargetValue load_this_parameter (Vala.TypeSymbol sym); public override Vala.TargetValue load_variable (Vala.Variable variable, Vala.TargetValue value); public override void visit_member_access (Vala.MemberAccess expr); } [CCode (cheader_filename = "valacodegen.h")] public class CCodeMethodCallModule : Vala.CCodeAssignmentModule { public CCodeMethodCallModule (); public override void visit_method_call (Vala.MethodCall expr); } [CCode (cheader_filename = "valacodegen.h")] public abstract class CCodeMethodModule : Vala.CCodeStructModule { public CCodeMethodModule (); public void complete_async (); public override void generate_cparameters (Vala.Method m, Vala.CCodeFile decl_space, Vala.Map cparam_map, Vala.CCodeFunction func, Vala.CCodeFunctionDeclarator? vdeclarator = null, Vala.Map? carg_map = null, Vala.CCodeFunctionCall? vcall = null, int direction = 3); public override void generate_method_declaration (Vala.Method m, Vala.CCodeFile decl_space); public virtual void generate_method_result_declaration (Vala.Method m, Vala.CCodeFile decl_space, Vala.CCodeFunction cfunc, Vala.Map cparam_map, Vala.Map? carg_map); public virtual Vala.CCodeParameter generate_parameter (Vala.Parameter param, Vala.CCodeFile decl_space, Vala.Map cparam_map, Vala.Map? carg_map); public void generate_vfunc (Vala.Method m, Vala.DataType return_type, Vala.Map cparam_map, Vala.Map carg_map, string suffix = "", int direction = 3); public override bool method_has_wrapper (Vala.Method method); public override void visit_creation_method (Vala.CreationMethod m); public override void visit_method (Vala.Method m); } [CCode (cheader_filename = "valacodegen.h")] public abstract class CCodeStructModule : Vala.CCodeBaseModule { public CCodeStructModule (); public override void generate_struct_declaration (Vala.Struct st, Vala.CCodeFile decl_space); public override void visit_struct (Vala.Struct st); } [CCode (cheader_filename = "valacodegen.h")] public class CType : Vala.DataType { public CType (string ctype_name); public override Vala.DataType copy (); public string ctype_name { get; set; } } [CCode (cheader_filename = "valacodegen.h")] public class ClassRegisterFunction : Vala.TypeRegisterFunction { public ClassRegisterFunction (Vala.Class cl); public override Vala.SymbolAccessibility get_accessibility (); public override string get_base_finalize_func_name (); public override string get_base_init_func_name (); public override string get_class_finalize_func_name (); public override string get_class_init_func_name (); public override string? get_gtype_value_table_collect_value_function_name (); public override string? get_gtype_value_table_copy_function_name (); public override string? get_gtype_value_table_free_function_name (); public override string? get_gtype_value_table_init_function_name (); public override string? get_gtype_value_table_lcopy_value_function_name (); public override string? get_gtype_value_table_peek_pointer_function_name (); public override string get_instance_init_func_name (); public override string get_instance_struct_size (); public override string get_parent_type_name (); public override Vala.TypeSymbol get_type_declaration (); public override string get_type_flags (); public override Vala.CCodeFragment get_type_interface_init_declaration (); public override void get_type_interface_init_statements (Vala.CodeContext context, Vala.CCodeBlock block, bool plugin); public override string get_type_struct_name (); public Vala.Class class_reference { get; set; } } [CCode (cheader_filename = "valacodegen.h")] public class EnumRegisterFunction : Vala.TypeRegisterFunction { public EnumRegisterFunction (Vala.Enum en); public override Vala.SymbolAccessibility get_accessibility (); public override Vala.TypeSymbol get_type_declaration (); public Vala.Enum enum_reference { get; set; } } [CCode (cheader_filename = "valacodegen.h")] public class GAsyncModule : Vala.GtkModule { public GAsyncModule (); public string generate_async_callback_wrapper (); public override void generate_cparameters (Vala.Method m, Vala.CCodeFile decl_space, Vala.Map cparam_map, Vala.CCodeFunction func, Vala.CCodeFunctionDeclarator? vdeclarator = null, Vala.Map? carg_map = null, Vala.CCodeFunctionCall? vcall = null, int direction = 3); public override void generate_method_declaration (Vala.Method m, Vala.CCodeFile decl_space); public override string generate_ready_function (Vala.Method m); public override void generate_virtual_method_declaration (Vala.Method m, Vala.CCodeFile decl_space, Vala.CCodeStruct type_struct); public override void return_with_exception (Vala.CCodeExpression error_expr); public override void visit_creation_method (Vala.CreationMethod m); public override void visit_method (Vala.Method m); public override void visit_return_statement (Vala.ReturnStatement stmt); public override void visit_yield_statement (Vala.YieldStatement stmt); } [CCode (cheader_filename = "valacodegen.h")] public class GDBusClientModule : Vala.GDBusModule { public GDBusClientModule (); public override void generate_dynamic_method_wrapper (Vala.DynamicMethod method); public override void generate_interface_declaration (Vala.Interface iface, Vala.CCodeFile decl_space); public Vala.CCodeConstant get_dbus_timeout (Vala.Symbol symbol); public override void register_dbus_info (Vala.CCodeBlock block, Vala.ObjectTypeSymbol sym); public override void visit_interface (Vala.Interface iface); public override void visit_method_call (Vala.MethodCall expr); } [CCode (cheader_filename = "valacodegen.h")] public class GDBusModule : Vala.GVariantModule { public GDBusModule (); public bool dbus_method_uses_file_descriptor (Vala.Method method); public static string dbus_result_name (Vala.Method m); public static string? get_dbus_name (Vala.TypeSymbol symbol); public static string get_dbus_name_for_member (Vala.Symbol symbol); public static int get_dbus_timeout_for_member (Vala.Symbol symbol); protected Vala.CCodeExpression get_interface_info (Vala.ObjectTypeSymbol sym); public static bool is_dbus_no_reply (Vala.Method m); public static bool is_dbus_visible (Vala.CodeNode node); public void receive_dbus_value (Vala.DataType type, Vala.CCodeExpression message_expr, Vala.CCodeExpression iter_expr, Vala.CCodeExpression target_expr, Vala.Symbol? sym, Vala.CCodeExpression? error_expr = null, out bool may_fail = null); public void send_dbus_value (Vala.DataType type, Vala.CCodeExpression builder_expr, Vala.CCodeExpression expr, Vala.Symbol? sym); public override void visit_class (Vala.Class cl); public override void visit_error_domain (Vala.ErrorDomain edomain); public override void visit_interface (Vala.Interface iface); } [CCode (cheader_filename = "valacodegen.h")] public class GDBusServerModule : Vala.GDBusClientModule { public GDBusServerModule (); public override void generate_class_declaration (Vala.Class cl, Vala.CCodeFile decl_space); public override void generate_interface_declaration (Vala.Interface iface, Vala.CCodeFile decl_space); public override void register_dbus_info (Vala.CCodeBlock block, Vala.ObjectTypeSymbol sym); public override void visit_class (Vala.Class cl); public override void visit_interface (Vala.Interface iface); public override void visit_method_call (Vala.MethodCall expr); } [CCode (cheader_filename = "valacodegen.h")] public class GErrorModule : Vala.CCodeDelegateModule { public GErrorModule (); public override void add_simple_check (Vala.CodeNode node, bool always_fails = false); protected override void append_scope_free (Vala.Symbol sym, Vala.CodeNode? stop_at = null); public override void generate_error_domain_declaration (Vala.ErrorDomain edomain, Vala.CCodeFile decl_space); public virtual void return_with_exception (Vala.CCodeExpression error_expr); public override void visit_catch_clause (Vala.CatchClause clause); public override void visit_error_domain (Vala.ErrorDomain edomain); public override void visit_throw_statement (Vala.ThrowStatement stmt); public override void visit_try_statement (Vala.TryStatement stmt); } [CCode (cheader_filename = "valacodegen.h")] public class GIRWriter : Vala.CodeVisitor { public GIRWriter (); protected virtual string? get_class_comment (Vala.Class c); protected virtual string? get_constant_comment (Vala.Constant c); protected virtual string? get_delegate_comment (Vala.Delegate cb); protected virtual string? get_delegate_return_comment (Vala.Delegate cb); protected virtual string? get_enum_comment (Vala.Enum en); protected virtual string? get_enum_value_comment (Vala.EnumValue ev); protected virtual string? get_error_code_comment (Vala.ErrorCode ecode); protected virtual string? get_error_domain_comment (Vala.ErrorDomain edomain); protected virtual string? get_field_comment (Vala.Field f); protected virtual string? get_interface_comment (Vala.Interface iface); protected virtual string? get_method_comment (Vala.Method m); protected virtual string? get_method_return_comment (Vala.Method m); protected virtual string? get_parameter_comment (Vala.Parameter param); protected virtual string? get_property_comment (Vala.Property prop); protected virtual string? get_signal_comment (Vala.Signal sig); protected virtual string? get_signal_return_comment (Vala.Signal sig); protected virtual string? get_struct_comment (Vala.Struct st); public override void visit_class (Vala.Class cl); public override void visit_constant (Vala.Constant c); public override void visit_creation_method (Vala.CreationMethod m); public override void visit_delegate (Vala.Delegate cb); public override void visit_enum (Vala.Enum en); public override void visit_enum_value (Vala.EnumValue ev); public override void visit_error_code (Vala.ErrorCode ecode); public override void visit_error_domain (Vala.ErrorDomain edomain); public override void visit_field (Vala.Field f); public override void visit_interface (Vala.Interface iface); public override void visit_method (Vala.Method m); public override void visit_namespace (Vala.Namespace ns); public override void visit_property (Vala.Property prop); public override void visit_signal (Vala.Signal sig); public override void visit_struct (Vala.Struct st); public void write_file (Vala.CodeContext context, string directory, string gir_filename, string gir_namespace, string gir_version, string package, string? gir_shared_library = null); public void write_includes (); } [CCode (cheader_filename = "valacodegen.h")] public class GObjectModule : Vala.GTypeModule { public GObjectModule (); public override void generate_class_init (Vala.Class cl); public override string get_dynamic_property_getter_cname (Vala.DynamicProperty prop); public override string get_dynamic_property_setter_cname (Vala.DynamicProperty prop); public override string get_dynamic_signal_cname (Vala.DynamicSignal node); public override string get_dynamic_signal_connect_after_wrapper_name (Vala.DynamicSignal sig); public override string get_dynamic_signal_connect_wrapper_name (Vala.DynamicSignal sig); public override bool is_gobject_property (Vala.Property prop); public override void visit_class (Vala.Class cl); public override void visit_constructor (Vala.Constructor c); public override void visit_method_call (Vala.MethodCall expr); public override void visit_property (Vala.Property prop); } [CCode (cheader_filename = "valacodegen.h")] public class GSignalModule : Vala.GObjectModule { public GSignalModule (); public override Vala.CCodeExpression get_signal_creation (Vala.Signal sig, Vala.TypeSymbol type); public override void visit_assignment (Vala.Assignment assignment); public override void visit_element_access (Vala.ElementAccess expr); public override void visit_member_access (Vala.MemberAccess expr); public override void visit_method_call (Vala.MethodCall expr); public override void visit_signal (Vala.Signal sig); } [CCode (cheader_filename = "valacodegen.h")] public class GTypeModule : Vala.GErrorModule { public GTypeModule (); public override void create_type_check_statement (Vala.CodeNode method_node, Vala.DataType ret_type, Vala.TypeSymbol t, bool non_null, string var_name); public virtual void end_instance_init (Vala.Class cl); public override void generate_class_declaration (Vala.Class cl, Vala.CCodeFile decl_space); public virtual void generate_class_init (Vala.Class cl); public override void generate_class_struct_declaration (Vala.Class cl, Vala.CCodeFile decl_space); public override void generate_interface_declaration (Vala.Interface iface, Vala.CCodeFile decl_space); public override Vala.CCodeParameter generate_parameter (Vala.Parameter param, Vala.CCodeFile decl_space, Vala.Map cparam_map, Vala.Map? carg_map); public virtual void generate_virtual_method_declaration (Vala.Method m, Vala.CCodeFile decl_space, Vala.CCodeStruct type_struct); public override Vala.CCodeExpression get_param_spec (Vala.Property prop); public override Vala.CCodeExpression get_param_spec_cexpression (Vala.Property prop); public override void visit_class (Vala.Class cl); public override void visit_enum (Vala.Enum en); public override void visit_interface (Vala.Interface iface); public override void visit_method_call (Vala.MethodCall expr); public override void visit_property (Vala.Property prop); public override void visit_struct (Vala.Struct st); } [CCode (cheader_filename = "valacodegen.h")] public class GVariantModule : Vala.GAsyncModule { public GVariantModule (); public override Vala.CCodeExpression? deserialize_expression (Vala.DataType type, Vala.CCodeExpression variant_expr, Vala.CCodeExpression? expr, Vala.CCodeExpression? error_expr = null, out bool may_fail = null); public override bool generate_enum_declaration (Vala.Enum en, Vala.CCodeFile decl_space); public Vala.CCodeFunction generate_enum_from_string_function (Vala.Enum en); public Vala.CCodeFunction generate_enum_from_string_function_declaration (Vala.Enum en); public Vala.CCodeFunction generate_enum_to_string_function (Vala.Enum en); public Vala.CCodeFunction generate_enum_to_string_function_declaration (Vala.Enum en); public static string? get_dbus_signature (Vala.Symbol symbol); public static string? get_type_signature (Vala.DataType datatype, Vala.Symbol? symbol = null); public void read_expression (Vala.DataType type, Vala.CCodeExpression iter_expr, Vala.CCodeExpression target_expr, Vala.Symbol? sym, Vala.CCodeExpression? error_expr = null, out bool may_fail = null); public override Vala.CCodeExpression? serialize_expression (Vala.DataType type, Vala.CCodeExpression expr); public override void visit_enum (Vala.Enum en); public void write_expression (Vala.DataType type, Vala.CCodeExpression builder_expr, Vala.CCodeExpression expr, Vala.Symbol? sym); } [CCode (cheader_filename = "valacodegen.h")] public class GtkModule : Vala.GSignalModule { public GtkModule (); public override void end_instance_init (Vala.Class cl); public override void generate_class_init (Vala.Class cl); public override void visit_field (Vala.Field f); public override void visit_method (Vala.Method m); public override void visit_property (Vala.Property prop); } [CCode (cheader_filename = "valacodegen.h")] public class InterfaceRegisterFunction : Vala.TypeRegisterFunction { public InterfaceRegisterFunction (Vala.Interface iface); public override Vala.SymbolAccessibility get_accessibility (); public override string get_base_finalize_func_name (); public override string get_base_init_func_name (); public override string get_class_finalize_func_name (); public override string get_class_init_func_name (); public override string get_instance_init_func_name (); public override string get_instance_struct_size (); public override string get_parent_type_name (); public override Vala.TypeSymbol get_type_declaration (); public override void get_type_interface_init_statements (Vala.CodeContext context, Vala.CCodeBlock block, bool plugin); public override string get_type_struct_name (); public Vala.Interface interface_reference { get; set; } } [CCode (cheader_filename = "valacodegen.h")] public class StructRegisterFunction : Vala.TypeRegisterFunction { public StructRegisterFunction (Vala.Struct st); public override Vala.SymbolAccessibility get_accessibility (); public override Vala.TypeSymbol get_type_declaration (); public Vala.Struct struct_reference { get; set; } } [CCode (cheader_filename = "valacodegen.h")] public abstract class TypeRegisterFunction { public TypeRegisterFunction (); public abstract Vala.SymbolAccessibility get_accessibility (); public virtual string get_base_finalize_func_name (); public virtual string get_base_init_func_name (); public virtual string get_class_finalize_func_name (); public virtual string get_class_init_func_name (); public Vala.CCodeFragment get_declaration (); public Vala.CCodeFragment get_definition (); public virtual string? get_gtype_value_table_collect_value_function_name (); public virtual string? get_gtype_value_table_copy_function_name (); public virtual string? get_gtype_value_table_free_function_name (); public virtual string? get_gtype_value_table_init_function_name (); public virtual string? get_gtype_value_table_lcopy_value_function_name (); public virtual string? get_gtype_value_table_peek_pointer_function_name (); public virtual string get_instance_init_func_name (); public virtual string get_instance_struct_size (); public virtual string get_parent_type_name (); public Vala.CCodeFragment get_source_declaration (); public abstract Vala.TypeSymbol get_type_declaration (); public virtual string get_type_flags (); public virtual Vala.CCodeFragment get_type_interface_init_declaration (); public virtual void get_type_interface_init_statements (Vala.CodeContext context, Vala.CCodeBlock block, bool plugin); public virtual string get_type_struct_name (); public void init_from_type (Vala.CodeContext context, bool plugin, bool declaration_only); } [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_array_length (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string? get_ccode_array_length_expr (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string? get_ccode_array_length_name (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static double get_ccode_array_length_pos (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string? get_ccode_array_length_type (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_array_null_terminated (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_concrete_accessor (Vala.Property p); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_const_name (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_constructv_name (Vala.CreationMethod m); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_copy_function (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_default_value (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_delegate_target (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_delegate_target_name (Vala.Variable variable); [CCode (cheader_filename = "valacodegen.h")] public static double get_ccode_delegate_target_pos (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_destroy_function (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static double get_ccode_destroy_notify_pos (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string? get_ccode_dup_function (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_finish_instance (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_finish_name (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_finish_real_name (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_finish_vfunc_name (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_free_function (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_free_function_address_of (Vala.Class cl); [CCode (cheader_filename = "valacodegen.h")] public static double get_ccode_generic_type_pos (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_get_value_function (Vala.CodeNode sym); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_has_copy_function (Vala.Struct st); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_has_destroy_function (Vala.Struct st); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_has_generic_type_parameter (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_has_new_function (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_has_type_id (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_header_filenames (Vala.Symbol sym); [CCode (cheader_filename = "valacodegen.h")] public static double get_ccode_instance_pos (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_is_gboxed (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_lower_case_name (Vala.CodeNode node, string? infix = null); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_lower_case_prefix (Vala.Symbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_lower_case_suffix (Vala.Symbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_marshaller_type_name (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_name (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_no_accessor_method (Vala.Property p); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_param_spec_function (Vala.CodeNode sym); [CCode (cheader_filename = "valacodegen.h")] public static double get_ccode_pos (Vala.Parameter param); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_prefix (Vala.Symbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_quark_name (Vala.ErrorDomain edomain); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_real_name (Vala.Symbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_ref_function (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_ref_function_void (Vala.Class cl); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_ref_sink_function (Vala.ObjectTypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_sentinel (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_set_value_function (Vala.CodeNode sym); [CCode (cheader_filename = "valacodegen.h")] public static bool get_ccode_simple_generics (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_take_value_function (Vala.CodeNode sym); [CCode (cheader_filename = "valacodegen.h")] public static string? get_ccode_type (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_type_check_function (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_type_id (Vala.CodeNode node); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_type_name (Vala.Interface iface); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_unref_function (Vala.ObjectTypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_upper_case_name (Vala.Symbol sym, string? infix = null); [CCode (cheader_filename = "valacodegen.h")] public static string get_ccode_vfunc_name (Vala.Method m); [CCode (cheader_filename = "valacodegen.h")] public static bool is_reference_counting (Vala.TypeSymbol sym); } valabind-1.5.0/private/gee.vapi000066400000000000000000000105341323123274000163700ustar00rootroot00000000000000/* gee.vapi generated by valac, do not modify. */ /* namespace Vala { [CCode (cheader_filename = "valagee.h")] public class ArrayList : Vala.List { public ArrayList (GLib.EqualFunc equal_func = GLib.direct_equal); public override bool add (G item); public override void clear (); public override bool contains (G item); public override G @get (int index); public override GLib.Type get_element_type (); public override int index_of (G item); public override void insert (int index, G item); public override Vala.Iterator iterator (); public override bool remove (G item); public override G remove_at (int index); public override void @set (int index, G item); public GLib.EqualFunc equal_func { set; } public override int size { get; } } [CCode (cheader_filename = "valagee.h")] public abstract class Collection : Vala.Iterable { public Collection (); public abstract bool add (G item); public virtual bool add_all (Vala.Collection collection); public abstract void clear (); public abstract bool contains (G item); public abstract bool remove (G item); public virtual G[] to_array (); public virtual bool is_empty { get; } public abstract int size { get; } } [CCode (cheader_filename = "valagee.h")] public class HashMap : Vala.Map { public HashMap (GLib.HashFunc key_hash_func = GLib.direct_hash, GLib.EqualFunc key_equal_func = GLib.direct_equal, GLib.EqualFunc value_equal_func = GLib.direct_equal); public override void clear (); public override bool contains (K key); public override V @get (K key); public override Vala.Set get_keys (); public override Vala.Collection get_values (); public override Vala.MapIterator map_iterator (); public override bool remove (K key); public override void @set (K key, V value); public GLib.EqualFunc key_equal_func { set; } public GLib.HashFunc key_hash_func { set; } public override int size { get; } public GLib.EqualFunc value_equal_func { set; } } [CCode (cheader_filename = "valagee.h")] public class HashSet : Vala.Set { public HashSet (GLib.HashFunc hash_func = GLib.direct_hash, GLib.EqualFunc equal_func = GLib.direct_equal); public override bool add (G key); public override void clear (); public override bool contains (G key); public override GLib.Type get_element_type (); public override Vala.Iterator iterator (); public override bool remove (G key); public GLib.EqualFunc equal_func { set; } public GLib.HashFunc hash_func { set; } public override int size { get; } } [CCode (cheader_filename = "valagee.h")] public abstract class Iterable { public Iterable (); public abstract GLib.Type get_element_type (); public abstract Vala.Iterator iterator (); } [CCode (cheader_filename = "valagee.h")] public abstract class Iterator { public Iterator (); public abstract G @get (); public abstract bool has_next (); public abstract bool next (); public abstract void remove (); public abstract bool valid { get; } } [CCode (cheader_filename = "valagee.h")] public abstract class List : Vala.Collection { public List (); public virtual G first (); public abstract G @get (int index); public abstract int index_of (G item); public abstract void insert (int index, G item); public virtual void insert_all (int index, Vala.Collection collection); public virtual G last (); public abstract G remove_at (int index); public abstract void @set (int index, G item); public virtual void sort (owned GLib.CompareDataFunc compare_func); } [CCode (cheader_filename = "valagee.h")] public abstract class Map { public Map (); public abstract void clear (); public abstract bool contains (K key); public abstract V @get (K key); public abstract Vala.Set get_keys (); public abstract Vala.Collection get_values (); public abstract Vala.MapIterator map_iterator (); public abstract bool remove (K key); public abstract void @set (K key, V value); public abstract int size { get; } } [CCode (cheader_filename = "valagee.h")] public abstract class MapIterator { public MapIterator (); public abstract K get_key (); public abstract V get_value (); public abstract bool next (); } [CCode (cheader_filename = "valagee.h")] public abstract class Set : Vala.Collection { public Set (); } } */ valabind-1.5.0/private/vala.h000066400000000000000000011274371323123274000160570ustar00rootroot00000000000000/* vala.h generated by valac, the Vala compiler, do not modify */ #ifndef __VALA_H__ #define __VALA_H__ #include #include #include #include #include #include #include G_BEGIN_DECLS #define VALA_TYPE_CODE_NODE (vala_code_node_get_type ()) #define VALA_CODE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_NODE, ValaCodeNode)) #define VALA_CODE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_NODE, ValaCodeNodeClass)) #define VALA_IS_CODE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_NODE)) #define VALA_IS_CODE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_NODE)) #define VALA_CODE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_NODE, ValaCodeNodeClass)) typedef struct _ValaCodeNode ValaCodeNode; typedef struct _ValaCodeNodeClass ValaCodeNodeClass; typedef struct _ValaCodeNodePrivate ValaCodeNodePrivate; #define VALA_TYPE_CODE_VISITOR (vala_code_visitor_get_type ()) #define VALA_CODE_VISITOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_VISITOR, ValaCodeVisitor)) #define VALA_CODE_VISITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_VISITOR, ValaCodeVisitorClass)) #define VALA_IS_CODE_VISITOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_VISITOR)) #define VALA_IS_CODE_VISITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_VISITOR)) #define VALA_CODE_VISITOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_VISITOR, ValaCodeVisitorClass)) typedef struct _ValaCodeVisitor ValaCodeVisitor; typedef struct _ValaCodeVisitorClass ValaCodeVisitorClass; #define VALA_TYPE_CODE_CONTEXT (vala_code_context_get_type ()) #define VALA_CODE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_CONTEXT, ValaCodeContext)) #define VALA_CODE_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_CONTEXT, ValaCodeContextClass)) #define VALA_IS_CODE_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_CONTEXT)) #define VALA_IS_CODE_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_CONTEXT)) #define VALA_CODE_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_CONTEXT, ValaCodeContextClass)) typedef struct _ValaCodeContext ValaCodeContext; typedef struct _ValaCodeContextClass ValaCodeContextClass; #define VALA_TYPE_CODE_GENERATOR (vala_code_generator_get_type ()) #define VALA_CODE_GENERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_GENERATOR, ValaCodeGenerator)) #define VALA_CODE_GENERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_GENERATOR, ValaCodeGeneratorClass)) #define VALA_IS_CODE_GENERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_GENERATOR)) #define VALA_IS_CODE_GENERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_GENERATOR)) #define VALA_CODE_GENERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_GENERATOR, ValaCodeGeneratorClass)) typedef struct _ValaCodeGenerator ValaCodeGenerator; typedef struct _ValaCodeGeneratorClass ValaCodeGeneratorClass; #define VALA_TYPE_DATA_TYPE (vala_data_type_get_type ()) #define VALA_DATA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DATA_TYPE, ValaDataType)) #define VALA_DATA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DATA_TYPE, ValaDataTypeClass)) #define VALA_IS_DATA_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DATA_TYPE)) #define VALA_IS_DATA_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DATA_TYPE)) #define VALA_DATA_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DATA_TYPE, ValaDataTypeClass)) typedef struct _ValaDataType ValaDataType; typedef struct _ValaDataTypeClass ValaDataTypeClass; #define VALA_TYPE_EXPRESSION (vala_expression_get_type ()) #define VALA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_EXPRESSION, ValaExpression)) #define VALA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_EXPRESSION, ValaExpressionClass)) #define VALA_IS_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_EXPRESSION)) #define VALA_IS_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_EXPRESSION)) #define VALA_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_EXPRESSION, ValaExpressionClass)) typedef struct _ValaExpression ValaExpression; typedef struct _ValaExpressionClass ValaExpressionClass; #define VALA_TYPE_SYMBOL (vala_symbol_get_type ()) #define VALA_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SYMBOL, ValaSymbol)) #define VALA_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SYMBOL, ValaSymbolClass)) #define VALA_IS_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SYMBOL)) #define VALA_IS_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SYMBOL)) #define VALA_SYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SYMBOL, ValaSymbolClass)) typedef struct _ValaSymbol ValaSymbol; typedef struct _ValaSymbolClass ValaSymbolClass; #define VALA_TYPE_VARIABLE (vala_variable_get_type ()) #define VALA_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_VARIABLE, ValaVariable)) #define VALA_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_VARIABLE, ValaVariableClass)) #define VALA_IS_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_VARIABLE)) #define VALA_IS_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_VARIABLE)) #define VALA_VARIABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_VARIABLE, ValaVariableClass)) typedef struct _ValaVariable ValaVariable; typedef struct _ValaVariableClass ValaVariableClass; #define VALA_TYPE_ATTRIBUTE (vala_attribute_get_type ()) #define VALA_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ATTRIBUTE, ValaAttribute)) #define VALA_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ATTRIBUTE, ValaAttributeClass)) #define VALA_IS_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ATTRIBUTE)) #define VALA_IS_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ATTRIBUTE)) #define VALA_ATTRIBUTE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ATTRIBUTE, ValaAttributeClass)) typedef struct _ValaAttribute ValaAttribute; typedef struct _ValaAttributeClass ValaAttributeClass; typedef struct _ValaExpressionPrivate ValaExpressionPrivate; #define VALA_TYPE_ADDRESSOF_EXPRESSION (vala_addressof_expression_get_type ()) #define VALA_ADDRESSOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpression)) #define VALA_ADDRESSOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpressionClass)) #define VALA_IS_ADDRESSOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION)) #define VALA_IS_ADDRESSOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ADDRESSOF_EXPRESSION)) #define VALA_ADDRESSOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ADDRESSOF_EXPRESSION, ValaAddressofExpressionClass)) typedef struct _ValaAddressofExpression ValaAddressofExpression; typedef struct _ValaAddressofExpressionClass ValaAddressofExpressionClass; typedef struct _ValaAddressofExpressionPrivate ValaAddressofExpressionPrivate; #define VALA_TYPE_SOURCE_REFERENCE (vala_source_reference_get_type ()) #define VALA_SOURCE_REFERENCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SOURCE_REFERENCE, ValaSourceReference)) #define VALA_SOURCE_REFERENCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SOURCE_REFERENCE, ValaSourceReferenceClass)) #define VALA_IS_SOURCE_REFERENCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SOURCE_REFERENCE)) #define VALA_IS_SOURCE_REFERENCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SOURCE_REFERENCE)) #define VALA_SOURCE_REFERENCE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SOURCE_REFERENCE, ValaSourceReferenceClass)) typedef struct _ValaSourceReference ValaSourceReference; typedef struct _ValaSourceReferenceClass ValaSourceReferenceClass; typedef struct _ValaSymbolPrivate ValaSymbolPrivate; #define VALA_TYPE_NAMESPACE (vala_namespace_get_type ()) #define VALA_NAMESPACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NAMESPACE, ValaNamespace)) #define VALA_NAMESPACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NAMESPACE, ValaNamespaceClass)) #define VALA_IS_NAMESPACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NAMESPACE)) #define VALA_IS_NAMESPACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NAMESPACE)) #define VALA_NAMESPACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NAMESPACE, ValaNamespaceClass)) typedef struct _ValaNamespace ValaNamespace; typedef struct _ValaNamespaceClass ValaNamespaceClass; #define VALA_TYPE_TYPESYMBOL (vala_typesymbol_get_type ()) #define VALA_TYPESYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) #define VALA_TYPESYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPESYMBOL, ValaTypeSymbolClass)) #define VALA_IS_TYPESYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPESYMBOL)) #define VALA_IS_TYPESYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPESYMBOL)) #define VALA_TYPESYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPESYMBOL, ValaTypeSymbolClass)) typedef struct _ValaTypeSymbol ValaTypeSymbol; typedef struct _ValaTypeSymbolClass ValaTypeSymbolClass; #define VALA_TYPE_OBJECT_TYPE_SYMBOL (vala_object_type_symbol_get_type ()) #define VALA_OBJECT_TYPE_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol)) #define VALA_OBJECT_TYPE_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbolClass)) #define VALA_IS_OBJECT_TYPE_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_OBJECT_TYPE_SYMBOL)) #define VALA_IS_OBJECT_TYPE_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_OBJECT_TYPE_SYMBOL)) #define VALA_OBJECT_TYPE_SYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbolClass)) typedef struct _ValaObjectTypeSymbol ValaObjectTypeSymbol; typedef struct _ValaObjectTypeSymbolClass ValaObjectTypeSymbolClass; #define VALA_TYPE_CLASS (vala_class_get_type ()) #define VALA_CLASS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CLASS, ValaClass)) #define VALA_CLASS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CLASS, ValaClassClass)) #define VALA_IS_CLASS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CLASS)) #define VALA_IS_CLASS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CLASS)) #define VALA_CLASS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CLASS, ValaClassClass)) typedef struct _ValaClass ValaClass; typedef struct _ValaClassClass ValaClassClass; #define VALA_TYPE_INTERFACE (vala_interface_get_type ()) #define VALA_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTERFACE, ValaInterface)) #define VALA_INTERFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTERFACE, ValaInterfaceClass)) #define VALA_IS_INTERFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTERFACE)) #define VALA_IS_INTERFACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTERFACE)) #define VALA_INTERFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTERFACE, ValaInterfaceClass)) typedef struct _ValaInterface ValaInterface; typedef struct _ValaInterfaceClass ValaInterfaceClass; #define VALA_TYPE_STRUCT (vala_struct_get_type ()) #define VALA_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRUCT, ValaStruct)) #define VALA_STRUCT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRUCT, ValaStructClass)) #define VALA_IS_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRUCT)) #define VALA_IS_STRUCT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRUCT)) #define VALA_STRUCT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRUCT, ValaStructClass)) typedef struct _ValaStruct ValaStruct; typedef struct _ValaStructClass ValaStructClass; #define VALA_TYPE_ENUM (vala_enum_get_type ()) #define VALA_ENUM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM, ValaEnum)) #define VALA_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM, ValaEnumClass)) #define VALA_IS_ENUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM)) #define VALA_IS_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM)) #define VALA_ENUM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM, ValaEnumClass)) typedef struct _ValaEnum ValaEnum; typedef struct _ValaEnumClass ValaEnumClass; #define VALA_TYPE_ERROR_DOMAIN (vala_error_domain_get_type ()) #define VALA_ERROR_DOMAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)) #define VALA_ERROR_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomainClass)) #define VALA_IS_ERROR_DOMAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ERROR_DOMAIN)) #define VALA_IS_ERROR_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ERROR_DOMAIN)) #define VALA_ERROR_DOMAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomainClass)) typedef struct _ValaErrorDomain ValaErrorDomain; typedef struct _ValaErrorDomainClass ValaErrorDomainClass; #define VALA_TYPE_DELEGATE (vala_delegate_get_type ()) #define VALA_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DELEGATE, ValaDelegate)) #define VALA_DELEGATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DELEGATE, ValaDelegateClass)) #define VALA_IS_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DELEGATE)) #define VALA_IS_DELEGATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DELEGATE)) #define VALA_DELEGATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DELEGATE, ValaDelegateClass)) typedef struct _ValaDelegate ValaDelegate; typedef struct _ValaDelegateClass ValaDelegateClass; #define VALA_TYPE_CONSTANT (vala_constant_get_type ()) #define VALA_CONSTANT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONSTANT, ValaConstant)) #define VALA_CONSTANT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONSTANT, ValaConstantClass)) #define VALA_IS_CONSTANT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONSTANT)) #define VALA_IS_CONSTANT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONSTANT)) #define VALA_CONSTANT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONSTANT, ValaConstantClass)) typedef struct _ValaConstant ValaConstant; typedef struct _ValaConstantClass ValaConstantClass; #define VALA_TYPE_FIELD (vala_field_get_type ()) #define VALA_FIELD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FIELD, ValaField)) #define VALA_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FIELD, ValaFieldClass)) #define VALA_IS_FIELD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FIELD)) #define VALA_IS_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FIELD)) #define VALA_FIELD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FIELD, ValaFieldClass)) typedef struct _ValaField ValaField; typedef struct _ValaFieldClass ValaFieldClass; #define VALA_TYPE_SUBROUTINE (vala_subroutine_get_type ()) #define VALA_SUBROUTINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SUBROUTINE, ValaSubroutine)) #define VALA_SUBROUTINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SUBROUTINE, ValaSubroutineClass)) #define VALA_IS_SUBROUTINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SUBROUTINE)) #define VALA_IS_SUBROUTINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SUBROUTINE)) #define VALA_SUBROUTINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SUBROUTINE, ValaSubroutineClass)) typedef struct _ValaSubroutine ValaSubroutine; typedef struct _ValaSubroutineClass ValaSubroutineClass; #define VALA_TYPE_METHOD (vala_method_get_type ()) #define VALA_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_METHOD, ValaMethod)) #define VALA_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_METHOD, ValaMethodClass)) #define VALA_IS_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_METHOD)) #define VALA_IS_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_METHOD)) #define VALA_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_METHOD, ValaMethodClass)) typedef struct _ValaMethod ValaMethod; typedef struct _ValaMethodClass ValaMethodClass; #define VALA_TYPE_PROPERTY (vala_property_get_type ()) #define VALA_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PROPERTY, ValaProperty)) #define VALA_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PROPERTY, ValaPropertyClass)) #define VALA_IS_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PROPERTY)) #define VALA_IS_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PROPERTY)) #define VALA_PROPERTY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PROPERTY, ValaPropertyClass)) typedef struct _ValaProperty ValaProperty; typedef struct _ValaPropertyClass ValaPropertyClass; #define VALA_TYPE_SIGNAL (vala_signal_get_type ()) #define VALA_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SIGNAL, ValaSignal)) #define VALA_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SIGNAL, ValaSignalClass)) #define VALA_IS_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SIGNAL)) #define VALA_IS_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SIGNAL)) #define VALA_SIGNAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SIGNAL, ValaSignalClass)) typedef struct _ValaSignal ValaSignal; typedef struct _ValaSignalClass ValaSignalClass; #define VALA_TYPE_CONSTRUCTOR (vala_constructor_get_type ()) #define VALA_CONSTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONSTRUCTOR, ValaConstructor)) #define VALA_CONSTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONSTRUCTOR, ValaConstructorClass)) #define VALA_IS_CONSTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONSTRUCTOR)) #define VALA_IS_CONSTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONSTRUCTOR)) #define VALA_CONSTRUCTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONSTRUCTOR, ValaConstructorClass)) typedef struct _ValaConstructor ValaConstructor; typedef struct _ValaConstructorClass ValaConstructorClass; #define VALA_TYPE_DESTRUCTOR (vala_destructor_get_type ()) #define VALA_DESTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DESTRUCTOR, ValaDestructor)) #define VALA_DESTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DESTRUCTOR, ValaDestructorClass)) #define VALA_IS_DESTRUCTOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DESTRUCTOR)) #define VALA_IS_DESTRUCTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DESTRUCTOR)) #define VALA_DESTRUCTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DESTRUCTOR, ValaDestructorClass)) typedef struct _ValaDestructor ValaDestructor; typedef struct _ValaDestructorClass ValaDestructorClass; typedef struct _ValaSubroutinePrivate ValaSubroutinePrivate; #define VALA_TYPE_CALLABLE (vala_callable_get_type ()) #define VALA_CALLABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CALLABLE, ValaCallable)) #define VALA_IS_CALLABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CALLABLE)) #define VALA_CALLABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), VALA_TYPE_CALLABLE, ValaCallableIface)) typedef struct _ValaCallable ValaCallable; typedef struct _ValaCallableIface ValaCallableIface; #define VALA_TYPE_PARAMETER (vala_parameter_get_type ()) #define VALA_PARAMETER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PARAMETER, ValaParameter)) #define VALA_PARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PARAMETER, ValaParameterClass)) #define VALA_IS_PARAMETER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PARAMETER)) #define VALA_IS_PARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PARAMETER)) #define VALA_PARAMETER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PARAMETER, ValaParameterClass)) typedef struct _ValaParameter ValaParameter; typedef struct _ValaParameterClass ValaParameterClass; typedef struct _ValaMethodPrivate ValaMethodPrivate; #define VALA_TYPE_ARRAY_COPY_METHOD (vala_array_copy_method_get_type ()) #define VALA_ARRAY_COPY_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_COPY_METHOD, ValaArrayCopyMethod)) #define VALA_ARRAY_COPY_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_COPY_METHOD, ValaArrayCopyMethodClass)) #define VALA_IS_ARRAY_COPY_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_COPY_METHOD)) #define VALA_IS_ARRAY_COPY_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_COPY_METHOD)) #define VALA_ARRAY_COPY_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_COPY_METHOD, ValaArrayCopyMethodClass)) typedef struct _ValaArrayCopyMethod ValaArrayCopyMethod; typedef struct _ValaArrayCopyMethodClass ValaArrayCopyMethodClass; typedef struct _ValaArrayCopyMethodPrivate ValaArrayCopyMethodPrivate; #define VALA_TYPE_ARRAY_CREATION_EXPRESSION (vala_array_creation_expression_get_type ()) #define VALA_ARRAY_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression)) #define VALA_ARRAY_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpressionClass)) #define VALA_IS_ARRAY_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION)) #define VALA_IS_ARRAY_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_CREATION_EXPRESSION)) #define VALA_ARRAY_CREATION_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpressionClass)) typedef struct _ValaArrayCreationExpression ValaArrayCreationExpression; typedef struct _ValaArrayCreationExpressionClass ValaArrayCreationExpressionClass; typedef struct _ValaArrayCreationExpressionPrivate ValaArrayCreationExpressionPrivate; #define VALA_TYPE_INITIALIZER_LIST (vala_initializer_list_get_type ()) #define VALA_INITIALIZER_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INITIALIZER_LIST, ValaInitializerList)) #define VALA_INITIALIZER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INITIALIZER_LIST, ValaInitializerListClass)) #define VALA_IS_INITIALIZER_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INITIALIZER_LIST)) #define VALA_IS_INITIALIZER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INITIALIZER_LIST)) #define VALA_INITIALIZER_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INITIALIZER_LIST, ValaInitializerListClass)) typedef struct _ValaInitializerList ValaInitializerList; typedef struct _ValaInitializerListClass ValaInitializerListClass; typedef struct _ValaVariablePrivate ValaVariablePrivate; #define VALA_TYPE_LOCKABLE (vala_lockable_get_type ()) #define VALA_LOCKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LOCKABLE, ValaLockable)) #define VALA_IS_LOCKABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LOCKABLE)) #define VALA_LOCKABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), VALA_TYPE_LOCKABLE, ValaLockableIface)) typedef struct _ValaLockable ValaLockable; typedef struct _ValaLockableIface ValaLockableIface; typedef struct _ValaFieldPrivate ValaFieldPrivate; #define VALA_TYPE_ARRAY_LENGTH_FIELD (vala_array_length_field_get_type ()) #define VALA_ARRAY_LENGTH_FIELD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_LENGTH_FIELD, ValaArrayLengthField)) #define VALA_ARRAY_LENGTH_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_LENGTH_FIELD, ValaArrayLengthFieldClass)) #define VALA_IS_ARRAY_LENGTH_FIELD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_LENGTH_FIELD)) #define VALA_IS_ARRAY_LENGTH_FIELD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_LENGTH_FIELD)) #define VALA_ARRAY_LENGTH_FIELD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_LENGTH_FIELD, ValaArrayLengthFieldClass)) typedef struct _ValaArrayLengthField ValaArrayLengthField; typedef struct _ValaArrayLengthFieldClass ValaArrayLengthFieldClass; typedef struct _ValaArrayLengthFieldPrivate ValaArrayLengthFieldPrivate; #define VALA_TYPE_ARRAY_MOVE_METHOD (vala_array_move_method_get_type ()) #define VALA_ARRAY_MOVE_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_MOVE_METHOD, ValaArrayMoveMethod)) #define VALA_ARRAY_MOVE_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_MOVE_METHOD, ValaArrayMoveMethodClass)) #define VALA_IS_ARRAY_MOVE_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_MOVE_METHOD)) #define VALA_IS_ARRAY_MOVE_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_MOVE_METHOD)) #define VALA_ARRAY_MOVE_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_MOVE_METHOD, ValaArrayMoveMethodClass)) typedef struct _ValaArrayMoveMethod ValaArrayMoveMethod; typedef struct _ValaArrayMoveMethodClass ValaArrayMoveMethodClass; typedef struct _ValaArrayMoveMethodPrivate ValaArrayMoveMethodPrivate; #define VALA_TYPE_ARRAY_RESIZE_METHOD (vala_array_resize_method_get_type ()) #define VALA_ARRAY_RESIZE_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_RESIZE_METHOD, ValaArrayResizeMethod)) #define VALA_ARRAY_RESIZE_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_RESIZE_METHOD, ValaArrayResizeMethodClass)) #define VALA_IS_ARRAY_RESIZE_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_RESIZE_METHOD)) #define VALA_IS_ARRAY_RESIZE_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_RESIZE_METHOD)) #define VALA_ARRAY_RESIZE_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_RESIZE_METHOD, ValaArrayResizeMethodClass)) typedef struct _ValaArrayResizeMethod ValaArrayResizeMethod; typedef struct _ValaArrayResizeMethodClass ValaArrayResizeMethodClass; typedef struct _ValaArrayResizeMethodPrivate ValaArrayResizeMethodPrivate; typedef struct _ValaDataTypePrivate ValaDataTypePrivate; #define VALA_TYPE_SCOPE (vala_scope_get_type ()) #define VALA_SCOPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SCOPE, ValaScope)) #define VALA_SCOPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SCOPE, ValaScopeClass)) #define VALA_IS_SCOPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SCOPE)) #define VALA_IS_SCOPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SCOPE)) #define VALA_SCOPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SCOPE, ValaScopeClass)) typedef struct _ValaScope ValaScope; typedef struct _ValaScopeClass ValaScopeClass; #define VALA_TYPE_TYPEPARAMETER (vala_typeparameter_get_type ()) #define VALA_TYPEPARAMETER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPEPARAMETER, ValaTypeParameter)) #define VALA_TYPEPARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPEPARAMETER, ValaTypeParameterClass)) #define VALA_IS_TYPEPARAMETER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPEPARAMETER)) #define VALA_IS_TYPEPARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPEPARAMETER)) #define VALA_TYPEPARAMETER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPEPARAMETER, ValaTypeParameterClass)) typedef struct _ValaTypeParameter ValaTypeParameter; typedef struct _ValaTypeParameterClass ValaTypeParameterClass; #define VALA_TYPE_REFERENCE_TYPE (vala_reference_type_get_type ()) #define VALA_REFERENCE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REFERENCE_TYPE, ValaReferenceType)) #define VALA_REFERENCE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REFERENCE_TYPE, ValaReferenceTypeClass)) #define VALA_IS_REFERENCE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REFERENCE_TYPE)) #define VALA_IS_REFERENCE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REFERENCE_TYPE)) #define VALA_REFERENCE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REFERENCE_TYPE, ValaReferenceTypeClass)) typedef struct _ValaReferenceType ValaReferenceType; typedef struct _ValaReferenceTypeClass ValaReferenceTypeClass; typedef struct _ValaReferenceTypePrivate ValaReferenceTypePrivate; #define VALA_TYPE_ARRAY_TYPE (vala_array_type_get_type ()) #define VALA_ARRAY_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_TYPE, ValaArrayType)) #define VALA_ARRAY_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_TYPE, ValaArrayTypeClass)) #define VALA_IS_ARRAY_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_TYPE)) #define VALA_IS_ARRAY_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_TYPE)) #define VALA_ARRAY_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_TYPE, ValaArrayTypeClass)) typedef struct _ValaArrayType ValaArrayType; typedef struct _ValaArrayTypeClass ValaArrayTypeClass; typedef struct _ValaArrayTypePrivate ValaArrayTypePrivate; #define VALA_TYPE_ASSIGNMENT (vala_assignment_get_type ()) #define VALA_ASSIGNMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ASSIGNMENT, ValaAssignment)) #define VALA_ASSIGNMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ASSIGNMENT, ValaAssignmentClass)) #define VALA_IS_ASSIGNMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ASSIGNMENT)) #define VALA_IS_ASSIGNMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ASSIGNMENT)) #define VALA_ASSIGNMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ASSIGNMENT, ValaAssignmentClass)) typedef struct _ValaAssignment ValaAssignment; typedef struct _ValaAssignmentClass ValaAssignmentClass; typedef struct _ValaAssignmentPrivate ValaAssignmentPrivate; #define VALA_TYPE_ASSIGNMENT_OPERATOR (vala_assignment_operator_get_type ()) typedef struct _ValaAttributePrivate ValaAttributePrivate; #define VALA_TYPE_BASE_ACCESS (vala_base_access_get_type ()) #define VALA_BASE_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BASE_ACCESS, ValaBaseAccess)) #define VALA_BASE_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BASE_ACCESS, ValaBaseAccessClass)) #define VALA_IS_BASE_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BASE_ACCESS)) #define VALA_IS_BASE_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BASE_ACCESS)) #define VALA_BASE_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BASE_ACCESS, ValaBaseAccessClass)) typedef struct _ValaBaseAccess ValaBaseAccess; typedef struct _ValaBaseAccessClass ValaBaseAccessClass; typedef struct _ValaBaseAccessPrivate ValaBaseAccessPrivate; #define VALA_TYPE_BASIC_BLOCK (vala_basic_block_get_type ()) #define VALA_BASIC_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BASIC_BLOCK, ValaBasicBlock)) #define VALA_BASIC_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BASIC_BLOCK, ValaBasicBlockClass)) #define VALA_IS_BASIC_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BASIC_BLOCK)) #define VALA_IS_BASIC_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BASIC_BLOCK)) #define VALA_BASIC_BLOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BASIC_BLOCK, ValaBasicBlockClass)) typedef struct _ValaBasicBlock ValaBasicBlock; typedef struct _ValaBasicBlockClass ValaBasicBlockClass; typedef struct _ValaBasicBlockPrivate ValaBasicBlockPrivate; #define VALA_TYPE_PHI_FUNCTION (vala_phi_function_get_type ()) #define VALA_PHI_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PHI_FUNCTION, ValaPhiFunction)) #define VALA_PHI_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PHI_FUNCTION, ValaPhiFunctionClass)) #define VALA_IS_PHI_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PHI_FUNCTION)) #define VALA_IS_PHI_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PHI_FUNCTION)) #define VALA_PHI_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PHI_FUNCTION, ValaPhiFunctionClass)) typedef struct _ValaPhiFunction ValaPhiFunction; typedef struct _ValaPhiFunctionClass ValaPhiFunctionClass; #define VALA_TYPE_BINARY_EXPRESSION (vala_binary_expression_get_type ()) #define VALA_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpression)) #define VALA_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpressionClass)) #define VALA_IS_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BINARY_EXPRESSION)) #define VALA_IS_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BINARY_EXPRESSION)) #define VALA_BINARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpressionClass)) typedef struct _ValaBinaryExpression ValaBinaryExpression; typedef struct _ValaBinaryExpressionClass ValaBinaryExpressionClass; typedef struct _ValaBinaryExpressionPrivate ValaBinaryExpressionPrivate; #define VALA_TYPE_BINARY_OPERATOR (vala_binary_operator_get_type ()) #define VALA_TYPE_STATEMENT (vala_statement_get_type ()) #define VALA_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STATEMENT, ValaStatement)) #define VALA_IS_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STATEMENT)) #define VALA_STATEMENT_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), VALA_TYPE_STATEMENT, ValaStatementIface)) typedef struct _ValaStatement ValaStatement; typedef struct _ValaStatementIface ValaStatementIface; #define VALA_TYPE_BLOCK (vala_block_get_type ()) #define VALA_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BLOCK, ValaBlock)) #define VALA_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BLOCK, ValaBlockClass)) #define VALA_IS_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BLOCK)) #define VALA_IS_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BLOCK)) #define VALA_BLOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BLOCK, ValaBlockClass)) typedef struct _ValaBlock ValaBlock; typedef struct _ValaBlockClass ValaBlockClass; typedef struct _ValaBlockPrivate ValaBlockPrivate; #define VALA_TYPE_LOCAL_VARIABLE (vala_local_variable_get_type ()) #define VALA_LOCAL_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable)) #define VALA_LOCAL_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariableClass)) #define VALA_IS_LOCAL_VARIABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LOCAL_VARIABLE)) #define VALA_IS_LOCAL_VARIABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LOCAL_VARIABLE)) #define VALA_LOCAL_VARIABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariableClass)) typedef struct _ValaLocalVariable ValaLocalVariable; typedef struct _ValaLocalVariableClass ValaLocalVariableClass; #define VALA_TYPE_LITERAL (vala_literal_get_type ()) #define VALA_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LITERAL, ValaLiteral)) #define VALA_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LITERAL, ValaLiteralClass)) #define VALA_IS_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LITERAL)) #define VALA_IS_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LITERAL)) #define VALA_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LITERAL, ValaLiteralClass)) typedef struct _ValaLiteral ValaLiteral; typedef struct _ValaLiteralClass ValaLiteralClass; typedef struct _ValaLiteralPrivate ValaLiteralPrivate; #define VALA_TYPE_BOOLEAN_LITERAL (vala_boolean_literal_get_type ()) #define VALA_BOOLEAN_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteral)) #define VALA_BOOLEAN_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteralClass)) #define VALA_IS_BOOLEAN_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BOOLEAN_LITERAL)) #define VALA_IS_BOOLEAN_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BOOLEAN_LITERAL)) #define VALA_BOOLEAN_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteralClass)) typedef struct _ValaBooleanLiteral ValaBooleanLiteral; typedef struct _ValaBooleanLiteralClass ValaBooleanLiteralClass; typedef struct _ValaBooleanLiteralPrivate ValaBooleanLiteralPrivate; #define VALA_TYPE_VALUE_TYPE (vala_value_type_get_type ()) #define VALA_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_VALUE_TYPE, ValaValueType)) #define VALA_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_VALUE_TYPE, ValaValueTypeClass)) #define VALA_IS_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_VALUE_TYPE)) #define VALA_IS_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_VALUE_TYPE)) #define VALA_VALUE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_VALUE_TYPE, ValaValueTypeClass)) typedef struct _ValaValueType ValaValueType; typedef struct _ValaValueTypeClass ValaValueTypeClass; typedef struct _ValaValueTypePrivate ValaValueTypePrivate; #define VALA_TYPE_BOOLEAN_TYPE (vala_boolean_type_get_type ()) #define VALA_BOOLEAN_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BOOLEAN_TYPE, ValaBooleanType)) #define VALA_BOOLEAN_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BOOLEAN_TYPE, ValaBooleanTypeClass)) #define VALA_IS_BOOLEAN_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BOOLEAN_TYPE)) #define VALA_IS_BOOLEAN_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BOOLEAN_TYPE)) #define VALA_BOOLEAN_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BOOLEAN_TYPE, ValaBooleanTypeClass)) typedef struct _ValaBooleanType ValaBooleanType; typedef struct _ValaBooleanTypeClass ValaBooleanTypeClass; typedef struct _ValaBooleanTypePrivate ValaBooleanTypePrivate; #define VALA_TYPE_BREAK_STATEMENT (vala_break_statement_get_type ()) #define VALA_BREAK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_BREAK_STATEMENT, ValaBreakStatement)) #define VALA_BREAK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_BREAK_STATEMENT, ValaBreakStatementClass)) #define VALA_IS_BREAK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_BREAK_STATEMENT)) #define VALA_IS_BREAK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_BREAK_STATEMENT)) #define VALA_BREAK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_BREAK_STATEMENT, ValaBreakStatementClass)) typedef struct _ValaBreakStatement ValaBreakStatement; typedef struct _ValaBreakStatementClass ValaBreakStatementClass; typedef struct _ValaBreakStatementPrivate ValaBreakStatementPrivate; #define VALA_TYPE_CALLABLE_TYPE (vala_callable_type_get_type ()) #define VALA_CALLABLE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CALLABLE_TYPE, ValaCallableType)) #define VALA_CALLABLE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CALLABLE_TYPE, ValaCallableTypeClass)) #define VALA_IS_CALLABLE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CALLABLE_TYPE)) #define VALA_IS_CALLABLE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CALLABLE_TYPE)) #define VALA_CALLABLE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CALLABLE_TYPE, ValaCallableTypeClass)) typedef struct _ValaCallableType ValaCallableType; typedef struct _ValaCallableTypeClass ValaCallableTypeClass; typedef struct _ValaCallableTypePrivate ValaCallableTypePrivate; #define VALA_TYPE_CAST_EXPRESSION (vala_cast_expression_get_type ()) #define VALA_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CAST_EXPRESSION, ValaCastExpression)) #define VALA_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CAST_EXPRESSION, ValaCastExpressionClass)) #define VALA_IS_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CAST_EXPRESSION)) #define VALA_IS_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CAST_EXPRESSION)) #define VALA_CAST_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CAST_EXPRESSION, ValaCastExpressionClass)) typedef struct _ValaCastExpression ValaCastExpression; typedef struct _ValaCastExpressionClass ValaCastExpressionClass; typedef struct _ValaCastExpressionPrivate ValaCastExpressionPrivate; #define VALA_TYPE_CATCH_CLAUSE (vala_catch_clause_get_type ()) #define VALA_CATCH_CLAUSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CATCH_CLAUSE, ValaCatchClause)) #define VALA_CATCH_CLAUSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CATCH_CLAUSE, ValaCatchClauseClass)) #define VALA_IS_CATCH_CLAUSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CATCH_CLAUSE)) #define VALA_IS_CATCH_CLAUSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CATCH_CLAUSE)) #define VALA_CATCH_CLAUSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CATCH_CLAUSE, ValaCatchClauseClass)) typedef struct _ValaCatchClause ValaCatchClause; typedef struct _ValaCatchClauseClass ValaCatchClauseClass; typedef struct _ValaCatchClausePrivate ValaCatchClausePrivate; #define VALA_TYPE_CHARACTER_LITERAL (vala_character_literal_get_type ()) #define VALA_CHARACTER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteral)) #define VALA_CHARACTER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteralClass)) #define VALA_IS_CHARACTER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CHARACTER_LITERAL)) #define VALA_IS_CHARACTER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CHARACTER_LITERAL)) #define VALA_CHARACTER_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteralClass)) typedef struct _ValaCharacterLiteral ValaCharacterLiteral; typedef struct _ValaCharacterLiteralClass ValaCharacterLiteralClass; typedef struct _ValaCharacterLiteralPrivate ValaCharacterLiteralPrivate; typedef struct _ValaTypeSymbolPrivate ValaTypeSymbolPrivate; typedef struct _ValaObjectTypeSymbolPrivate ValaObjectTypeSymbolPrivate; typedef struct _ValaClassPrivate ValaClassPrivate; #define VALA_TYPE_COMMENT (vala_comment_get_type ()) #define VALA_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_COMMENT, ValaComment)) #define VALA_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_COMMENT, ValaCommentClass)) #define VALA_IS_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_COMMENT)) #define VALA_IS_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_COMMENT)) #define VALA_COMMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_COMMENT, ValaCommentClass)) typedef struct _ValaComment ValaComment; typedef struct _ValaCommentClass ValaCommentClass; #define VALA_TYPE_CREATION_METHOD (vala_creation_method_get_type ()) #define VALA_CREATION_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CREATION_METHOD, ValaCreationMethod)) #define VALA_CREATION_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CREATION_METHOD, ValaCreationMethodClass)) #define VALA_IS_CREATION_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CREATION_METHOD)) #define VALA_IS_CREATION_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CREATION_METHOD)) #define VALA_CREATION_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CREATION_METHOD, ValaCreationMethodClass)) typedef struct _ValaCreationMethod ValaCreationMethod; typedef struct _ValaCreationMethodClass ValaCreationMethodClass; #define VALA_TYPE_CLASS_TYPE (vala_class_type_get_type ()) #define VALA_CLASS_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CLASS_TYPE, ValaClassType)) #define VALA_CLASS_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CLASS_TYPE, ValaClassTypeClass)) #define VALA_IS_CLASS_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CLASS_TYPE)) #define VALA_IS_CLASS_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CLASS_TYPE)) #define VALA_CLASS_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CLASS_TYPE, ValaClassTypeClass)) typedef struct _ValaClassType ValaClassType; typedef struct _ValaClassTypeClass ValaClassTypeClass; typedef struct _ValaClassTypePrivate ValaClassTypePrivate; typedef struct _ValaCodeContextPrivate ValaCodeContextPrivate; #define VALA_TYPE_SOURCE_FILE (vala_source_file_get_type ()) #define VALA_SOURCE_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SOURCE_FILE, ValaSourceFile)) #define VALA_SOURCE_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SOURCE_FILE, ValaSourceFileClass)) #define VALA_IS_SOURCE_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SOURCE_FILE)) #define VALA_IS_SOURCE_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SOURCE_FILE)) #define VALA_SOURCE_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SOURCE_FILE, ValaSourceFileClass)) typedef struct _ValaSourceFile ValaSourceFile; typedef struct _ValaSourceFileClass ValaSourceFileClass; #define VALA_TYPE_PROFILE (vala_profile_get_type ()) #define VALA_TYPE_REPORT (vala_report_get_type ()) #define VALA_REPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REPORT, ValaReport)) #define VALA_REPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REPORT, ValaReportClass)) #define VALA_IS_REPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REPORT)) #define VALA_IS_REPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REPORT)) #define VALA_REPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REPORT, ValaReportClass)) typedef struct _ValaReport ValaReport; typedef struct _ValaReportClass ValaReportClass; #define VALA_TYPE_SYMBOL_RESOLVER (vala_symbol_resolver_get_type ()) #define VALA_SYMBOL_RESOLVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SYMBOL_RESOLVER, ValaSymbolResolver)) #define VALA_SYMBOL_RESOLVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SYMBOL_RESOLVER, ValaSymbolResolverClass)) #define VALA_IS_SYMBOL_RESOLVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SYMBOL_RESOLVER)) #define VALA_IS_SYMBOL_RESOLVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SYMBOL_RESOLVER)) #define VALA_SYMBOL_RESOLVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SYMBOL_RESOLVER, ValaSymbolResolverClass)) typedef struct _ValaSymbolResolver ValaSymbolResolver; typedef struct _ValaSymbolResolverClass ValaSymbolResolverClass; #define VALA_TYPE_SEMANTIC_ANALYZER (vala_semantic_analyzer_get_type ()) #define VALA_SEMANTIC_ANALYZER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SEMANTIC_ANALYZER, ValaSemanticAnalyzer)) #define VALA_SEMANTIC_ANALYZER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SEMANTIC_ANALYZER, ValaSemanticAnalyzerClass)) #define VALA_IS_SEMANTIC_ANALYZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SEMANTIC_ANALYZER)) #define VALA_IS_SEMANTIC_ANALYZER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SEMANTIC_ANALYZER)) #define VALA_SEMANTIC_ANALYZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SEMANTIC_ANALYZER, ValaSemanticAnalyzerClass)) typedef struct _ValaSemanticAnalyzer ValaSemanticAnalyzer; typedef struct _ValaSemanticAnalyzerClass ValaSemanticAnalyzerClass; #define VALA_TYPE_FLOW_ANALYZER (vala_flow_analyzer_get_type ()) #define VALA_FLOW_ANALYZER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FLOW_ANALYZER, ValaFlowAnalyzer)) #define VALA_FLOW_ANALYZER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FLOW_ANALYZER, ValaFlowAnalyzerClass)) #define VALA_IS_FLOW_ANALYZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FLOW_ANALYZER)) #define VALA_IS_FLOW_ANALYZER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FLOW_ANALYZER)) #define VALA_FLOW_ANALYZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FLOW_ANALYZER, ValaFlowAnalyzerClass)) typedef struct _ValaFlowAnalyzer ValaFlowAnalyzer; typedef struct _ValaFlowAnalyzerClass ValaFlowAnalyzerClass; #define VALA_TYPE_USED_ATTR (vala_used_attr_get_type ()) #define VALA_USED_ATTR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_USED_ATTR, ValaUsedAttr)) #define VALA_USED_ATTR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_USED_ATTR, ValaUsedAttrClass)) #define VALA_IS_USED_ATTR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_USED_ATTR)) #define VALA_IS_USED_ATTR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_USED_ATTR)) #define VALA_USED_ATTR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_USED_ATTR, ValaUsedAttrClass)) typedef struct _ValaUsedAttr ValaUsedAttr; typedef struct _ValaUsedAttrClass ValaUsedAttrClass; typedef struct _ValaCodeVisitorPrivate ValaCodeVisitorPrivate; #define VALA_TYPE_ENUM_VALUE (vala_enum_value_get_type ()) #define VALA_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValue)) #define VALA_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass)) #define VALA_IS_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM_VALUE)) #define VALA_IS_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM_VALUE)) #define VALA_ENUM_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass)) typedef struct _ValaEnumValue ValaEnumValue; typedef struct _ValaEnumValueClass ValaEnumValueClass; #define VALA_TYPE_ERROR_CODE (vala_error_code_get_type ()) #define VALA_ERROR_CODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ERROR_CODE, ValaErrorCode)) #define VALA_ERROR_CODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ERROR_CODE, ValaErrorCodeClass)) #define VALA_IS_ERROR_CODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ERROR_CODE)) #define VALA_IS_ERROR_CODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ERROR_CODE)) #define VALA_ERROR_CODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ERROR_CODE, ValaErrorCodeClass)) typedef struct _ValaErrorCode ValaErrorCode; typedef struct _ValaErrorCodeClass ValaErrorCodeClass; #define VALA_TYPE_PROPERTY_ACCESSOR (vala_property_accessor_get_type ()) #define VALA_PROPERTY_ACCESSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor)) #define VALA_PROPERTY_ACCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessorClass)) #define VALA_IS_PROPERTY_ACCESSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PROPERTY_ACCESSOR)) #define VALA_IS_PROPERTY_ACCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PROPERTY_ACCESSOR)) #define VALA_PROPERTY_ACCESSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessorClass)) typedef struct _ValaPropertyAccessor ValaPropertyAccessor; typedef struct _ValaPropertyAccessorClass ValaPropertyAccessorClass; #define VALA_TYPE_USING_DIRECTIVE (vala_using_directive_get_type ()) #define VALA_USING_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_USING_DIRECTIVE, ValaUsingDirective)) #define VALA_USING_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_USING_DIRECTIVE, ValaUsingDirectiveClass)) #define VALA_IS_USING_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_USING_DIRECTIVE)) #define VALA_IS_USING_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_USING_DIRECTIVE)) #define VALA_USING_DIRECTIVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_USING_DIRECTIVE, ValaUsingDirectiveClass)) typedef struct _ValaUsingDirective ValaUsingDirective; typedef struct _ValaUsingDirectiveClass ValaUsingDirectiveClass; #define VALA_TYPE_EMPTY_STATEMENT (vala_empty_statement_get_type ()) #define VALA_EMPTY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_EMPTY_STATEMENT, ValaEmptyStatement)) #define VALA_EMPTY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_EMPTY_STATEMENT, ValaEmptyStatementClass)) #define VALA_IS_EMPTY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_EMPTY_STATEMENT)) #define VALA_IS_EMPTY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_EMPTY_STATEMENT)) #define VALA_EMPTY_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_EMPTY_STATEMENT, ValaEmptyStatementClass)) typedef struct _ValaEmptyStatement ValaEmptyStatement; typedef struct _ValaEmptyStatementClass ValaEmptyStatementClass; #define VALA_TYPE_DECLARATION_STATEMENT (vala_declaration_statement_get_type ()) #define VALA_DECLARATION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DECLARATION_STATEMENT, ValaDeclarationStatement)) #define VALA_DECLARATION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DECLARATION_STATEMENT, ValaDeclarationStatementClass)) #define VALA_IS_DECLARATION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DECLARATION_STATEMENT)) #define VALA_IS_DECLARATION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DECLARATION_STATEMENT)) #define VALA_DECLARATION_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DECLARATION_STATEMENT, ValaDeclarationStatementClass)) typedef struct _ValaDeclarationStatement ValaDeclarationStatement; typedef struct _ValaDeclarationStatementClass ValaDeclarationStatementClass; #define VALA_TYPE_EXPRESSION_STATEMENT (vala_expression_statement_get_type ()) #define VALA_EXPRESSION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_EXPRESSION_STATEMENT, ValaExpressionStatement)) #define VALA_EXPRESSION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_EXPRESSION_STATEMENT, ValaExpressionStatementClass)) #define VALA_IS_EXPRESSION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_EXPRESSION_STATEMENT)) #define VALA_IS_EXPRESSION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_EXPRESSION_STATEMENT)) #define VALA_EXPRESSION_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_EXPRESSION_STATEMENT, ValaExpressionStatementClass)) typedef struct _ValaExpressionStatement ValaExpressionStatement; typedef struct _ValaExpressionStatementClass ValaExpressionStatementClass; #define VALA_TYPE_IF_STATEMENT (vala_if_statement_get_type ()) #define VALA_IF_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_IF_STATEMENT, ValaIfStatement)) #define VALA_IF_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_IF_STATEMENT, ValaIfStatementClass)) #define VALA_IS_IF_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_IF_STATEMENT)) #define VALA_IS_IF_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_IF_STATEMENT)) #define VALA_IF_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_IF_STATEMENT, ValaIfStatementClass)) typedef struct _ValaIfStatement ValaIfStatement; typedef struct _ValaIfStatementClass ValaIfStatementClass; #define VALA_TYPE_SWITCH_STATEMENT (vala_switch_statement_get_type ()) #define VALA_SWITCH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SWITCH_STATEMENT, ValaSwitchStatement)) #define VALA_SWITCH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SWITCH_STATEMENT, ValaSwitchStatementClass)) #define VALA_IS_SWITCH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SWITCH_STATEMENT)) #define VALA_IS_SWITCH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SWITCH_STATEMENT)) #define VALA_SWITCH_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SWITCH_STATEMENT, ValaSwitchStatementClass)) typedef struct _ValaSwitchStatement ValaSwitchStatement; typedef struct _ValaSwitchStatementClass ValaSwitchStatementClass; #define VALA_TYPE_SWITCH_SECTION (vala_switch_section_get_type ()) #define VALA_SWITCH_SECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SWITCH_SECTION, ValaSwitchSection)) #define VALA_SWITCH_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SWITCH_SECTION, ValaSwitchSectionClass)) #define VALA_IS_SWITCH_SECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SWITCH_SECTION)) #define VALA_IS_SWITCH_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SWITCH_SECTION)) #define VALA_SWITCH_SECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SWITCH_SECTION, ValaSwitchSectionClass)) typedef struct _ValaSwitchSection ValaSwitchSection; typedef struct _ValaSwitchSectionClass ValaSwitchSectionClass; #define VALA_TYPE_SWITCH_LABEL (vala_switch_label_get_type ()) #define VALA_SWITCH_LABEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SWITCH_LABEL, ValaSwitchLabel)) #define VALA_SWITCH_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SWITCH_LABEL, ValaSwitchLabelClass)) #define VALA_IS_SWITCH_LABEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SWITCH_LABEL)) #define VALA_IS_SWITCH_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SWITCH_LABEL)) #define VALA_SWITCH_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SWITCH_LABEL, ValaSwitchLabelClass)) typedef struct _ValaSwitchLabel ValaSwitchLabel; typedef struct _ValaSwitchLabelClass ValaSwitchLabelClass; #define VALA_TYPE_LOOP (vala_loop_get_type ()) #define VALA_LOOP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LOOP, ValaLoop)) #define VALA_LOOP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LOOP, ValaLoopClass)) #define VALA_IS_LOOP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LOOP)) #define VALA_IS_LOOP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LOOP)) #define VALA_LOOP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LOOP, ValaLoopClass)) typedef struct _ValaLoop ValaLoop; typedef struct _ValaLoopClass ValaLoopClass; #define VALA_TYPE_WHILE_STATEMENT (vala_while_statement_get_type ()) #define VALA_WHILE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_WHILE_STATEMENT, ValaWhileStatement)) #define VALA_WHILE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_WHILE_STATEMENT, ValaWhileStatementClass)) #define VALA_IS_WHILE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_WHILE_STATEMENT)) #define VALA_IS_WHILE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_WHILE_STATEMENT)) #define VALA_WHILE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_WHILE_STATEMENT, ValaWhileStatementClass)) typedef struct _ValaWhileStatement ValaWhileStatement; typedef struct _ValaWhileStatementClass ValaWhileStatementClass; #define VALA_TYPE_DO_STATEMENT (vala_do_statement_get_type ()) #define VALA_DO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DO_STATEMENT, ValaDoStatement)) #define VALA_DO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DO_STATEMENT, ValaDoStatementClass)) #define VALA_IS_DO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DO_STATEMENT)) #define VALA_IS_DO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DO_STATEMENT)) #define VALA_DO_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DO_STATEMENT, ValaDoStatementClass)) typedef struct _ValaDoStatement ValaDoStatement; typedef struct _ValaDoStatementClass ValaDoStatementClass; #define VALA_TYPE_FOR_STATEMENT (vala_for_statement_get_type ()) #define VALA_FOR_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FOR_STATEMENT, ValaForStatement)) #define VALA_FOR_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FOR_STATEMENT, ValaForStatementClass)) #define VALA_IS_FOR_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FOR_STATEMENT)) #define VALA_IS_FOR_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FOR_STATEMENT)) #define VALA_FOR_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FOR_STATEMENT, ValaForStatementClass)) typedef struct _ValaForStatement ValaForStatement; typedef struct _ValaForStatementClass ValaForStatementClass; #define VALA_TYPE_FOREACH_STATEMENT (vala_foreach_statement_get_type ()) #define VALA_FOREACH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FOREACH_STATEMENT, ValaForeachStatement)) #define VALA_FOREACH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FOREACH_STATEMENT, ValaForeachStatementClass)) #define VALA_IS_FOREACH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FOREACH_STATEMENT)) #define VALA_IS_FOREACH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FOREACH_STATEMENT)) #define VALA_FOREACH_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FOREACH_STATEMENT, ValaForeachStatementClass)) typedef struct _ValaForeachStatement ValaForeachStatement; typedef struct _ValaForeachStatementClass ValaForeachStatementClass; #define VALA_TYPE_CONTINUE_STATEMENT (vala_continue_statement_get_type ()) #define VALA_CONTINUE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONTINUE_STATEMENT, ValaContinueStatement)) #define VALA_CONTINUE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONTINUE_STATEMENT, ValaContinueStatementClass)) #define VALA_IS_CONTINUE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONTINUE_STATEMENT)) #define VALA_IS_CONTINUE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONTINUE_STATEMENT)) #define VALA_CONTINUE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONTINUE_STATEMENT, ValaContinueStatementClass)) typedef struct _ValaContinueStatement ValaContinueStatement; typedef struct _ValaContinueStatementClass ValaContinueStatementClass; #define VALA_TYPE_RETURN_STATEMENT (vala_return_statement_get_type ()) #define VALA_RETURN_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_RETURN_STATEMENT, ValaReturnStatement)) #define VALA_RETURN_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_RETURN_STATEMENT, ValaReturnStatementClass)) #define VALA_IS_RETURN_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_RETURN_STATEMENT)) #define VALA_IS_RETURN_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_RETURN_STATEMENT)) #define VALA_RETURN_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_RETURN_STATEMENT, ValaReturnStatementClass)) typedef struct _ValaReturnStatement ValaReturnStatement; typedef struct _ValaReturnStatementClass ValaReturnStatementClass; #define VALA_TYPE_YIELD_STATEMENT (vala_yield_statement_get_type ()) #define VALA_YIELD_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_YIELD_STATEMENT, ValaYieldStatement)) #define VALA_YIELD_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_YIELD_STATEMENT, ValaYieldStatementClass)) #define VALA_IS_YIELD_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_YIELD_STATEMENT)) #define VALA_IS_YIELD_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_YIELD_STATEMENT)) #define VALA_YIELD_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_YIELD_STATEMENT, ValaYieldStatementClass)) typedef struct _ValaYieldStatement ValaYieldStatement; typedef struct _ValaYieldStatementClass ValaYieldStatementClass; #define VALA_TYPE_THROW_STATEMENT (vala_throw_statement_get_type ()) #define VALA_THROW_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_THROW_STATEMENT, ValaThrowStatement)) #define VALA_THROW_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_THROW_STATEMENT, ValaThrowStatementClass)) #define VALA_IS_THROW_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_THROW_STATEMENT)) #define VALA_IS_THROW_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_THROW_STATEMENT)) #define VALA_THROW_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_THROW_STATEMENT, ValaThrowStatementClass)) typedef struct _ValaThrowStatement ValaThrowStatement; typedef struct _ValaThrowStatementClass ValaThrowStatementClass; #define VALA_TYPE_TRY_STATEMENT (vala_try_statement_get_type ()) #define VALA_TRY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TRY_STATEMENT, ValaTryStatement)) #define VALA_TRY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TRY_STATEMENT, ValaTryStatementClass)) #define VALA_IS_TRY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TRY_STATEMENT)) #define VALA_IS_TRY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TRY_STATEMENT)) #define VALA_TRY_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TRY_STATEMENT, ValaTryStatementClass)) typedef struct _ValaTryStatement ValaTryStatement; typedef struct _ValaTryStatementClass ValaTryStatementClass; #define VALA_TYPE_LOCK_STATEMENT (vala_lock_statement_get_type ()) #define VALA_LOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LOCK_STATEMENT, ValaLockStatement)) #define VALA_LOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LOCK_STATEMENT, ValaLockStatementClass)) #define VALA_IS_LOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LOCK_STATEMENT)) #define VALA_IS_LOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LOCK_STATEMENT)) #define VALA_LOCK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LOCK_STATEMENT, ValaLockStatementClass)) typedef struct _ValaLockStatement ValaLockStatement; typedef struct _ValaLockStatementClass ValaLockStatementClass; #define VALA_TYPE_UNLOCK_STATEMENT (vala_unlock_statement_get_type ()) #define VALA_UNLOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatement)) #define VALA_UNLOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatementClass)) #define VALA_IS_UNLOCK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNLOCK_STATEMENT)) #define VALA_IS_UNLOCK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNLOCK_STATEMENT)) #define VALA_UNLOCK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNLOCK_STATEMENT, ValaUnlockStatementClass)) typedef struct _ValaUnlockStatement ValaUnlockStatement; typedef struct _ValaUnlockStatementClass ValaUnlockStatementClass; #define VALA_TYPE_DELETE_STATEMENT (vala_delete_statement_get_type ()) #define VALA_DELETE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatement)) #define VALA_DELETE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatementClass)) #define VALA_IS_DELETE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DELETE_STATEMENT)) #define VALA_IS_DELETE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DELETE_STATEMENT)) #define VALA_DELETE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DELETE_STATEMENT, ValaDeleteStatementClass)) typedef struct _ValaDeleteStatement ValaDeleteStatement; typedef struct _ValaDeleteStatementClass ValaDeleteStatementClass; #define VALA_TYPE_INTEGER_LITERAL (vala_integer_literal_get_type ()) #define VALA_INTEGER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral)) #define VALA_INTEGER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteralClass)) #define VALA_IS_INTEGER_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTEGER_LITERAL)) #define VALA_IS_INTEGER_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTEGER_LITERAL)) #define VALA_INTEGER_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteralClass)) typedef struct _ValaIntegerLiteral ValaIntegerLiteral; typedef struct _ValaIntegerLiteralClass ValaIntegerLiteralClass; #define VALA_TYPE_REAL_LITERAL (vala_real_literal_get_type ()) #define VALA_REAL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REAL_LITERAL, ValaRealLiteral)) #define VALA_REAL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REAL_LITERAL, ValaRealLiteralClass)) #define VALA_IS_REAL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REAL_LITERAL)) #define VALA_IS_REAL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REAL_LITERAL)) #define VALA_REAL_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REAL_LITERAL, ValaRealLiteralClass)) typedef struct _ValaRealLiteral ValaRealLiteral; typedef struct _ValaRealLiteralClass ValaRealLiteralClass; #define VALA_TYPE_REGEX_LITERAL (vala_regex_literal_get_type ()) #define VALA_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteral)) #define VALA_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass)) #define VALA_IS_REGEX_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REGEX_LITERAL)) #define VALA_IS_REGEX_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REGEX_LITERAL)) #define VALA_REGEX_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REGEX_LITERAL, ValaRegexLiteralClass)) typedef struct _ValaRegexLiteral ValaRegexLiteral; typedef struct _ValaRegexLiteralClass ValaRegexLiteralClass; #define VALA_TYPE_STRING_LITERAL (vala_string_literal_get_type ()) #define VALA_STRING_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRING_LITERAL, ValaStringLiteral)) #define VALA_STRING_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRING_LITERAL, ValaStringLiteralClass)) #define VALA_IS_STRING_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRING_LITERAL)) #define VALA_IS_STRING_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRING_LITERAL)) #define VALA_STRING_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRING_LITERAL, ValaStringLiteralClass)) typedef struct _ValaStringLiteral ValaStringLiteral; typedef struct _ValaStringLiteralClass ValaStringLiteralClass; #define VALA_TYPE_TEMPLATE (vala_template_get_type ()) #define VALA_TEMPLATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TEMPLATE, ValaTemplate)) #define VALA_TEMPLATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TEMPLATE, ValaTemplateClass)) #define VALA_IS_TEMPLATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TEMPLATE)) #define VALA_IS_TEMPLATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TEMPLATE)) #define VALA_TEMPLATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TEMPLATE, ValaTemplateClass)) typedef struct _ValaTemplate ValaTemplate; typedef struct _ValaTemplateClass ValaTemplateClass; #define VALA_TYPE_TUPLE (vala_tuple_get_type ()) #define VALA_TUPLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TUPLE, ValaTuple)) #define VALA_TUPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TUPLE, ValaTupleClass)) #define VALA_IS_TUPLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TUPLE)) #define VALA_IS_TUPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TUPLE)) #define VALA_TUPLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TUPLE, ValaTupleClass)) typedef struct _ValaTuple ValaTuple; typedef struct _ValaTupleClass ValaTupleClass; #define VALA_TYPE_NULL_LITERAL (vala_null_literal_get_type ()) #define VALA_NULL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NULL_LITERAL, ValaNullLiteral)) #define VALA_NULL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NULL_LITERAL, ValaNullLiteralClass)) #define VALA_IS_NULL_LITERAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NULL_LITERAL)) #define VALA_IS_NULL_LITERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NULL_LITERAL)) #define VALA_NULL_LITERAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NULL_LITERAL, ValaNullLiteralClass)) typedef struct _ValaNullLiteral ValaNullLiteral; typedef struct _ValaNullLiteralClass ValaNullLiteralClass; #define VALA_TYPE_MEMBER_ACCESS (vala_member_access_get_type ()) #define VALA_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)) #define VALA_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccessClass)) #define VALA_IS_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MEMBER_ACCESS)) #define VALA_IS_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MEMBER_ACCESS)) #define VALA_MEMBER_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MEMBER_ACCESS, ValaMemberAccessClass)) typedef struct _ValaMemberAccess ValaMemberAccess; typedef struct _ValaMemberAccessClass ValaMemberAccessClass; #define VALA_TYPE_METHOD_CALL (vala_method_call_get_type ()) #define VALA_METHOD_CALL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_METHOD_CALL, ValaMethodCall)) #define VALA_METHOD_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_METHOD_CALL, ValaMethodCallClass)) #define VALA_IS_METHOD_CALL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_METHOD_CALL)) #define VALA_IS_METHOD_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_METHOD_CALL)) #define VALA_METHOD_CALL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_METHOD_CALL, ValaMethodCallClass)) typedef struct _ValaMethodCall ValaMethodCall; typedef struct _ValaMethodCallClass ValaMethodCallClass; #define VALA_TYPE_ELEMENT_ACCESS (vala_element_access_get_type ()) #define VALA_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccess)) #define VALA_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccessClass)) #define VALA_IS_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ELEMENT_ACCESS)) #define VALA_IS_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ELEMENT_ACCESS)) #define VALA_ELEMENT_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ELEMENT_ACCESS, ValaElementAccessClass)) typedef struct _ValaElementAccess ValaElementAccess; typedef struct _ValaElementAccessClass ValaElementAccessClass; #define VALA_TYPE_SLICE_EXPRESSION (vala_slice_expression_get_type ()) #define VALA_SLICE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpression)) #define VALA_SLICE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpressionClass)) #define VALA_IS_SLICE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SLICE_EXPRESSION)) #define VALA_IS_SLICE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SLICE_EXPRESSION)) #define VALA_SLICE_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SLICE_EXPRESSION, ValaSliceExpressionClass)) typedef struct _ValaSliceExpression ValaSliceExpression; typedef struct _ValaSliceExpressionClass ValaSliceExpressionClass; #define VALA_TYPE_POSTFIX_EXPRESSION (vala_postfix_expression_get_type ()) #define VALA_POSTFIX_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpression)) #define VALA_POSTFIX_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpressionClass)) #define VALA_IS_POSTFIX_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POSTFIX_EXPRESSION)) #define VALA_IS_POSTFIX_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POSTFIX_EXPRESSION)) #define VALA_POSTFIX_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POSTFIX_EXPRESSION, ValaPostfixExpressionClass)) typedef struct _ValaPostfixExpression ValaPostfixExpression; typedef struct _ValaPostfixExpressionClass ValaPostfixExpressionClass; #define VALA_TYPE_OBJECT_CREATION_EXPRESSION (vala_object_creation_expression_get_type ()) #define VALA_OBJECT_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpression)) #define VALA_OBJECT_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpressionClass)) #define VALA_IS_OBJECT_CREATION_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION)) #define VALA_IS_OBJECT_CREATION_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_OBJECT_CREATION_EXPRESSION)) #define VALA_OBJECT_CREATION_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_OBJECT_CREATION_EXPRESSION, ValaObjectCreationExpressionClass)) typedef struct _ValaObjectCreationExpression ValaObjectCreationExpression; typedef struct _ValaObjectCreationExpressionClass ValaObjectCreationExpressionClass; #define VALA_TYPE_SIZEOF_EXPRESSION (vala_sizeof_expression_get_type ()) #define VALA_SIZEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpression)) #define VALA_SIZEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpressionClass)) #define VALA_IS_SIZEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SIZEOF_EXPRESSION)) #define VALA_IS_SIZEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SIZEOF_EXPRESSION)) #define VALA_SIZEOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SIZEOF_EXPRESSION, ValaSizeofExpressionClass)) typedef struct _ValaSizeofExpression ValaSizeofExpression; typedef struct _ValaSizeofExpressionClass ValaSizeofExpressionClass; #define VALA_TYPE_TYPEOF_EXPRESSION (vala_typeof_expression_get_type ()) #define VALA_TYPEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpression)) #define VALA_TYPEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpressionClass)) #define VALA_IS_TYPEOF_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPEOF_EXPRESSION)) #define VALA_IS_TYPEOF_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPEOF_EXPRESSION)) #define VALA_TYPEOF_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPEOF_EXPRESSION, ValaTypeofExpressionClass)) typedef struct _ValaTypeofExpression ValaTypeofExpression; typedef struct _ValaTypeofExpressionClass ValaTypeofExpressionClass; #define VALA_TYPE_UNARY_EXPRESSION (vala_unary_expression_get_type ()) #define VALA_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpression)) #define VALA_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpressionClass)) #define VALA_IS_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNARY_EXPRESSION)) #define VALA_IS_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNARY_EXPRESSION)) #define VALA_UNARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpressionClass)) typedef struct _ValaUnaryExpression ValaUnaryExpression; typedef struct _ValaUnaryExpressionClass ValaUnaryExpressionClass; #define VALA_TYPE_NAMED_ARGUMENT (vala_named_argument_get_type ()) #define VALA_NAMED_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgument)) #define VALA_NAMED_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgumentClass)) #define VALA_IS_NAMED_ARGUMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NAMED_ARGUMENT)) #define VALA_IS_NAMED_ARGUMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NAMED_ARGUMENT)) #define VALA_NAMED_ARGUMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NAMED_ARGUMENT, ValaNamedArgumentClass)) typedef struct _ValaNamedArgument ValaNamedArgument; typedef struct _ValaNamedArgumentClass ValaNamedArgumentClass; #define VALA_TYPE_POINTER_INDIRECTION (vala_pointer_indirection_get_type ()) #define VALA_POINTER_INDIRECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirection)) #define VALA_POINTER_INDIRECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirectionClass)) #define VALA_IS_POINTER_INDIRECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POINTER_INDIRECTION)) #define VALA_IS_POINTER_INDIRECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POINTER_INDIRECTION)) #define VALA_POINTER_INDIRECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POINTER_INDIRECTION, ValaPointerIndirectionClass)) typedef struct _ValaPointerIndirection ValaPointerIndirection; typedef struct _ValaPointerIndirectionClass ValaPointerIndirectionClass; #define VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION (vala_reference_transfer_expression_get_type ()) #define VALA_REFERENCE_TRANSFER_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpression)) #define VALA_REFERENCE_TRANSFER_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpressionClass)) #define VALA_IS_REFERENCE_TRANSFER_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION)) #define VALA_IS_REFERENCE_TRANSFER_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION)) #define VALA_REFERENCE_TRANSFER_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_REFERENCE_TRANSFER_EXPRESSION, ValaReferenceTransferExpressionClass)) typedef struct _ValaReferenceTransferExpression ValaReferenceTransferExpression; typedef struct _ValaReferenceTransferExpressionClass ValaReferenceTransferExpressionClass; #define VALA_TYPE_TYPECHECK (vala_typecheck_get_type ()) #define VALA_TYPECHECK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPECHECK, ValaTypeCheck)) #define VALA_TYPECHECK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPECHECK, ValaTypeCheckClass)) #define VALA_IS_TYPECHECK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPECHECK)) #define VALA_IS_TYPECHECK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPECHECK)) #define VALA_TYPECHECK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPECHECK, ValaTypeCheckClass)) typedef struct _ValaTypeCheck ValaTypeCheck; typedef struct _ValaTypeCheckClass ValaTypeCheckClass; #define VALA_TYPE_CONDITIONAL_EXPRESSION (vala_conditional_expression_get_type ()) #define VALA_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpression)) #define VALA_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpressionClass)) #define VALA_IS_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION)) #define VALA_IS_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CONDITIONAL_EXPRESSION)) #define VALA_CONDITIONAL_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CONDITIONAL_EXPRESSION, ValaConditionalExpressionClass)) typedef struct _ValaConditionalExpression ValaConditionalExpression; typedef struct _ValaConditionalExpressionClass ValaConditionalExpressionClass; #define VALA_TYPE_LAMBDA_EXPRESSION (vala_lambda_expression_get_type ()) #define VALA_LAMBDA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpression)) #define VALA_LAMBDA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpressionClass)) #define VALA_IS_LAMBDA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LAMBDA_EXPRESSION)) #define VALA_IS_LAMBDA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LAMBDA_EXPRESSION)) #define VALA_LAMBDA_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LAMBDA_EXPRESSION, ValaLambdaExpressionClass)) typedef struct _ValaLambdaExpression ValaLambdaExpression; typedef struct _ValaLambdaExpressionClass ValaLambdaExpressionClass; typedef struct _ValaCodeGeneratorPrivate ValaCodeGeneratorPrivate; #define VALA_TYPE_TARGET_VALUE (vala_target_value_get_type ()) #define VALA_TARGET_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TARGET_VALUE, ValaTargetValue)) #define VALA_TARGET_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TARGET_VALUE, ValaTargetValueClass)) #define VALA_IS_TARGET_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TARGET_VALUE)) #define VALA_IS_TARGET_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TARGET_VALUE)) #define VALA_TARGET_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TARGET_VALUE, ValaTargetValueClass)) typedef struct _ValaTargetValue ValaTargetValue; typedef struct _ValaTargetValueClass ValaTargetValueClass; #define VALA_TYPE_ATTRIBUTE_CACHE (vala_attribute_cache_get_type ()) #define VALA_ATTRIBUTE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ATTRIBUTE_CACHE, ValaAttributeCache)) #define VALA_ATTRIBUTE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ATTRIBUTE_CACHE, ValaAttributeCacheClass)) #define VALA_IS_ATTRIBUTE_CACHE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ATTRIBUTE_CACHE)) #define VALA_IS_ATTRIBUTE_CACHE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ATTRIBUTE_CACHE)) #define VALA_ATTRIBUTE_CACHE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ATTRIBUTE_CACHE, ValaAttributeCacheClass)) typedef struct _ValaAttributeCache ValaAttributeCache; typedef struct _ValaAttributeCacheClass ValaAttributeCacheClass; typedef struct _ValaAttributeCachePrivate ValaAttributeCachePrivate; #define VALA_TYPE_CODE_WRITER (vala_code_writer_get_type ()) #define VALA_CODE_WRITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_WRITER, ValaCodeWriter)) #define VALA_CODE_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CODE_WRITER, ValaCodeWriterClass)) #define VALA_IS_CODE_WRITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CODE_WRITER)) #define VALA_IS_CODE_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CODE_WRITER)) #define VALA_CODE_WRITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CODE_WRITER, ValaCodeWriterClass)) typedef struct _ValaCodeWriter ValaCodeWriter; typedef struct _ValaCodeWriterClass ValaCodeWriterClass; typedef struct _ValaCodeWriterPrivate ValaCodeWriterPrivate; #define VALA_TYPE_CODE_WRITER_TYPE (vala_code_writer_type_get_type ()) typedef struct _ValaCommentPrivate ValaCommentPrivate; #define VALA_TYPE_GIR_COMMENT (vala_gir_comment_get_type ()) #define VALA_GIR_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GIR_COMMENT, ValaGirComment)) #define VALA_GIR_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GIR_COMMENT, ValaGirCommentClass)) #define VALA_IS_GIR_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GIR_COMMENT)) #define VALA_IS_GIR_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GIR_COMMENT)) #define VALA_GIR_COMMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GIR_COMMENT, ValaGirCommentClass)) typedef struct _ValaGirComment ValaGirComment; typedef struct _ValaGirCommentClass ValaGirCommentClass; typedef struct _ValaGirCommentPrivate ValaGirCommentPrivate; typedef struct _ValaConditionalExpressionPrivate ValaConditionalExpressionPrivate; typedef struct _ValaConstantPrivate ValaConstantPrivate; typedef struct _ValaConstructorPrivate ValaConstructorPrivate; #define VALA_TYPE_MEMBER_BINDING (vala_member_binding_get_type ()) typedef struct _ValaContinueStatementPrivate ValaContinueStatementPrivate; typedef struct _ValaCreationMethodPrivate ValaCreationMethodPrivate; typedef struct _ValaDeclarationStatementPrivate ValaDeclarationStatementPrivate; typedef struct _ValaDelegatePrivate ValaDelegatePrivate; #define VALA_TYPE_DELEGATE_TYPE (vala_delegate_type_get_type ()) #define VALA_DELEGATE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)) #define VALA_DELEGATE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DELEGATE_TYPE, ValaDelegateTypeClass)) #define VALA_IS_DELEGATE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DELEGATE_TYPE)) #define VALA_IS_DELEGATE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DELEGATE_TYPE)) #define VALA_DELEGATE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DELEGATE_TYPE, ValaDelegateTypeClass)) typedef struct _ValaDelegateType ValaDelegateType; typedef struct _ValaDelegateTypeClass ValaDelegateTypeClass; typedef struct _ValaDelegateTypePrivate ValaDelegateTypePrivate; typedef struct _ValaDeleteStatementPrivate ValaDeleteStatementPrivate; typedef struct _ValaDestructorPrivate ValaDestructorPrivate; typedef struct _ValaDoStatementPrivate ValaDoStatementPrivate; #define VALA_TYPE_DYNAMIC_METHOD (vala_dynamic_method_get_type ()) #define VALA_DYNAMIC_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DYNAMIC_METHOD, ValaDynamicMethod)) #define VALA_DYNAMIC_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DYNAMIC_METHOD, ValaDynamicMethodClass)) #define VALA_IS_DYNAMIC_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DYNAMIC_METHOD)) #define VALA_IS_DYNAMIC_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DYNAMIC_METHOD)) #define VALA_DYNAMIC_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DYNAMIC_METHOD, ValaDynamicMethodClass)) typedef struct _ValaDynamicMethod ValaDynamicMethod; typedef struct _ValaDynamicMethodClass ValaDynamicMethodClass; typedef struct _ValaDynamicMethodPrivate ValaDynamicMethodPrivate; typedef struct _ValaPropertyPrivate ValaPropertyPrivate; #define VALA_TYPE_DYNAMIC_PROPERTY (vala_dynamic_property_get_type ()) #define VALA_DYNAMIC_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty)) #define VALA_DYNAMIC_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicPropertyClass)) #define VALA_IS_DYNAMIC_PROPERTY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DYNAMIC_PROPERTY)) #define VALA_IS_DYNAMIC_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DYNAMIC_PROPERTY)) #define VALA_DYNAMIC_PROPERTY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicPropertyClass)) typedef struct _ValaDynamicProperty ValaDynamicProperty; typedef struct _ValaDynamicPropertyClass ValaDynamicPropertyClass; typedef struct _ValaDynamicPropertyPrivate ValaDynamicPropertyPrivate; typedef struct _ValaSignalPrivate ValaSignalPrivate; #define VALA_TYPE_DYNAMIC_SIGNAL (vala_dynamic_signal_get_type ()) #define VALA_DYNAMIC_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_DYNAMIC_SIGNAL, ValaDynamicSignal)) #define VALA_DYNAMIC_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_DYNAMIC_SIGNAL, ValaDynamicSignalClass)) #define VALA_IS_DYNAMIC_SIGNAL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_DYNAMIC_SIGNAL)) #define VALA_IS_DYNAMIC_SIGNAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_DYNAMIC_SIGNAL)) #define VALA_DYNAMIC_SIGNAL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_DYNAMIC_SIGNAL, ValaDynamicSignalClass)) typedef struct _ValaDynamicSignal ValaDynamicSignal; typedef struct _ValaDynamicSignalClass ValaDynamicSignalClass; typedef struct _ValaDynamicSignalPrivate ValaDynamicSignalPrivate; typedef struct _ValaElementAccessPrivate ValaElementAccessPrivate; typedef struct _ValaEmptyStatementPrivate ValaEmptyStatementPrivate; typedef struct _ValaEnumPrivate ValaEnumPrivate; typedef struct _ValaEnumValuePrivate ValaEnumValuePrivate; #define VALA_TYPE_ENUM_VALUE_TYPE (vala_enum_value_type_get_type ()) #define VALA_ENUM_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM_VALUE_TYPE, ValaEnumValueType)) #define VALA_ENUM_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM_VALUE_TYPE, ValaEnumValueTypeClass)) #define VALA_IS_ENUM_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM_VALUE_TYPE)) #define VALA_IS_ENUM_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM_VALUE_TYPE)) #define VALA_ENUM_VALUE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM_VALUE_TYPE, ValaEnumValueTypeClass)) typedef struct _ValaEnumValueType ValaEnumValueType; typedef struct _ValaEnumValueTypeClass ValaEnumValueTypeClass; typedef struct _ValaEnumValueTypePrivate ValaEnumValueTypePrivate; typedef struct _ValaErrorCodePrivate ValaErrorCodePrivate; typedef struct _ValaErrorDomainPrivate ValaErrorDomainPrivate; #define VALA_TYPE_ERROR_TYPE (vala_error_type_get_type ()) #define VALA_ERROR_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ERROR_TYPE, ValaErrorType)) #define VALA_ERROR_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ERROR_TYPE, ValaErrorTypeClass)) #define VALA_IS_ERROR_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ERROR_TYPE)) #define VALA_IS_ERROR_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ERROR_TYPE)) #define VALA_ERROR_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ERROR_TYPE, ValaErrorTypeClass)) typedef struct _ValaErrorType ValaErrorType; typedef struct _ValaErrorTypeClass ValaErrorTypeClass; typedef struct _ValaErrorTypePrivate ValaErrorTypePrivate; typedef struct _ValaExpressionStatementPrivate ValaExpressionStatementPrivate; #define VALA_TYPE_FIELD_PROTOTYPE (vala_field_prototype_get_type ()) #define VALA_FIELD_PROTOTYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FIELD_PROTOTYPE, ValaFieldPrototype)) #define VALA_FIELD_PROTOTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FIELD_PROTOTYPE, ValaFieldPrototypeClass)) #define VALA_IS_FIELD_PROTOTYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FIELD_PROTOTYPE)) #define VALA_IS_FIELD_PROTOTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FIELD_PROTOTYPE)) #define VALA_FIELD_PROTOTYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FIELD_PROTOTYPE, ValaFieldPrototypeClass)) typedef struct _ValaFieldPrototype ValaFieldPrototype; typedef struct _ValaFieldPrototypeClass ValaFieldPrototypeClass; typedef struct _ValaFieldPrototypePrivate ValaFieldPrototypePrivate; #define VALA_TYPE_FLOATING_TYPE (vala_floating_type_get_type ()) #define VALA_FLOATING_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_FLOATING_TYPE, ValaFloatingType)) #define VALA_FLOATING_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_FLOATING_TYPE, ValaFloatingTypeClass)) #define VALA_IS_FLOATING_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_FLOATING_TYPE)) #define VALA_IS_FLOATING_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_FLOATING_TYPE)) #define VALA_FLOATING_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_FLOATING_TYPE, ValaFloatingTypeClass)) typedef struct _ValaFloatingType ValaFloatingType; typedef struct _ValaFloatingTypeClass ValaFloatingTypeClass; typedef struct _ValaFloatingTypePrivate ValaFloatingTypePrivate; typedef struct _ValaFlowAnalyzerPrivate ValaFlowAnalyzerPrivate; typedef struct _ValaForeachStatementPrivate ValaForeachStatementPrivate; typedef struct _ValaForStatementPrivate ValaForStatementPrivate; #define VALA_TYPE_GIR_PARSER (vala_gir_parser_get_type ()) #define VALA_GIR_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GIR_PARSER, ValaGirParser)) #define VALA_GIR_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GIR_PARSER, ValaGirParserClass)) #define VALA_IS_GIR_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GIR_PARSER)) #define VALA_IS_GIR_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GIR_PARSER)) #define VALA_GIR_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GIR_PARSER, ValaGirParserClass)) typedef struct _ValaGirParser ValaGirParser; typedef struct _ValaGirParserClass ValaGirParserClass; typedef struct _ValaGirParserPrivate ValaGirParserPrivate; #define VALA_TYPE_GENERIC_TYPE (vala_generic_type_get_type ()) #define VALA_GENERIC_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GENERIC_TYPE, ValaGenericType)) #define VALA_GENERIC_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GENERIC_TYPE, ValaGenericTypeClass)) #define VALA_IS_GENERIC_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GENERIC_TYPE)) #define VALA_IS_GENERIC_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GENERIC_TYPE)) #define VALA_GENERIC_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GENERIC_TYPE, ValaGenericTypeClass)) typedef struct _ValaGenericType ValaGenericType; typedef struct _ValaGenericTypeClass ValaGenericTypeClass; typedef struct _ValaGenericTypePrivate ValaGenericTypePrivate; #define VALA_GENIE_TYPE_PARSER (vala_genie_parser_get_type ()) #define VALA_GENIE_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GENIE_TYPE_PARSER, ValaGenieParser)) #define VALA_GENIE_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GENIE_TYPE_PARSER, ValaGenieParserClass)) #define VALA_GENIE_IS_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GENIE_TYPE_PARSER)) #define VALA_GENIE_IS_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GENIE_TYPE_PARSER)) #define VALA_GENIE_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GENIE_TYPE_PARSER, ValaGenieParserClass)) typedef struct _ValaGenieParser ValaGenieParser; typedef struct _ValaGenieParserClass ValaGenieParserClass; typedef struct _ValaGenieParserPrivate ValaGenieParserPrivate; #define VALA_GENIE_TYPE_SCANNER (vala_genie_scanner_get_type ()) #define VALA_GENIE_SCANNER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_GENIE_TYPE_SCANNER, ValaGenieScanner)) #define VALA_GENIE_SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_GENIE_TYPE_SCANNER, ValaGenieScannerClass)) #define VALA_GENIE_IS_SCANNER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_GENIE_TYPE_SCANNER)) #define VALA_GENIE_IS_SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_GENIE_TYPE_SCANNER)) #define VALA_GENIE_SCANNER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_GENIE_TYPE_SCANNER, ValaGenieScannerClass)) typedef struct _ValaGenieScanner ValaGenieScanner; typedef struct _ValaGenieScannerClass ValaGenieScannerClass; typedef struct _ValaGenieScannerPrivate ValaGenieScannerPrivate; #define VALA_TYPE_SOURCE_LOCATION (vala_source_location_get_type ()) typedef struct _ValaSourceLocation ValaSourceLocation; #define VALA_GENIE_TYPE_TOKEN_TYPE (vala_genie_token_type_get_type ()) typedef struct _ValaIfStatementPrivate ValaIfStatementPrivate; typedef struct _ValaInitializerListPrivate ValaInitializerListPrivate; typedef struct _ValaIntegerLiteralPrivate ValaIntegerLiteralPrivate; #define VALA_TYPE_INTEGER_TYPE (vala_integer_type_get_type ()) #define VALA_INTEGER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTEGER_TYPE, ValaIntegerType)) #define VALA_INTEGER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTEGER_TYPE, ValaIntegerTypeClass)) #define VALA_IS_INTEGER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTEGER_TYPE)) #define VALA_IS_INTEGER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTEGER_TYPE)) #define VALA_INTEGER_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTEGER_TYPE, ValaIntegerTypeClass)) typedef struct _ValaIntegerType ValaIntegerType; typedef struct _ValaIntegerTypeClass ValaIntegerTypeClass; typedef struct _ValaIntegerTypePrivate ValaIntegerTypePrivate; typedef struct _ValaInterfacePrivate ValaInterfacePrivate; #define VALA_TYPE_INTERFACE_TYPE (vala_interface_type_get_type ()) #define VALA_INTERFACE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTERFACE_TYPE, ValaInterfaceType)) #define VALA_INTERFACE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTERFACE_TYPE, ValaInterfaceTypeClass)) #define VALA_IS_INTERFACE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTERFACE_TYPE)) #define VALA_IS_INTERFACE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTERFACE_TYPE)) #define VALA_INTERFACE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTERFACE_TYPE, ValaInterfaceTypeClass)) typedef struct _ValaInterfaceType ValaInterfaceType; typedef struct _ValaInterfaceTypeClass ValaInterfaceTypeClass; typedef struct _ValaInterfaceTypePrivate ValaInterfaceTypePrivate; #define VALA_TYPE_INVALID_TYPE (vala_invalid_type_get_type ()) #define VALA_INVALID_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INVALID_TYPE, ValaInvalidType)) #define VALA_INVALID_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INVALID_TYPE, ValaInvalidTypeClass)) #define VALA_IS_INVALID_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INVALID_TYPE)) #define VALA_IS_INVALID_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INVALID_TYPE)) #define VALA_INVALID_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INVALID_TYPE, ValaInvalidTypeClass)) typedef struct _ValaInvalidType ValaInvalidType; typedef struct _ValaInvalidTypeClass ValaInvalidTypeClass; typedef struct _ValaInvalidTypePrivate ValaInvalidTypePrivate; typedef struct _ValaLambdaExpressionPrivate ValaLambdaExpressionPrivate; typedef struct _ValaLocalVariablePrivate ValaLocalVariablePrivate; typedef struct _ValaLockStatementPrivate ValaLockStatementPrivate; typedef struct _ValaLoopPrivate ValaLoopPrivate; #define VALA_TYPE_MARKUP_READER (vala_markup_reader_get_type ()) #define VALA_MARKUP_READER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MARKUP_READER, ValaMarkupReader)) #define VALA_MARKUP_READER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MARKUP_READER, ValaMarkupReaderClass)) #define VALA_IS_MARKUP_READER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MARKUP_READER)) #define VALA_IS_MARKUP_READER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MARKUP_READER)) #define VALA_MARKUP_READER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MARKUP_READER, ValaMarkupReaderClass)) typedef struct _ValaMarkupReader ValaMarkupReader; typedef struct _ValaMarkupReaderClass ValaMarkupReaderClass; typedef struct _ValaMarkupReaderPrivate ValaMarkupReaderPrivate; #define VALA_TYPE_MARKUP_TOKEN_TYPE (vala_markup_token_type_get_type ()) typedef struct _ValaMemberAccessPrivate ValaMemberAccessPrivate; #define VALA_TYPE_MEMBER_INITIALIZER (vala_member_initializer_get_type ()) #define VALA_MEMBER_INITIALIZER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MEMBER_INITIALIZER, ValaMemberInitializer)) #define VALA_MEMBER_INITIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MEMBER_INITIALIZER, ValaMemberInitializerClass)) #define VALA_IS_MEMBER_INITIALIZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MEMBER_INITIALIZER)) #define VALA_IS_MEMBER_INITIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MEMBER_INITIALIZER)) #define VALA_MEMBER_INITIALIZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MEMBER_INITIALIZER, ValaMemberInitializerClass)) typedef struct _ValaMemberInitializer ValaMemberInitializer; typedef struct _ValaMemberInitializerClass ValaMemberInitializerClass; typedef struct _ValaMemberInitializerPrivate ValaMemberInitializerPrivate; typedef struct _ValaMethodCallPrivate ValaMethodCallPrivate; #define VALA_TYPE_METHOD_TYPE (vala_method_type_get_type ()) #define VALA_METHOD_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_METHOD_TYPE, ValaMethodType)) #define VALA_METHOD_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_METHOD_TYPE, ValaMethodTypeClass)) #define VALA_IS_METHOD_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_METHOD_TYPE)) #define VALA_IS_METHOD_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_METHOD_TYPE)) #define VALA_METHOD_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_METHOD_TYPE, ValaMethodTypeClass)) typedef struct _ValaMethodType ValaMethodType; typedef struct _ValaMethodTypeClass ValaMethodTypeClass; typedef struct _ValaMethodTypePrivate ValaMethodTypePrivate; typedef struct _ValaNamedArgumentPrivate ValaNamedArgumentPrivate; typedef struct _ValaNamespacePrivate ValaNamespacePrivate; typedef struct _ValaNullLiteralPrivate ValaNullLiteralPrivate; #define VALA_TYPE_NULL_TYPE (vala_null_type_get_type ()) #define VALA_NULL_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_NULL_TYPE, ValaNullType)) #define VALA_NULL_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_NULL_TYPE, ValaNullTypeClass)) #define VALA_IS_NULL_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_NULL_TYPE)) #define VALA_IS_NULL_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_NULL_TYPE)) #define VALA_NULL_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_NULL_TYPE, ValaNullTypeClass)) typedef struct _ValaNullType ValaNullType; typedef struct _ValaNullTypeClass ValaNullTypeClass; typedef struct _ValaNullTypePrivate ValaNullTypePrivate; typedef struct _ValaObjectCreationExpressionPrivate ValaObjectCreationExpressionPrivate; #define VALA_TYPE_OBJECT_TYPE (vala_object_type_get_type ()) #define VALA_OBJECT_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_OBJECT_TYPE, ValaObjectType)) #define VALA_OBJECT_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_OBJECT_TYPE, ValaObjectTypeClass)) #define VALA_IS_OBJECT_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_OBJECT_TYPE)) #define VALA_IS_OBJECT_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_OBJECT_TYPE)) #define VALA_OBJECT_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_OBJECT_TYPE, ValaObjectTypeClass)) typedef struct _ValaObjectType ValaObjectType; typedef struct _ValaObjectTypeClass ValaObjectTypeClass; typedef struct _ValaObjectTypePrivate ValaObjectTypePrivate; typedef struct _ValaParameterPrivate ValaParameterPrivate; #define VALA_TYPE_PARAMETER_DIRECTION (vala_parameter_direction_get_type ()) #define VALA_TYPE_PARSER (vala_parser_get_type ()) #define VALA_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PARSER, ValaParser)) #define VALA_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PARSER, ValaParserClass)) #define VALA_IS_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_PARSER)) #define VALA_IS_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_PARSER)) #define VALA_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_PARSER, ValaParserClass)) typedef struct _ValaParser ValaParser; typedef struct _ValaParserClass ValaParserClass; typedef struct _ValaParserPrivate ValaParserPrivate; typedef struct _ValaPhiFunctionPrivate ValaPhiFunctionPrivate; typedef struct _ValaPointerIndirectionPrivate ValaPointerIndirectionPrivate; #define VALA_TYPE_POINTER_TYPE (vala_pointer_type_get_type ()) #define VALA_POINTER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_POINTER_TYPE, ValaPointerType)) #define VALA_POINTER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_POINTER_TYPE, ValaPointerTypeClass)) #define VALA_IS_POINTER_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_POINTER_TYPE)) #define VALA_IS_POINTER_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_POINTER_TYPE)) #define VALA_POINTER_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_POINTER_TYPE, ValaPointerTypeClass)) typedef struct _ValaPointerType ValaPointerType; typedef struct _ValaPointerTypeClass ValaPointerTypeClass; typedef struct _ValaPointerTypePrivate ValaPointerTypePrivate; typedef struct _ValaPostfixExpressionPrivate ValaPostfixExpressionPrivate; typedef struct _ValaPropertyAccessorPrivate ValaPropertyAccessorPrivate; typedef struct _ValaRealLiteralPrivate ValaRealLiteralPrivate; typedef struct _ValaReferenceTransferExpressionPrivate ValaReferenceTransferExpressionPrivate; typedef struct _ValaRegexLiteralPrivate ValaRegexLiteralPrivate; typedef struct _ValaReportPrivate ValaReportPrivate; #define VALA_REPORT_TYPE_COLORED (vala_report_colored_get_type ()) typedef struct _ValaReturnStatementPrivate ValaReturnStatementPrivate; #define VALA_TYPE_SCANNER (vala_scanner_get_type ()) #define VALA_SCANNER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SCANNER, ValaScanner)) #define VALA_SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SCANNER, ValaScannerClass)) #define VALA_IS_SCANNER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SCANNER)) #define VALA_IS_SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SCANNER)) #define VALA_SCANNER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SCANNER, ValaScannerClass)) typedef struct _ValaScanner ValaScanner; typedef struct _ValaScannerClass ValaScannerClass; typedef struct _ValaScannerPrivate ValaScannerPrivate; #define VALA_TYPE_TOKEN_TYPE (vala_token_type_get_type ()) typedef struct _ValaScopePrivate ValaScopePrivate; typedef struct _ValaSemanticAnalyzerPrivate ValaSemanticAnalyzerPrivate; #define VALA_TYPE_STRUCT_VALUE_TYPE (vala_struct_value_type_get_type ()) #define VALA_STRUCT_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRUCT_VALUE_TYPE, ValaStructValueType)) #define VALA_STRUCT_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRUCT_VALUE_TYPE, ValaStructValueTypeClass)) #define VALA_IS_STRUCT_VALUE_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRUCT_VALUE_TYPE)) #define VALA_IS_STRUCT_VALUE_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRUCT_VALUE_TYPE)) #define VALA_STRUCT_VALUE_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRUCT_VALUE_TYPE, ValaStructValueTypeClass)) typedef struct _ValaStructValueType ValaStructValueType; typedef struct _ValaStructValueTypeClass ValaStructValueTypeClass; #define VALA_TYPE_SIGNAL_TYPE (vala_signal_type_get_type ()) #define VALA_SIGNAL_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SIGNAL_TYPE, ValaSignalType)) #define VALA_SIGNAL_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SIGNAL_TYPE, ValaSignalTypeClass)) #define VALA_IS_SIGNAL_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SIGNAL_TYPE)) #define VALA_IS_SIGNAL_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SIGNAL_TYPE)) #define VALA_SIGNAL_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SIGNAL_TYPE, ValaSignalTypeClass)) typedef struct _ValaSignalType ValaSignalType; typedef struct _ValaSignalTypeClass ValaSignalTypeClass; typedef struct _ValaSignalTypePrivate ValaSignalTypePrivate; typedef struct _ValaSizeofExpressionPrivate ValaSizeofExpressionPrivate; typedef struct _ValaSliceExpressionPrivate ValaSliceExpressionPrivate; typedef struct _ValaSourceFilePrivate ValaSourceFilePrivate; #define VALA_TYPE_SOURCE_FILE_TYPE (vala_source_file_type_get_type ()) typedef struct _ValaSourceReferencePrivate ValaSourceReferencePrivate; #define VALA_TYPE_STATEMENT_LIST (vala_statement_list_get_type ()) #define VALA_STATEMENT_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STATEMENT_LIST, ValaStatementList)) #define VALA_STATEMENT_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STATEMENT_LIST, ValaStatementListClass)) #define VALA_IS_STATEMENT_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STATEMENT_LIST)) #define VALA_IS_STATEMENT_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STATEMENT_LIST)) #define VALA_STATEMENT_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STATEMENT_LIST, ValaStatementListClass)) typedef struct _ValaStatementList ValaStatementList; typedef struct _ValaStatementListClass ValaStatementListClass; typedef struct _ValaStatementListPrivate ValaStatementListPrivate; typedef struct _ValaStringLiteralPrivate ValaStringLiteralPrivate; typedef struct _ValaStructPrivate ValaStructPrivate; typedef struct _ValaStructValueTypePrivate ValaStructValueTypePrivate; typedef struct _ValaSwitchLabelPrivate ValaSwitchLabelPrivate; typedef struct _ValaSwitchSectionPrivate ValaSwitchSectionPrivate; typedef struct _ValaSwitchStatementPrivate ValaSwitchStatementPrivate; #define VALA_TYPE_SYMBOL_ACCESSIBILITY (vala_symbol_accessibility_get_type ()) #define VALA_TYPE_VERSION_ATTRIBUTE (vala_version_attribute_get_type ()) #define VALA_VERSION_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_VERSION_ATTRIBUTE, ValaVersionAttribute)) #define VALA_VERSION_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_VERSION_ATTRIBUTE, ValaVersionAttributeClass)) #define VALA_IS_VERSION_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_VERSION_ATTRIBUTE)) #define VALA_IS_VERSION_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_VERSION_ATTRIBUTE)) #define VALA_VERSION_ATTRIBUTE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_VERSION_ATTRIBUTE, ValaVersionAttributeClass)) typedef struct _ValaVersionAttribute ValaVersionAttribute; typedef struct _ValaVersionAttributeClass ValaVersionAttributeClass; typedef struct _ValaSymbolResolverPrivate ValaSymbolResolverPrivate; typedef struct _ValaTargetValuePrivate ValaTargetValuePrivate; typedef struct _ValaTemplatePrivate ValaTemplatePrivate; typedef struct _ValaThrowStatementPrivate ValaThrowStatementPrivate; typedef struct _ValaTryStatementPrivate ValaTryStatementPrivate; typedef struct _ValaTuplePrivate ValaTuplePrivate; typedef struct _ValaTypeCheckPrivate ValaTypeCheckPrivate; typedef struct _ValaTypeofExpressionPrivate ValaTypeofExpressionPrivate; typedef struct _ValaTypeParameterPrivate ValaTypeParameterPrivate; typedef struct _ValaUnaryExpressionPrivate ValaUnaryExpressionPrivate; #define VALA_TYPE_UNARY_OPERATOR (vala_unary_operator_get_type ()) typedef struct _ValaUnlockStatementPrivate ValaUnlockStatementPrivate; #define VALA_TYPE_UNRESOLVED_SYMBOL (vala_unresolved_symbol_get_type ()) #define VALA_UNRESOLVED_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbol)) #define VALA_UNRESOLVED_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbolClass)) #define VALA_IS_UNRESOLVED_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNRESOLVED_SYMBOL)) #define VALA_IS_UNRESOLVED_SYMBOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNRESOLVED_SYMBOL)) #define VALA_UNRESOLVED_SYMBOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNRESOLVED_SYMBOL, ValaUnresolvedSymbolClass)) typedef struct _ValaUnresolvedSymbol ValaUnresolvedSymbol; typedef struct _ValaUnresolvedSymbolClass ValaUnresolvedSymbolClass; typedef struct _ValaUnresolvedSymbolPrivate ValaUnresolvedSymbolPrivate; #define VALA_TYPE_UNRESOLVED_TYPE (vala_unresolved_type_get_type ()) #define VALA_UNRESOLVED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedType)) #define VALA_UNRESOLVED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedTypeClass)) #define VALA_IS_UNRESOLVED_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_UNRESOLVED_TYPE)) #define VALA_IS_UNRESOLVED_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_UNRESOLVED_TYPE)) #define VALA_UNRESOLVED_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_UNRESOLVED_TYPE, ValaUnresolvedTypeClass)) typedef struct _ValaUnresolvedType ValaUnresolvedType; typedef struct _ValaUnresolvedTypeClass ValaUnresolvedTypeClass; typedef struct _ValaUnresolvedTypePrivate ValaUnresolvedTypePrivate; typedef struct _ValaUsedAttrPrivate ValaUsedAttrPrivate; typedef struct _ValaUsingDirectivePrivate ValaUsingDirectivePrivate; typedef struct _ValaVersionAttributePrivate ValaVersionAttributePrivate; #define VALA_TYPE_VOID_TYPE (vala_void_type_get_type ()) #define VALA_VOID_TYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_VOID_TYPE, ValaVoidType)) #define VALA_VOID_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_VOID_TYPE, ValaVoidTypeClass)) #define VALA_IS_VOID_TYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_VOID_TYPE)) #define VALA_IS_VOID_TYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_VOID_TYPE)) #define VALA_VOID_TYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_VOID_TYPE, ValaVoidTypeClass)) typedef struct _ValaVoidType ValaVoidType; typedef struct _ValaVoidTypeClass ValaVoidTypeClass; typedef struct _ValaVoidTypePrivate ValaVoidTypePrivate; typedef struct _ValaWhileStatementPrivate ValaWhileStatementPrivate; typedef struct _ValaYieldStatementPrivate ValaYieldStatementPrivate; struct _ValaCodeNode { GTypeInstance parent_instance; volatile int ref_count; ValaCodeNodePrivate * priv; GList* attributes; }; struct _ValaCodeNodeClass { GTypeClass parent_class; void (*finalize) (ValaCodeNode *self); void (*accept) (ValaCodeNode* self, ValaCodeVisitor* visitor); void (*accept_children) (ValaCodeNode* self, ValaCodeVisitor* visitor); gboolean (*check) (ValaCodeNode* self, ValaCodeContext* context); void (*emit) (ValaCodeNode* self, ValaCodeGenerator* codegen); void (*replace_type) (ValaCodeNode* self, ValaDataType* old_type, ValaDataType* new_type); void (*replace_expression) (ValaCodeNode* self, ValaExpression* old_node, ValaExpression* new_node); gchar* (*to_string) (ValaCodeNode* self); void (*get_defined_variables) (ValaCodeNode* self, ValaCollection* collection); void (*get_used_variables) (ValaCodeNode* self, ValaCollection* collection); }; struct _ValaExpression { ValaCodeNode parent_instance; ValaExpressionPrivate * priv; }; struct _ValaExpressionClass { ValaCodeNodeClass parent_class; gboolean (*is_constant) (ValaExpression* self); gboolean (*is_pure) (ValaExpression* self); gboolean (*is_non_null) (ValaExpression* self); gboolean (*is_accessible) (ValaExpression* self, ValaSymbol* sym); }; struct _ValaAddressofExpression { ValaExpression parent_instance; ValaAddressofExpressionPrivate * priv; }; struct _ValaAddressofExpressionClass { ValaExpressionClass parent_class; }; struct _ValaSymbol { ValaCodeNode parent_instance; ValaSymbolPrivate * priv; }; struct _ValaSymbolClass { ValaCodeNodeClass parent_class; gboolean (*is_instance_member) (ValaSymbol* self); gboolean (*is_class_member) (ValaSymbol* self); void (*add_namespace) (ValaSymbol* self, ValaNamespace* ns); void (*add_class) (ValaSymbol* self, ValaClass* cl); void (*add_interface) (ValaSymbol* self, ValaInterface* iface); void (*add_struct) (ValaSymbol* self, ValaStruct* st); void (*add_enum) (ValaSymbol* self, ValaEnum* en); void (*add_error_domain) (ValaSymbol* self, ValaErrorDomain* edomain); void (*add_delegate) (ValaSymbol* self, ValaDelegate* d); void (*add_constant) (ValaSymbol* self, ValaConstant* constant); void (*add_field) (ValaSymbol* self, ValaField* f); void (*add_method) (ValaSymbol* self, ValaMethod* m); void (*add_property) (ValaSymbol* self, ValaProperty* prop); void (*add_signal) (ValaSymbol* self, ValaSignal* sig); void (*add_constructor) (ValaSymbol* self, ValaConstructor* c); void (*add_destructor) (ValaSymbol* self, ValaDestructor* d); }; struct _ValaSubroutine { ValaSymbol parent_instance; ValaSubroutinePrivate * priv; }; struct _ValaSubroutineClass { ValaSymbolClass parent_class; gboolean (*get_has_result) (ValaSubroutine* self); }; struct _ValaCallableIface { GTypeInterface parent_iface; void (*add_parameter) (ValaCallable* self, ValaParameter* param); ValaList* (*get_parameters) (ValaCallable* self); ValaDataType* (*get_return_type) (ValaCallable* self); void (*set_return_type) (ValaCallable* self, ValaDataType* value); }; struct _ValaMethod { ValaSubroutine parent_instance; ValaMethodPrivate * priv; }; struct _ValaMethodClass { ValaSubroutineClass parent_class; }; struct _ValaArrayCopyMethod { ValaMethod parent_instance; ValaArrayCopyMethodPrivate * priv; }; struct _ValaArrayCopyMethodClass { ValaMethodClass parent_class; }; struct _ValaArrayCreationExpression { ValaExpression parent_instance; ValaArrayCreationExpressionPrivate * priv; }; struct _ValaArrayCreationExpressionClass { ValaExpressionClass parent_class; }; struct _ValaVariable { ValaSymbol parent_instance; ValaVariablePrivate * priv; }; struct _ValaVariableClass { ValaSymbolClass parent_class; }; struct _ValaLockableIface { GTypeInterface parent_iface; gboolean (*get_lock_used) (ValaLockable* self); void (*set_lock_used) (ValaLockable* self, gboolean used); }; struct _ValaField { ValaVariable parent_instance; ValaFieldPrivate * priv; }; struct _ValaFieldClass { ValaVariableClass parent_class; }; struct _ValaArrayLengthField { ValaField parent_instance; ValaArrayLengthFieldPrivate * priv; }; struct _ValaArrayLengthFieldClass { ValaFieldClass parent_class; }; struct _ValaArrayMoveMethod { ValaMethod parent_instance; ValaArrayMoveMethodPrivate * priv; }; struct _ValaArrayMoveMethodClass { ValaMethodClass parent_class; }; struct _ValaArrayResizeMethod { ValaMethod parent_instance; ValaArrayResizeMethodPrivate * priv; }; struct _ValaArrayResizeMethodClass { ValaMethodClass parent_class; }; struct _ValaDataType { ValaCodeNode parent_instance; ValaDataTypePrivate * priv; }; struct _ValaDataTypeClass { ValaCodeNodeClass parent_class; gchar* (*to_qualified_string) (ValaDataType* self, ValaScope* scope); ValaDataType* (*copy) (ValaDataType* self); gboolean (*equals) (ValaDataType* self, ValaDataType* type2); gboolean (*stricter) (ValaDataType* self, ValaDataType* type2); gboolean (*compatible) (ValaDataType* self, ValaDataType* target_type); gboolean (*is_invokable) (ValaDataType* self); ValaDataType* (*get_return_type) (ValaDataType* self); ValaList* (*get_parameters) (ValaDataType* self); gboolean (*is_reference_type_or_type_parameter) (ValaDataType* self); gboolean (*is_array) (ValaDataType* self); gboolean (*is_accessible) (ValaDataType* self, ValaSymbol* sym); ValaSymbol* (*get_member) (ValaDataType* self, const gchar* member_name); ValaSymbol* (*get_pointer_member) (ValaDataType* self, const gchar* member_name); gboolean (*is_real_struct_type) (ValaDataType* self); gboolean (*is_disposable) (ValaDataType* self); ValaDataType* (*get_actual_type) (ValaDataType* self, ValaDataType* derived_instance_type, ValaList* method_type_arguments, ValaCodeNode* node_reference); ValaDataType* (*infer_type_argument) (ValaDataType* self, ValaTypeParameter* type_param, ValaDataType* value_type); gchar* (*to_prototype_string) (ValaDataType* self, const gchar* override_name); }; struct _ValaReferenceType { ValaDataType parent_instance; ValaReferenceTypePrivate * priv; }; struct _ValaReferenceTypeClass { ValaDataTypeClass parent_class; }; struct _ValaArrayType { ValaReferenceType parent_instance; ValaArrayTypePrivate * priv; }; struct _ValaArrayTypeClass { ValaReferenceTypeClass parent_class; }; struct _ValaAssignment { ValaExpression parent_instance; ValaAssignmentPrivate * priv; }; struct _ValaAssignmentClass { ValaExpressionClass parent_class; }; typedef enum { VALA_ASSIGNMENT_OPERATOR_NONE, VALA_ASSIGNMENT_OPERATOR_SIMPLE, VALA_ASSIGNMENT_OPERATOR_BITWISE_OR, VALA_ASSIGNMENT_OPERATOR_BITWISE_AND, VALA_ASSIGNMENT_OPERATOR_BITWISE_XOR, VALA_ASSIGNMENT_OPERATOR_ADD, VALA_ASSIGNMENT_OPERATOR_SUB, VALA_ASSIGNMENT_OPERATOR_MUL, VALA_ASSIGNMENT_OPERATOR_DIV, VALA_ASSIGNMENT_OPERATOR_PERCENT, VALA_ASSIGNMENT_OPERATOR_SHIFT_LEFT, VALA_ASSIGNMENT_OPERATOR_SHIFT_RIGHT } ValaAssignmentOperator; struct _ValaAttribute { ValaCodeNode parent_instance; ValaAttributePrivate * priv; }; struct _ValaAttributeClass { ValaCodeNodeClass parent_class; }; struct _ValaBaseAccess { ValaExpression parent_instance; ValaBaseAccessPrivate * priv; }; struct _ValaBaseAccessClass { ValaExpressionClass parent_class; }; struct _ValaBasicBlock { GTypeInstance parent_instance; volatile int ref_count; ValaBasicBlockPrivate * priv; }; struct _ValaBasicBlockClass { GTypeClass parent_class; void (*finalize) (ValaBasicBlock *self); }; struct _ValaBinaryExpression { ValaExpression parent_instance; ValaBinaryExpressionPrivate * priv; }; struct _ValaBinaryExpressionClass { ValaExpressionClass parent_class; }; typedef enum { VALA_BINARY_OPERATOR_NONE, VALA_BINARY_OPERATOR_PLUS, VALA_BINARY_OPERATOR_MINUS, VALA_BINARY_OPERATOR_MUL, VALA_BINARY_OPERATOR_DIV, VALA_BINARY_OPERATOR_MOD, VALA_BINARY_OPERATOR_SHIFT_LEFT, VALA_BINARY_OPERATOR_SHIFT_RIGHT, VALA_BINARY_OPERATOR_LESS_THAN, VALA_BINARY_OPERATOR_GREATER_THAN, VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL, VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL, VALA_BINARY_OPERATOR_EQUALITY, VALA_BINARY_OPERATOR_INEQUALITY, VALA_BINARY_OPERATOR_BITWISE_AND, VALA_BINARY_OPERATOR_BITWISE_OR, VALA_BINARY_OPERATOR_BITWISE_XOR, VALA_BINARY_OPERATOR_AND, VALA_BINARY_OPERATOR_OR, VALA_BINARY_OPERATOR_IN, VALA_BINARY_OPERATOR_COALESCE } ValaBinaryOperator; struct _ValaStatementIface { GTypeInterface parent_iface; }; struct _ValaBlock { ValaSymbol parent_instance; ValaBlockPrivate * priv; }; struct _ValaBlockClass { ValaSymbolClass parent_class; }; struct _ValaLiteral { ValaExpression parent_instance; ValaLiteralPrivate * priv; }; struct _ValaLiteralClass { ValaExpressionClass parent_class; }; struct _ValaBooleanLiteral { ValaLiteral parent_instance; ValaBooleanLiteralPrivate * priv; }; struct _ValaBooleanLiteralClass { ValaLiteralClass parent_class; }; struct _ValaValueType { ValaDataType parent_instance; ValaValueTypePrivate * priv; }; struct _ValaValueTypeClass { ValaDataTypeClass parent_class; }; struct _ValaBooleanType { ValaValueType parent_instance; ValaBooleanTypePrivate * priv; }; struct _ValaBooleanTypeClass { ValaValueTypeClass parent_class; }; struct _ValaBreakStatement { ValaCodeNode parent_instance; ValaBreakStatementPrivate * priv; }; struct _ValaBreakStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaCallableType { ValaDataType parent_instance; ValaCallableTypePrivate * priv; }; struct _ValaCallableTypeClass { ValaDataTypeClass parent_class; }; struct _ValaCastExpression { ValaExpression parent_instance; ValaCastExpressionPrivate * priv; }; struct _ValaCastExpressionClass { ValaExpressionClass parent_class; }; struct _ValaCatchClause { ValaCodeNode parent_instance; ValaCatchClausePrivate * priv; }; struct _ValaCatchClauseClass { ValaCodeNodeClass parent_class; }; struct _ValaCharacterLiteral { ValaLiteral parent_instance; ValaCharacterLiteralPrivate * priv; }; struct _ValaCharacterLiteralClass { ValaLiteralClass parent_class; }; struct _ValaTypeSymbol { ValaSymbol parent_instance; ValaTypeSymbolPrivate * priv; }; struct _ValaTypeSymbolClass { ValaSymbolClass parent_class; gboolean (*is_reference_type) (ValaTypeSymbol* self); gboolean (*is_subtype_of) (ValaTypeSymbol* self, ValaTypeSymbol* t); gint (*get_type_parameter_index) (ValaTypeSymbol* self, const gchar* name); }; struct _ValaObjectTypeSymbol { ValaTypeSymbol parent_instance; ValaObjectTypeSymbolPrivate * priv; }; struct _ValaObjectTypeSymbolClass { ValaTypeSymbolClass parent_class; ValaList* (*get_methods) (ValaObjectTypeSymbol* self); ValaList* (*get_signals) (ValaObjectTypeSymbol* self); ValaList* (*get_properties) (ValaObjectTypeSymbol* self); }; struct _ValaClass { ValaObjectTypeSymbol parent_instance; ValaClassPrivate * priv; }; struct _ValaClassClass { ValaObjectTypeSymbolClass parent_class; }; struct _ValaClassType { ValaReferenceType parent_instance; ValaClassTypePrivate * priv; }; struct _ValaClassTypeClass { ValaReferenceTypeClass parent_class; }; struct _ValaCodeContext { GTypeInstance parent_instance; volatile int ref_count; ValaCodeContextPrivate * priv; }; struct _ValaCodeContextClass { GTypeClass parent_class; void (*finalize) (ValaCodeContext *self); }; typedef enum { VALA_PROFILE_GOBJECT } ValaProfile; struct _ValaCodeVisitor { GTypeInstance parent_instance; volatile int ref_count; ValaCodeVisitorPrivate * priv; }; struct _ValaCodeVisitorClass { GTypeClass parent_class; void (*finalize) (ValaCodeVisitor *self); void (*visit_source_file) (ValaCodeVisitor* self, ValaSourceFile* source_file); void (*visit_namespace) (ValaCodeVisitor* self, ValaNamespace* ns); void (*visit_class) (ValaCodeVisitor* self, ValaClass* cl); void (*visit_struct) (ValaCodeVisitor* self, ValaStruct* st); void (*visit_interface) (ValaCodeVisitor* self, ValaInterface* iface); void (*visit_enum) (ValaCodeVisitor* self, ValaEnum* en); void (*visit_enum_value) (ValaCodeVisitor* self, ValaEnumValue* ev); void (*visit_error_domain) (ValaCodeVisitor* self, ValaErrorDomain* edomain); void (*visit_error_code) (ValaCodeVisitor* self, ValaErrorCode* ecode); void (*visit_delegate) (ValaCodeVisitor* self, ValaDelegate* d); void (*visit_constant) (ValaCodeVisitor* self, ValaConstant* c); void (*visit_field) (ValaCodeVisitor* self, ValaField* f); void (*visit_method) (ValaCodeVisitor* self, ValaMethod* m); void (*visit_creation_method) (ValaCodeVisitor* self, ValaCreationMethod* m); void (*visit_formal_parameter) (ValaCodeVisitor* self, ValaParameter* p); void (*visit_property) (ValaCodeVisitor* self, ValaProperty* prop); void (*visit_property_accessor) (ValaCodeVisitor* self, ValaPropertyAccessor* acc); void (*visit_signal) (ValaCodeVisitor* self, ValaSignal* sig); void (*visit_constructor) (ValaCodeVisitor* self, ValaConstructor* c); void (*visit_destructor) (ValaCodeVisitor* self, ValaDestructor* d); void (*visit_type_parameter) (ValaCodeVisitor* self, ValaTypeParameter* p); void (*visit_using_directive) (ValaCodeVisitor* self, ValaUsingDirective* ns); void (*visit_data_type) (ValaCodeVisitor* self, ValaDataType* type); void (*visit_block) (ValaCodeVisitor* self, ValaBlock* b); void (*visit_empty_statement) (ValaCodeVisitor* self, ValaEmptyStatement* stmt); void (*visit_declaration_statement) (ValaCodeVisitor* self, ValaDeclarationStatement* stmt); void (*visit_local_variable) (ValaCodeVisitor* self, ValaLocalVariable* local); void (*visit_initializer_list) (ValaCodeVisitor* self, ValaInitializerList* list); void (*visit_expression_statement) (ValaCodeVisitor* self, ValaExpressionStatement* stmt); void (*visit_if_statement) (ValaCodeVisitor* self, ValaIfStatement* stmt); void (*visit_switch_statement) (ValaCodeVisitor* self, ValaSwitchStatement* stmt); void (*visit_switch_section) (ValaCodeVisitor* self, ValaSwitchSection* section); void (*visit_switch_label) (ValaCodeVisitor* self, ValaSwitchLabel* label); void (*visit_loop) (ValaCodeVisitor* self, ValaLoop* stmt); void (*visit_while_statement) (ValaCodeVisitor* self, ValaWhileStatement* stmt); void (*visit_do_statement) (ValaCodeVisitor* self, ValaDoStatement* stmt); void (*visit_for_statement) (ValaCodeVisitor* self, ValaForStatement* stmt); void (*visit_foreach_statement) (ValaCodeVisitor* self, ValaForeachStatement* stmt); void (*visit_break_statement) (ValaCodeVisitor* self, ValaBreakStatement* stmt); void (*visit_continue_statement) (ValaCodeVisitor* self, ValaContinueStatement* stmt); void (*visit_return_statement) (ValaCodeVisitor* self, ValaReturnStatement* stmt); void (*visit_yield_statement) (ValaCodeVisitor* self, ValaYieldStatement* y); void (*visit_throw_statement) (ValaCodeVisitor* self, ValaThrowStatement* stmt); void (*visit_try_statement) (ValaCodeVisitor* self, ValaTryStatement* stmt); void (*visit_catch_clause) (ValaCodeVisitor* self, ValaCatchClause* clause); void (*visit_lock_statement) (ValaCodeVisitor* self, ValaLockStatement* stmt); void (*visit_unlock_statement) (ValaCodeVisitor* self, ValaUnlockStatement* stmt); void (*visit_delete_statement) (ValaCodeVisitor* self, ValaDeleteStatement* stmt); void (*visit_expression) (ValaCodeVisitor* self, ValaExpression* expr); void (*visit_array_creation_expression) (ValaCodeVisitor* self, ValaArrayCreationExpression* expr); void (*visit_boolean_literal) (ValaCodeVisitor* self, ValaBooleanLiteral* lit); void (*visit_character_literal) (ValaCodeVisitor* self, ValaCharacterLiteral* lit); void (*visit_integer_literal) (ValaCodeVisitor* self, ValaIntegerLiteral* lit); void (*visit_real_literal) (ValaCodeVisitor* self, ValaRealLiteral* lit); void (*visit_regex_literal) (ValaCodeVisitor* self, ValaRegexLiteral* lit); void (*visit_string_literal) (ValaCodeVisitor* self, ValaStringLiteral* lit); void (*visit_template) (ValaCodeVisitor* self, ValaTemplate* tmpl); void (*visit_tuple) (ValaCodeVisitor* self, ValaTuple* tuple); void (*visit_null_literal) (ValaCodeVisitor* self, ValaNullLiteral* lit); void (*visit_member_access) (ValaCodeVisitor* self, ValaMemberAccess* expr); void (*visit_method_call) (ValaCodeVisitor* self, ValaMethodCall* expr); void (*visit_element_access) (ValaCodeVisitor* self, ValaElementAccess* expr); void (*visit_slice_expression) (ValaCodeVisitor* self, ValaSliceExpression* expr); void (*visit_base_access) (ValaCodeVisitor* self, ValaBaseAccess* expr); void (*visit_postfix_expression) (ValaCodeVisitor* self, ValaPostfixExpression* expr); void (*visit_object_creation_expression) (ValaCodeVisitor* self, ValaObjectCreationExpression* expr); void (*visit_sizeof_expression) (ValaCodeVisitor* self, ValaSizeofExpression* expr); void (*visit_typeof_expression) (ValaCodeVisitor* self, ValaTypeofExpression* expr); void (*visit_unary_expression) (ValaCodeVisitor* self, ValaUnaryExpression* expr); void (*visit_cast_expression) (ValaCodeVisitor* self, ValaCastExpression* expr); void (*visit_named_argument) (ValaCodeVisitor* self, ValaNamedArgument* expr); void (*visit_pointer_indirection) (ValaCodeVisitor* self, ValaPointerIndirection* expr); void (*visit_addressof_expression) (ValaCodeVisitor* self, ValaAddressofExpression* expr); void (*visit_reference_transfer_expression) (ValaCodeVisitor* self, ValaReferenceTransferExpression* expr); void (*visit_binary_expression) (ValaCodeVisitor* self, ValaBinaryExpression* expr); void (*visit_type_check) (ValaCodeVisitor* self, ValaTypeCheck* expr); void (*visit_conditional_expression) (ValaCodeVisitor* self, ValaConditionalExpression* expr); void (*visit_lambda_expression) (ValaCodeVisitor* self, ValaLambdaExpression* expr); void (*visit_assignment) (ValaCodeVisitor* self, ValaAssignment* a); void (*visit_end_full_expression) (ValaCodeVisitor* self, ValaExpression* expr); }; struct _ValaCodeGenerator { ValaCodeVisitor parent_instance; ValaCodeGeneratorPrivate * priv; }; struct _ValaCodeGeneratorClass { ValaCodeVisitorClass parent_class; void (*emit) (ValaCodeGenerator* self, ValaCodeContext* context); ValaTargetValue* (*load_local) (ValaCodeGenerator* self, ValaLocalVariable* local); void (*store_local) (ValaCodeGenerator* self, ValaLocalVariable* local, ValaTargetValue* value, gboolean initializer, ValaSourceReference* source_reference); ValaTargetValue* (*load_parameter) (ValaCodeGenerator* self, ValaParameter* param); void (*store_parameter) (ValaCodeGenerator* self, ValaParameter* param, ValaTargetValue* value, gboolean capturing_parameter, ValaSourceReference* source_reference); ValaTargetValue* (*load_field) (ValaCodeGenerator* self, ValaField* field, ValaTargetValue* instance); void (*store_field) (ValaCodeGenerator* self, ValaField* field, ValaTargetValue* instance, ValaTargetValue* value, ValaSourceReference* source_reference); }; struct _ValaAttributeCache { GTypeInstance parent_instance; volatile int ref_count; ValaAttributeCachePrivate * priv; }; struct _ValaAttributeCacheClass { GTypeClass parent_class; void (*finalize) (ValaAttributeCache *self); }; struct _ValaCodeWriter { ValaCodeVisitor parent_instance; ValaCodeWriterPrivate * priv; }; struct _ValaCodeWriterClass { ValaCodeVisitorClass parent_class; }; typedef enum { VALA_CODE_WRITER_TYPE_EXTERNAL, VALA_CODE_WRITER_TYPE_INTERNAL, VALA_CODE_WRITER_TYPE_FAST, VALA_CODE_WRITER_TYPE_DUMP } ValaCodeWriterType; struct _ValaComment { GTypeInstance parent_instance; volatile int ref_count; ValaCommentPrivate * priv; }; struct _ValaCommentClass { GTypeClass parent_class; void (*finalize) (ValaComment *self); }; struct _ValaGirComment { ValaComment parent_instance; ValaGirCommentPrivate * priv; }; struct _ValaGirCommentClass { ValaCommentClass parent_class; }; struct _ValaConditionalExpression { ValaExpression parent_instance; ValaConditionalExpressionPrivate * priv; }; struct _ValaConditionalExpressionClass { ValaExpressionClass parent_class; }; struct _ValaConstant { ValaSymbol parent_instance; ValaConstantPrivate * priv; }; struct _ValaConstantClass { ValaSymbolClass parent_class; }; struct _ValaConstructor { ValaSubroutine parent_instance; ValaConstructorPrivate * priv; }; struct _ValaConstructorClass { ValaSubroutineClass parent_class; }; typedef enum { VALA_MEMBER_BINDING_INSTANCE, VALA_MEMBER_BINDING_CLASS, VALA_MEMBER_BINDING_STATIC } ValaMemberBinding; struct _ValaContinueStatement { ValaCodeNode parent_instance; ValaContinueStatementPrivate * priv; }; struct _ValaContinueStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaCreationMethod { ValaMethod parent_instance; ValaCreationMethodPrivate * priv; }; struct _ValaCreationMethodClass { ValaMethodClass parent_class; }; struct _ValaDeclarationStatement { ValaCodeNode parent_instance; ValaDeclarationStatementPrivate * priv; }; struct _ValaDeclarationStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaDelegate { ValaTypeSymbol parent_instance; ValaDelegatePrivate * priv; }; struct _ValaDelegateClass { ValaTypeSymbolClass parent_class; }; struct _ValaDelegateType { ValaCallableType parent_instance; ValaDelegateTypePrivate * priv; }; struct _ValaDelegateTypeClass { ValaCallableTypeClass parent_class; }; struct _ValaDeleteStatement { ValaCodeNode parent_instance; ValaDeleteStatementPrivate * priv; }; struct _ValaDeleteStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaDestructor { ValaSubroutine parent_instance; ValaDestructorPrivate * priv; }; struct _ValaDestructorClass { ValaSubroutineClass parent_class; }; struct _ValaDoStatement { ValaCodeNode parent_instance; ValaDoStatementPrivate * priv; }; struct _ValaDoStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaDynamicMethod { ValaMethod parent_instance; ValaDynamicMethodPrivate * priv; }; struct _ValaDynamicMethodClass { ValaMethodClass parent_class; }; struct _ValaProperty { ValaSymbol parent_instance; ValaPropertyPrivate * priv; }; struct _ValaPropertyClass { ValaSymbolClass parent_class; }; struct _ValaDynamicProperty { ValaProperty parent_instance; ValaDynamicPropertyPrivate * priv; }; struct _ValaDynamicPropertyClass { ValaPropertyClass parent_class; }; struct _ValaSignal { ValaSymbol parent_instance; ValaSignalPrivate * priv; }; struct _ValaSignalClass { ValaSymbolClass parent_class; }; struct _ValaDynamicSignal { ValaSignal parent_instance; ValaDynamicSignalPrivate * priv; }; struct _ValaDynamicSignalClass { ValaSignalClass parent_class; }; struct _ValaElementAccess { ValaExpression parent_instance; ValaElementAccessPrivate * priv; }; struct _ValaElementAccessClass { ValaExpressionClass parent_class; }; struct _ValaEmptyStatement { ValaCodeNode parent_instance; ValaEmptyStatementPrivate * priv; }; struct _ValaEmptyStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaEnum { ValaTypeSymbol parent_instance; ValaEnumPrivate * priv; }; struct _ValaEnumClass { ValaTypeSymbolClass parent_class; }; struct _ValaEnumValue { ValaConstant parent_instance; ValaEnumValuePrivate * priv; }; struct _ValaEnumValueClass { ValaConstantClass parent_class; }; struct _ValaEnumValueType { ValaValueType parent_instance; ValaEnumValueTypePrivate * priv; }; struct _ValaEnumValueTypeClass { ValaValueTypeClass parent_class; }; struct _ValaErrorCode { ValaTypeSymbol parent_instance; ValaErrorCodePrivate * priv; }; struct _ValaErrorCodeClass { ValaTypeSymbolClass parent_class; }; struct _ValaErrorDomain { ValaTypeSymbol parent_instance; ValaErrorDomainPrivate * priv; }; struct _ValaErrorDomainClass { ValaTypeSymbolClass parent_class; }; struct _ValaErrorType { ValaReferenceType parent_instance; ValaErrorTypePrivate * priv; }; struct _ValaErrorTypeClass { ValaReferenceTypeClass parent_class; }; struct _ValaExpressionStatement { ValaCodeNode parent_instance; ValaExpressionStatementPrivate * priv; }; struct _ValaExpressionStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaFieldPrototype { ValaDataType parent_instance; ValaFieldPrototypePrivate * priv; }; struct _ValaFieldPrototypeClass { ValaDataTypeClass parent_class; }; struct _ValaFloatingType { ValaValueType parent_instance; ValaFloatingTypePrivate * priv; }; struct _ValaFloatingTypeClass { ValaValueTypeClass parent_class; }; struct _ValaFlowAnalyzer { ValaCodeVisitor parent_instance; ValaFlowAnalyzerPrivate * priv; }; struct _ValaFlowAnalyzerClass { ValaCodeVisitorClass parent_class; }; struct _ValaForeachStatement { ValaBlock parent_instance; ValaForeachStatementPrivate * priv; }; struct _ValaForeachStatementClass { ValaBlockClass parent_class; }; struct _ValaForStatement { ValaCodeNode parent_instance; ValaForStatementPrivate * priv; }; struct _ValaForStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaGirParser { ValaCodeVisitor parent_instance; ValaGirParserPrivate * priv; }; struct _ValaGirParserClass { ValaCodeVisitorClass parent_class; }; struct _ValaGenericType { ValaDataType parent_instance; ValaGenericTypePrivate * priv; }; struct _ValaGenericTypeClass { ValaDataTypeClass parent_class; }; struct _ValaGenieParser { ValaCodeVisitor parent_instance; ValaGenieParserPrivate * priv; }; struct _ValaGenieParserClass { ValaCodeVisitorClass parent_class; }; struct _ValaGenieScanner { GTypeInstance parent_instance; volatile int ref_count; ValaGenieScannerPrivate * priv; }; struct _ValaGenieScannerClass { GTypeClass parent_class; void (*finalize) (ValaGenieScanner *self); }; struct _ValaSourceLocation { gchar* pos; gint line; gint column; }; typedef enum { VALA_GENIE_TOKEN_TYPE_NONE, VALA_GENIE_TOKEN_TYPE_ABSTRACT, VALA_GENIE_TOKEN_TYPE_ARRAY, VALA_GENIE_TOKEN_TYPE_AS, VALA_GENIE_TOKEN_TYPE_ASSERT, VALA_GENIE_TOKEN_TYPE_ASSIGN, VALA_GENIE_TOKEN_TYPE_ASSIGN_ADD, VALA_GENIE_TOKEN_TYPE_ASSIGN_BITWISE_AND, VALA_GENIE_TOKEN_TYPE_ASSIGN_BITWISE_OR, VALA_GENIE_TOKEN_TYPE_ASSIGN_BITWISE_XOR, VALA_GENIE_TOKEN_TYPE_ASSIGN_DIV, VALA_GENIE_TOKEN_TYPE_ASSIGN_MUL, VALA_GENIE_TOKEN_TYPE_ASSIGN_PERCENT, VALA_GENIE_TOKEN_TYPE_ASSIGN_SHIFT_LEFT, VALA_GENIE_TOKEN_TYPE_ASSIGN_SUB, VALA_GENIE_TOKEN_TYPE_ASYNC, VALA_GENIE_TOKEN_TYPE_BITWISE_AND, VALA_GENIE_TOKEN_TYPE_BITWISE_OR, VALA_GENIE_TOKEN_TYPE_BREAK, VALA_GENIE_TOKEN_TYPE_CARRET, VALA_GENIE_TOKEN_TYPE_CASE, VALA_GENIE_TOKEN_TYPE_CHARACTER_LITERAL, VALA_GENIE_TOKEN_TYPE_CLASS, VALA_GENIE_TOKEN_TYPE_CLOSE_BRACE, VALA_GENIE_TOKEN_TYPE_CLOSE_BRACKET, VALA_GENIE_TOKEN_TYPE_CLOSE_PARENS, VALA_GENIE_TOKEN_TYPE_CLOSE_REGEX_LITERAL, VALA_GENIE_TOKEN_TYPE_CLOSE_TEMPLATE, VALA_GENIE_TOKEN_TYPE_COLON, VALA_GENIE_TOKEN_TYPE_COMMA, VALA_GENIE_TOKEN_TYPE_CONST, VALA_GENIE_TOKEN_TYPE_CONSTRUCT, VALA_GENIE_TOKEN_TYPE_CONTINUE, VALA_GENIE_TOKEN_TYPE_DEDENT, VALA_GENIE_TOKEN_TYPE_DEF, VALA_GENIE_TOKEN_TYPE_DEFAULT, VALA_GENIE_TOKEN_TYPE_DELEGATE, VALA_GENIE_TOKEN_TYPE_DELETE, VALA_GENIE_TOKEN_TYPE_DICT, VALA_GENIE_TOKEN_TYPE_DIV, VALA_GENIE_TOKEN_TYPE_DO, VALA_GENIE_TOKEN_TYPE_DOT, VALA_GENIE_TOKEN_TYPE_DOWNTO, VALA_GENIE_TOKEN_TYPE_DYNAMIC, VALA_GENIE_TOKEN_TYPE_ELLIPSIS, VALA_GENIE_TOKEN_TYPE_ELSE, VALA_GENIE_TOKEN_TYPE_ENUM, VALA_GENIE_TOKEN_TYPE_ENSURES, VALA_GENIE_TOKEN_TYPE_ERRORDOMAIN, VALA_GENIE_TOKEN_TYPE_EOF, VALA_GENIE_TOKEN_TYPE_EOL, VALA_GENIE_TOKEN_TYPE_EVENT, VALA_GENIE_TOKEN_TYPE_EXCEPT, VALA_GENIE_TOKEN_TYPE_EXTERN, VALA_GENIE_TOKEN_TYPE_FALSE, VALA_GENIE_TOKEN_TYPE_FINAL, VALA_GENIE_TOKEN_TYPE_FINALLY, VALA_GENIE_TOKEN_TYPE_FOR, VALA_GENIE_TOKEN_TYPE_GET, VALA_GENIE_TOKEN_TYPE_HASH, VALA_GENIE_TOKEN_TYPE_IDENTIFIER, VALA_GENIE_TOKEN_TYPE_IF, VALA_GENIE_TOKEN_TYPE_IMPLEMENTS, VALA_GENIE_TOKEN_TYPE_IN, VALA_GENIE_TOKEN_TYPE_INDENT, VALA_GENIE_TOKEN_TYPE_INIT, VALA_GENIE_TOKEN_TYPE_INLINE, VALA_GENIE_TOKEN_TYPE_INTEGER_LITERAL, VALA_GENIE_TOKEN_TYPE_INTERFACE, VALA_GENIE_TOKEN_TYPE_INTERNAL, VALA_GENIE_TOKEN_TYPE_INTERR, VALA_GENIE_TOKEN_TYPE_IS, VALA_GENIE_TOKEN_TYPE_ISA, VALA_GENIE_TOKEN_TYPE_LAMBDA, VALA_GENIE_TOKEN_TYPE_LIST, VALA_GENIE_TOKEN_TYPE_LOCK, VALA_GENIE_TOKEN_TYPE_MINUS, VALA_GENIE_TOKEN_TYPE_NAMESPACE, VALA_GENIE_TOKEN_TYPE_NEW, VALA_GENIE_TOKEN_TYPE_NULL, VALA_GENIE_TOKEN_TYPE_OF, VALA_GENIE_TOKEN_TYPE_OUT, VALA_GENIE_TOKEN_TYPE_OP_AND, VALA_GENIE_TOKEN_TYPE_OP_DEC, VALA_GENIE_TOKEN_TYPE_OP_EQ, VALA_GENIE_TOKEN_TYPE_OP_GE, VALA_GENIE_TOKEN_TYPE_OP_GT, VALA_GENIE_TOKEN_TYPE_OP_INC, VALA_GENIE_TOKEN_TYPE_OP_LE, VALA_GENIE_TOKEN_TYPE_OP_LT, VALA_GENIE_TOKEN_TYPE_OP_NE, VALA_GENIE_TOKEN_TYPE_OP_NEG, VALA_GENIE_TOKEN_TYPE_OP_OR, VALA_GENIE_TOKEN_TYPE_OP_PTR, VALA_GENIE_TOKEN_TYPE_OP_SHIFT_LEFT, VALA_GENIE_TOKEN_TYPE_OPEN_BRACE, VALA_GENIE_TOKEN_TYPE_OPEN_BRACKET, VALA_GENIE_TOKEN_TYPE_OPEN_PARENS, VALA_GENIE_TOKEN_TYPE_OPEN_REGEX_LITERAL, VALA_GENIE_TOKEN_TYPE_OPEN_TEMPLATE, VALA_GENIE_TOKEN_TYPE_OVERRIDE, VALA_GENIE_TOKEN_TYPE_OWNED, VALA_GENIE_TOKEN_TYPE_PARAMS, VALA_GENIE_TOKEN_TYPE_PASS, VALA_GENIE_TOKEN_TYPE_PERCENT, VALA_GENIE_TOKEN_TYPE_PLUS, VALA_GENIE_TOKEN_TYPE_PRINT, VALA_GENIE_TOKEN_TYPE_PRIVATE, VALA_GENIE_TOKEN_TYPE_PROP, VALA_GENIE_TOKEN_TYPE_PROTECTED, VALA_GENIE_TOKEN_TYPE_PUBLIC, VALA_GENIE_TOKEN_TYPE_RAISE, VALA_GENIE_TOKEN_TYPE_RAISES, VALA_GENIE_TOKEN_TYPE_READONLY, VALA_GENIE_TOKEN_TYPE_REAL_LITERAL, VALA_GENIE_TOKEN_TYPE_REF, VALA_GENIE_TOKEN_TYPE_REGEX_LITERAL, VALA_GENIE_TOKEN_TYPE_REQUIRES, VALA_GENIE_TOKEN_TYPE_RETURN, VALA_GENIE_TOKEN_TYPE_SEALED, VALA_GENIE_TOKEN_TYPE_SEMICOLON, VALA_GENIE_TOKEN_TYPE_SET, VALA_GENIE_TOKEN_TYPE_SIZEOF, VALA_GENIE_TOKEN_TYPE_STAR, VALA_GENIE_TOKEN_TYPE_STATIC, VALA_GENIE_TOKEN_TYPE_STRING_LITERAL, VALA_GENIE_TOKEN_TYPE_STRUCT, VALA_GENIE_TOKEN_TYPE_SUPER, VALA_GENIE_TOKEN_TYPE_TEMPLATE_STRING_LITERAL, VALA_GENIE_TOKEN_TYPE_THIS, VALA_GENIE_TOKEN_TYPE_TILDE, VALA_GENIE_TOKEN_TYPE_TO, VALA_GENIE_TOKEN_TYPE_TRUE, VALA_GENIE_TOKEN_TYPE_TRY, VALA_GENIE_TOKEN_TYPE_TYPEOF, VALA_GENIE_TOKEN_TYPE_UNOWNED, VALA_GENIE_TOKEN_TYPE_USES, VALA_GENIE_TOKEN_TYPE_VAR, VALA_GENIE_TOKEN_TYPE_VERBATIM_STRING_LITERAL, VALA_GENIE_TOKEN_TYPE_VIRTUAL, VALA_GENIE_TOKEN_TYPE_VOID, VALA_GENIE_TOKEN_TYPE_VOLATILE, VALA_GENIE_TOKEN_TYPE_WEAK, VALA_GENIE_TOKEN_TYPE_WHEN, VALA_GENIE_TOKEN_TYPE_WHILE, VALA_GENIE_TOKEN_TYPE_WRITEONLY, VALA_GENIE_TOKEN_TYPE_YIELD } ValaGenieTokenType; struct _ValaIfStatement { ValaCodeNode parent_instance; ValaIfStatementPrivate * priv; }; struct _ValaIfStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaInitializerList { ValaExpression parent_instance; ValaInitializerListPrivate * priv; }; struct _ValaInitializerListClass { ValaExpressionClass parent_class; }; struct _ValaIntegerLiteral { ValaLiteral parent_instance; ValaIntegerLiteralPrivate * priv; }; struct _ValaIntegerLiteralClass { ValaLiteralClass parent_class; }; struct _ValaIntegerType { ValaValueType parent_instance; ValaIntegerTypePrivate * priv; }; struct _ValaIntegerTypeClass { ValaValueTypeClass parent_class; }; struct _ValaInterface { ValaObjectTypeSymbol parent_instance; ValaInterfacePrivate * priv; }; struct _ValaInterfaceClass { ValaObjectTypeSymbolClass parent_class; ValaList* (*get_virtuals) (ValaInterface* self); }; struct _ValaInterfaceType { ValaReferenceType parent_instance; ValaInterfaceTypePrivate * priv; }; struct _ValaInterfaceTypeClass { ValaReferenceTypeClass parent_class; }; struct _ValaInvalidType { ValaDataType parent_instance; ValaInvalidTypePrivate * priv; }; struct _ValaInvalidTypeClass { ValaDataTypeClass parent_class; }; struct _ValaLambdaExpression { ValaExpression parent_instance; ValaLambdaExpressionPrivate * priv; }; struct _ValaLambdaExpressionClass { ValaExpressionClass parent_class; }; struct _ValaLocalVariable { ValaVariable parent_instance; ValaLocalVariablePrivate * priv; }; struct _ValaLocalVariableClass { ValaVariableClass parent_class; }; struct _ValaLockStatement { ValaCodeNode parent_instance; ValaLockStatementPrivate * priv; }; struct _ValaLockStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaLoop { ValaCodeNode parent_instance; ValaLoopPrivate * priv; }; struct _ValaLoopClass { ValaCodeNodeClass parent_class; }; struct _ValaMarkupReader { GTypeInstance parent_instance; volatile int ref_count; ValaMarkupReaderPrivate * priv; }; struct _ValaMarkupReaderClass { GTypeClass parent_class; void (*finalize) (ValaMarkupReader *self); }; typedef enum { VALA_MARKUP_TOKEN_TYPE_NONE, VALA_MARKUP_TOKEN_TYPE_START_ELEMENT, VALA_MARKUP_TOKEN_TYPE_END_ELEMENT, VALA_MARKUP_TOKEN_TYPE_TEXT, VALA_MARKUP_TOKEN_TYPE_EOF } ValaMarkupTokenType; struct _ValaMemberAccess { ValaExpression parent_instance; ValaMemberAccessPrivate * priv; }; struct _ValaMemberAccessClass { ValaExpressionClass parent_class; }; struct _ValaMemberInitializer { ValaCodeNode parent_instance; ValaMemberInitializerPrivate * priv; }; struct _ValaMemberInitializerClass { ValaCodeNodeClass parent_class; }; struct _ValaMethodCall { ValaExpression parent_instance; ValaMethodCallPrivate * priv; }; struct _ValaMethodCallClass { ValaExpressionClass parent_class; }; struct _ValaMethodType { ValaCallableType parent_instance; ValaMethodTypePrivate * priv; }; struct _ValaMethodTypeClass { ValaCallableTypeClass parent_class; }; struct _ValaNamedArgument { ValaExpression parent_instance; ValaNamedArgumentPrivate * priv; }; struct _ValaNamedArgumentClass { ValaExpressionClass parent_class; }; struct _ValaNamespace { ValaSymbol parent_instance; ValaNamespacePrivate * priv; }; struct _ValaNamespaceClass { ValaSymbolClass parent_class; }; struct _ValaNullLiteral { ValaLiteral parent_instance; ValaNullLiteralPrivate * priv; }; struct _ValaNullLiteralClass { ValaLiteralClass parent_class; }; struct _ValaNullType { ValaReferenceType parent_instance; ValaNullTypePrivate * priv; }; struct _ValaNullTypeClass { ValaReferenceTypeClass parent_class; }; struct _ValaObjectCreationExpression { ValaExpression parent_instance; ValaObjectCreationExpressionPrivate * priv; }; struct _ValaObjectCreationExpressionClass { ValaExpressionClass parent_class; }; struct _ValaObjectType { ValaReferenceType parent_instance; ValaObjectTypePrivate * priv; }; struct _ValaObjectTypeClass { ValaReferenceTypeClass parent_class; }; struct _ValaParameter { ValaVariable parent_instance; ValaParameterPrivate * priv; }; struct _ValaParameterClass { ValaVariableClass parent_class; }; typedef enum { VALA_PARAMETER_DIRECTION_IN, VALA_PARAMETER_DIRECTION_OUT, VALA_PARAMETER_DIRECTION_REF } ValaParameterDirection; struct _ValaParser { ValaCodeVisitor parent_instance; ValaParserPrivate * priv; }; struct _ValaParserClass { ValaCodeVisitorClass parent_class; }; typedef enum { VALA_PARSE_ERROR_FAILED, VALA_PARSE_ERROR_SYNTAX } ValaParseError; #define VALA_PARSE_ERROR vala_parse_error_quark () struct _ValaPhiFunction { GTypeInstance parent_instance; volatile int ref_count; ValaPhiFunctionPrivate * priv; }; struct _ValaPhiFunctionClass { GTypeClass parent_class; void (*finalize) (ValaPhiFunction *self); }; struct _ValaPointerIndirection { ValaExpression parent_instance; ValaPointerIndirectionPrivate * priv; }; struct _ValaPointerIndirectionClass { ValaExpressionClass parent_class; }; struct _ValaPointerType { ValaDataType parent_instance; ValaPointerTypePrivate * priv; }; struct _ValaPointerTypeClass { ValaDataTypeClass parent_class; }; struct _ValaPostfixExpression { ValaExpression parent_instance; ValaPostfixExpressionPrivate * priv; }; struct _ValaPostfixExpressionClass { ValaExpressionClass parent_class; }; struct _ValaPropertyAccessor { ValaSubroutine parent_instance; ValaPropertyAccessorPrivate * priv; }; struct _ValaPropertyAccessorClass { ValaSubroutineClass parent_class; }; struct _ValaRealLiteral { ValaLiteral parent_instance; ValaRealLiteralPrivate * priv; }; struct _ValaRealLiteralClass { ValaLiteralClass parent_class; }; struct _ValaReferenceTransferExpression { ValaExpression parent_instance; ValaReferenceTransferExpressionPrivate * priv; }; struct _ValaReferenceTransferExpressionClass { ValaExpressionClass parent_class; }; struct _ValaRegexLiteral { ValaLiteral parent_instance; ValaRegexLiteralPrivate * priv; }; struct _ValaRegexLiteralClass { ValaLiteralClass parent_class; }; struct _ValaReport { GTypeInstance parent_instance; volatile int ref_count; ValaReportPrivate * priv; gint warnings; gint errors; }; struct _ValaReportClass { GTypeClass parent_class; void (*finalize) (ValaReport *self); void (*note) (ValaReport* self, ValaSourceReference* source, const gchar* message); void (*depr) (ValaReport* self, ValaSourceReference* source, const gchar* message); void (*warn) (ValaReport* self, ValaSourceReference* source, const gchar* message); void (*err) (ValaReport* self, ValaSourceReference* source, const gchar* message); }; typedef enum { VALA_REPORT_COLORED_AUTO, VALA_REPORT_COLORED_NEVER, VALA_REPORT_COLORED_ALWAYS } ValaReportColored; struct _ValaReturnStatement { ValaCodeNode parent_instance; ValaReturnStatementPrivate * priv; }; struct _ValaReturnStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaScanner { GTypeInstance parent_instance; volatile int ref_count; ValaScannerPrivate * priv; }; struct _ValaScannerClass { GTypeClass parent_class; void (*finalize) (ValaScanner *self); }; typedef enum { VALA_TOKEN_TYPE_NONE, VALA_TOKEN_TYPE_ABSTRACT, VALA_TOKEN_TYPE_AS, VALA_TOKEN_TYPE_ASSIGN, VALA_TOKEN_TYPE_ASSIGN_ADD, VALA_TOKEN_TYPE_ASSIGN_BITWISE_AND, VALA_TOKEN_TYPE_ASSIGN_BITWISE_OR, VALA_TOKEN_TYPE_ASSIGN_BITWISE_XOR, VALA_TOKEN_TYPE_ASSIGN_DIV, VALA_TOKEN_TYPE_ASSIGN_MUL, VALA_TOKEN_TYPE_ASSIGN_PERCENT, VALA_TOKEN_TYPE_ASSIGN_SHIFT_LEFT, VALA_TOKEN_TYPE_ASSIGN_SUB, VALA_TOKEN_TYPE_ASYNC, VALA_TOKEN_TYPE_BASE, VALA_TOKEN_TYPE_BITWISE_AND, VALA_TOKEN_TYPE_BITWISE_OR, VALA_TOKEN_TYPE_BREAK, VALA_TOKEN_TYPE_CARRET, VALA_TOKEN_TYPE_CASE, VALA_TOKEN_TYPE_CATCH, VALA_TOKEN_TYPE_CHARACTER_LITERAL, VALA_TOKEN_TYPE_CLASS, VALA_TOKEN_TYPE_CLOSE_BRACE, VALA_TOKEN_TYPE_CLOSE_BRACKET, VALA_TOKEN_TYPE_CLOSE_PARENS, VALA_TOKEN_TYPE_CLOSE_REGEX_LITERAL, VALA_TOKEN_TYPE_CLOSE_TEMPLATE, VALA_TOKEN_TYPE_COLON, VALA_TOKEN_TYPE_COMMA, VALA_TOKEN_TYPE_CONST, VALA_TOKEN_TYPE_CONSTRUCT, VALA_TOKEN_TYPE_CONTINUE, VALA_TOKEN_TYPE_DEFAULT, VALA_TOKEN_TYPE_DELEGATE, VALA_TOKEN_TYPE_DELETE, VALA_TOKEN_TYPE_DIV, VALA_TOKEN_TYPE_DO, VALA_TOKEN_TYPE_DOUBLE_COLON, VALA_TOKEN_TYPE_DOT, VALA_TOKEN_TYPE_DYNAMIC, VALA_TOKEN_TYPE_ELLIPSIS, VALA_TOKEN_TYPE_ELSE, VALA_TOKEN_TYPE_ENUM, VALA_TOKEN_TYPE_ENSURES, VALA_TOKEN_TYPE_ERRORDOMAIN, VALA_TOKEN_TYPE_EOF, VALA_TOKEN_TYPE_EXTERN, VALA_TOKEN_TYPE_FALSE, VALA_TOKEN_TYPE_FINALLY, VALA_TOKEN_TYPE_FOR, VALA_TOKEN_TYPE_FOREACH, VALA_TOKEN_TYPE_GET, VALA_TOKEN_TYPE_HASH, VALA_TOKEN_TYPE_IDENTIFIER, VALA_TOKEN_TYPE_IF, VALA_TOKEN_TYPE_IN, VALA_TOKEN_TYPE_INLINE, VALA_TOKEN_TYPE_INTEGER_LITERAL, VALA_TOKEN_TYPE_INTERFACE, VALA_TOKEN_TYPE_INTERNAL, VALA_TOKEN_TYPE_INTERR, VALA_TOKEN_TYPE_IS, VALA_TOKEN_TYPE_LAMBDA, VALA_TOKEN_TYPE_LOCK, VALA_TOKEN_TYPE_MINUS, VALA_TOKEN_TYPE_NAMESPACE, VALA_TOKEN_TYPE_NEW, VALA_TOKEN_TYPE_NULL, VALA_TOKEN_TYPE_OUT, VALA_TOKEN_TYPE_OP_AND, VALA_TOKEN_TYPE_OP_COALESCING, VALA_TOKEN_TYPE_OP_DEC, VALA_TOKEN_TYPE_OP_EQ, VALA_TOKEN_TYPE_OP_GE, VALA_TOKEN_TYPE_OP_GT, VALA_TOKEN_TYPE_OP_INC, VALA_TOKEN_TYPE_OP_LE, VALA_TOKEN_TYPE_OP_LT, VALA_TOKEN_TYPE_OP_NE, VALA_TOKEN_TYPE_OP_NEG, VALA_TOKEN_TYPE_OP_OR, VALA_TOKEN_TYPE_OP_PTR, VALA_TOKEN_TYPE_OP_SHIFT_LEFT, VALA_TOKEN_TYPE_OPEN_BRACE, VALA_TOKEN_TYPE_OPEN_BRACKET, VALA_TOKEN_TYPE_OPEN_PARENS, VALA_TOKEN_TYPE_OPEN_REGEX_LITERAL, VALA_TOKEN_TYPE_OPEN_TEMPLATE, VALA_TOKEN_TYPE_OVERRIDE, VALA_TOKEN_TYPE_OWNED, VALA_TOKEN_TYPE_PARAMS, VALA_TOKEN_TYPE_PERCENT, VALA_TOKEN_TYPE_PLUS, VALA_TOKEN_TYPE_PRIVATE, VALA_TOKEN_TYPE_PROTECTED, VALA_TOKEN_TYPE_PUBLIC, VALA_TOKEN_TYPE_REAL_LITERAL, VALA_TOKEN_TYPE_REF, VALA_TOKEN_TYPE_REGEX_LITERAL, VALA_TOKEN_TYPE_REQUIRES, VALA_TOKEN_TYPE_RETURN, VALA_TOKEN_TYPE_SEALED, VALA_TOKEN_TYPE_SEMICOLON, VALA_TOKEN_TYPE_SET, VALA_TOKEN_TYPE_SIGNAL, VALA_TOKEN_TYPE_SIZEOF, VALA_TOKEN_TYPE_STAR, VALA_TOKEN_TYPE_STATIC, VALA_TOKEN_TYPE_STRING_LITERAL, VALA_TOKEN_TYPE_STRUCT, VALA_TOKEN_TYPE_SWITCH, VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL, VALA_TOKEN_TYPE_THIS, VALA_TOKEN_TYPE_THROW, VALA_TOKEN_TYPE_THROWS, VALA_TOKEN_TYPE_TILDE, VALA_TOKEN_TYPE_TRUE, VALA_TOKEN_TYPE_TRY, VALA_TOKEN_TYPE_TYPEOF, VALA_TOKEN_TYPE_UNOWNED, VALA_TOKEN_TYPE_USING, VALA_TOKEN_TYPE_VAR, VALA_TOKEN_TYPE_VERBATIM_STRING_LITERAL, VALA_TOKEN_TYPE_VIRTUAL, VALA_TOKEN_TYPE_VOID, VALA_TOKEN_TYPE_VOLATILE, VALA_TOKEN_TYPE_WEAK, VALA_TOKEN_TYPE_WHILE, VALA_TOKEN_TYPE_YIELD } ValaTokenType; struct _ValaScope { GTypeInstance parent_instance; volatile int ref_count; ValaScopePrivate * priv; }; struct _ValaScopeClass { GTypeClass parent_class; void (*finalize) (ValaScope *self); }; struct _ValaSemanticAnalyzer { ValaCodeVisitor parent_instance; ValaSemanticAnalyzerPrivate * priv; ValaBlock* insert_block; ValaDataType* void_type; ValaDataType* bool_type; ValaDataType* string_type; ValaDataType* regex_type; ValaDataType* uchar_type; ValaDataType* short_type; ValaDataType* ushort_type; ValaDataType* int_type; ValaDataType* uint_type; ValaDataType* long_type; ValaDataType* ulong_type; ValaDataType* size_t_type; ValaDataType* ssize_t_type; ValaDataType* int8_type; ValaDataType* unichar_type; ValaDataType* double_type; ValaDataType* type_type; ValaDataType* va_list_type; ValaClass* object_type; ValaStructValueType* gvalue_type; ValaObjectType* gvariant_type; ValaDataType* glist_type; ValaDataType* gslist_type; ValaDataType* garray_type; ValaDataType* gvaluearray_type; ValaClass* gerror_type; ValaDataType* list_type; ValaDataType* tuple_type; ValaDataType* error_type; ValaClass* gsource_type; }; struct _ValaSemanticAnalyzerClass { ValaCodeVisitorClass parent_class; }; struct _ValaSignalType { ValaCallableType parent_instance; ValaSignalTypePrivate * priv; }; struct _ValaSignalTypeClass { ValaCallableTypeClass parent_class; }; struct _ValaSizeofExpression { ValaExpression parent_instance; ValaSizeofExpressionPrivate * priv; }; struct _ValaSizeofExpressionClass { ValaExpressionClass parent_class; }; struct _ValaSliceExpression { ValaExpression parent_instance; ValaSliceExpressionPrivate * priv; }; struct _ValaSliceExpressionClass { ValaExpressionClass parent_class; }; struct _ValaSourceFile { GTypeInstance parent_instance; volatile int ref_count; ValaSourceFilePrivate * priv; }; struct _ValaSourceFileClass { GTypeClass parent_class; void (*finalize) (ValaSourceFile *self); }; typedef enum { VALA_SOURCE_FILE_TYPE_NONE, VALA_SOURCE_FILE_TYPE_SOURCE, VALA_SOURCE_FILE_TYPE_PACKAGE, VALA_SOURCE_FILE_TYPE_FAST } ValaSourceFileType; struct _ValaSourceReference { GTypeInstance parent_instance; volatile int ref_count; ValaSourceReferencePrivate * priv; }; struct _ValaSourceReferenceClass { GTypeClass parent_class; void (*finalize) (ValaSourceReference *self); }; struct _ValaStatementList { ValaCodeNode parent_instance; ValaStatementListPrivate * priv; }; struct _ValaStatementListClass { ValaCodeNodeClass parent_class; }; struct _ValaStringLiteral { ValaLiteral parent_instance; ValaStringLiteralPrivate * priv; }; struct _ValaStringLiteralClass { ValaLiteralClass parent_class; }; struct _ValaStruct { ValaTypeSymbol parent_instance; ValaStructPrivate * priv; }; struct _ValaStructClass { ValaTypeSymbolClass parent_class; }; struct _ValaStructValueType { ValaValueType parent_instance; ValaStructValueTypePrivate * priv; }; struct _ValaStructValueTypeClass { ValaValueTypeClass parent_class; }; struct _ValaSwitchLabel { ValaCodeNode parent_instance; ValaSwitchLabelPrivate * priv; }; struct _ValaSwitchLabelClass { ValaCodeNodeClass parent_class; }; struct _ValaSwitchSection { ValaBlock parent_instance; ValaSwitchSectionPrivate * priv; }; struct _ValaSwitchSectionClass { ValaBlockClass parent_class; }; struct _ValaSwitchStatement { ValaCodeNode parent_instance; ValaSwitchStatementPrivate * priv; }; struct _ValaSwitchStatementClass { ValaCodeNodeClass parent_class; }; typedef enum { VALA_SYMBOL_ACCESSIBILITY_PRIVATE, VALA_SYMBOL_ACCESSIBILITY_INTERNAL, VALA_SYMBOL_ACCESSIBILITY_PROTECTED, VALA_SYMBOL_ACCESSIBILITY_PUBLIC } ValaSymbolAccessibility; struct _ValaSymbolResolver { ValaCodeVisitor parent_instance; ValaSymbolResolverPrivate * priv; }; struct _ValaSymbolResolverClass { ValaCodeVisitorClass parent_class; }; struct _ValaTargetValue { GTypeInstance parent_instance; volatile int ref_count; ValaTargetValuePrivate * priv; }; struct _ValaTargetValueClass { GTypeClass parent_class; void (*finalize) (ValaTargetValue *self); }; struct _ValaTemplate { ValaExpression parent_instance; ValaTemplatePrivate * priv; }; struct _ValaTemplateClass { ValaExpressionClass parent_class; }; struct _ValaThrowStatement { ValaCodeNode parent_instance; ValaThrowStatementPrivate * priv; }; struct _ValaThrowStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaTryStatement { ValaCodeNode parent_instance; ValaTryStatementPrivate * priv; }; struct _ValaTryStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaTuple { ValaExpression parent_instance; ValaTuplePrivate * priv; }; struct _ValaTupleClass { ValaExpressionClass parent_class; }; struct _ValaTypeCheck { ValaExpression parent_instance; ValaTypeCheckPrivate * priv; }; struct _ValaTypeCheckClass { ValaExpressionClass parent_class; }; struct _ValaTypeofExpression { ValaExpression parent_instance; ValaTypeofExpressionPrivate * priv; }; struct _ValaTypeofExpressionClass { ValaExpressionClass parent_class; }; struct _ValaTypeParameter { ValaSymbol parent_instance; ValaTypeParameterPrivate * priv; }; struct _ValaTypeParameterClass { ValaSymbolClass parent_class; }; struct _ValaUnaryExpression { ValaExpression parent_instance; ValaUnaryExpressionPrivate * priv; }; struct _ValaUnaryExpressionClass { ValaExpressionClass parent_class; }; typedef enum { VALA_UNARY_OPERATOR_NONE, VALA_UNARY_OPERATOR_PLUS, VALA_UNARY_OPERATOR_MINUS, VALA_UNARY_OPERATOR_LOGICAL_NEGATION, VALA_UNARY_OPERATOR_BITWISE_COMPLEMENT, VALA_UNARY_OPERATOR_INCREMENT, VALA_UNARY_OPERATOR_DECREMENT, VALA_UNARY_OPERATOR_REF, VALA_UNARY_OPERATOR_OUT } ValaUnaryOperator; struct _ValaUnlockStatement { ValaCodeNode parent_instance; ValaUnlockStatementPrivate * priv; }; struct _ValaUnlockStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaUnresolvedSymbol { ValaSymbol parent_instance; ValaUnresolvedSymbolPrivate * priv; }; struct _ValaUnresolvedSymbolClass { ValaSymbolClass parent_class; }; struct _ValaUnresolvedType { ValaDataType parent_instance; ValaUnresolvedTypePrivate * priv; }; struct _ValaUnresolvedTypeClass { ValaDataTypeClass parent_class; }; struct _ValaUsedAttr { ValaCodeVisitor parent_instance; ValaUsedAttrPrivate * priv; ValaMap* marked; }; struct _ValaUsedAttrClass { ValaCodeVisitorClass parent_class; }; struct _ValaUsingDirective { ValaCodeNode parent_instance; ValaUsingDirectivePrivate * priv; }; struct _ValaUsingDirectiveClass { ValaCodeNodeClass parent_class; }; struct _ValaVersionAttribute { GTypeInstance parent_instance; volatile int ref_count; ValaVersionAttributePrivate * priv; }; struct _ValaVersionAttributeClass { GTypeClass parent_class; void (*finalize) (ValaVersionAttribute *self); }; struct _ValaVoidType { ValaDataType parent_instance; ValaVoidTypePrivate * priv; }; struct _ValaVoidTypeClass { ValaDataTypeClass parent_class; }; struct _ValaWhileStatement { ValaCodeNode parent_instance; ValaWhileStatementPrivate * priv; }; struct _ValaWhileStatementClass { ValaCodeNodeClass parent_class; }; struct _ValaYieldStatement { ValaCodeNode parent_instance; ValaYieldStatementPrivate * priv; }; struct _ValaYieldStatementClass { ValaCodeNodeClass parent_class; }; gpointer vala_code_node_ref (gpointer instance); void vala_code_node_unref (gpointer instance); GParamSpec* vala_param_spec_code_node (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_code_node (GValue* value, gpointer v_object); void vala_value_take_code_node (GValue* value, gpointer v_object); gpointer vala_value_get_code_node (const GValue* value); GType vala_code_node_get_type (void) G_GNUC_CONST; gpointer vala_code_visitor_ref (gpointer instance); void vala_code_visitor_unref (gpointer instance); GParamSpec* vala_param_spec_code_visitor (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_code_visitor (GValue* value, gpointer v_object); void vala_value_take_code_visitor (GValue* value, gpointer v_object); gpointer vala_value_get_code_visitor (const GValue* value); GType vala_code_visitor_get_type (void) G_GNUC_CONST; gpointer vala_code_context_ref (gpointer instance); void vala_code_context_unref (gpointer instance); GParamSpec* vala_param_spec_code_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_code_context (GValue* value, gpointer v_object); void vala_value_take_code_context (GValue* value, gpointer v_object); gpointer vala_value_get_code_context (const GValue* value); GType vala_code_context_get_type (void) G_GNUC_CONST; GType vala_code_generator_get_type (void) G_GNUC_CONST; GType vala_data_type_get_type (void) G_GNUC_CONST; GType vala_expression_get_type (void) G_GNUC_CONST; GType vala_symbol_get_type (void) G_GNUC_CONST; GType vala_variable_get_type (void) G_GNUC_CONST; GType vala_attribute_get_type (void) G_GNUC_CONST; GType vala_addressof_expression_get_type (void) G_GNUC_CONST; gpointer vala_source_reference_ref (gpointer instance); void vala_source_reference_unref (gpointer instance); GParamSpec* vala_param_spec_source_reference (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_source_reference (GValue* value, gpointer v_object); void vala_value_take_source_reference (GValue* value, gpointer v_object); gpointer vala_value_get_source_reference (const GValue* value); GType vala_source_reference_get_type (void) G_GNUC_CONST; ValaAddressofExpression* vala_addressof_expression_new (ValaExpression* inner, ValaSourceReference* source_reference); ValaAddressofExpression* vala_addressof_expression_construct (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference); ValaExpression* vala_addressof_expression_get_inner (ValaAddressofExpression* self); void vala_addressof_expression_set_inner (ValaAddressofExpression* self, ValaExpression* value); GType vala_namespace_get_type (void) G_GNUC_CONST; GType vala_typesymbol_get_type (void) G_GNUC_CONST; GType vala_object_type_symbol_get_type (void) G_GNUC_CONST; GType vala_class_get_type (void) G_GNUC_CONST; GType vala_interface_get_type (void) G_GNUC_CONST; GType vala_struct_get_type (void) G_GNUC_CONST; GType vala_enum_get_type (void) G_GNUC_CONST; GType vala_error_domain_get_type (void) G_GNUC_CONST; GType vala_delegate_get_type (void) G_GNUC_CONST; GType vala_constant_get_type (void) G_GNUC_CONST; GType vala_field_get_type (void) G_GNUC_CONST; GType vala_subroutine_get_type (void) G_GNUC_CONST; GType vala_method_get_type (void) G_GNUC_CONST; GType vala_property_get_type (void) G_GNUC_CONST; GType vala_signal_get_type (void) G_GNUC_CONST; GType vala_constructor_get_type (void) G_GNUC_CONST; GType vala_destructor_get_type (void) G_GNUC_CONST; GType vala_parameter_get_type (void) G_GNUC_CONST; GType vala_callable_get_type (void) G_GNUC_CONST; GType vala_array_copy_method_get_type (void) G_GNUC_CONST; ValaArrayCopyMethod* vala_array_copy_method_new (ValaSourceReference* source_reference); ValaArrayCopyMethod* vala_array_copy_method_construct (GType object_type, ValaSourceReference* source_reference); GType vala_array_creation_expression_get_type (void) G_GNUC_CONST; void vala_array_creation_expression_append_size (ValaArrayCreationExpression* self, ValaExpression* size); ValaList* vala_array_creation_expression_get_sizes (ValaArrayCreationExpression* self); GType vala_initializer_list_get_type (void) G_GNUC_CONST; ValaArrayCreationExpression* vala_array_creation_expression_new (ValaDataType* element_type, gint rank, ValaInitializerList* initializer_list, ValaSourceReference* source_reference); ValaArrayCreationExpression* vala_array_creation_expression_construct (GType object_type, ValaDataType* element_type, gint rank, ValaInitializerList* initializer_list, ValaSourceReference* source_reference); ValaDataType* vala_array_creation_expression_get_element_type (ValaArrayCreationExpression* self); void vala_array_creation_expression_set_element_type (ValaArrayCreationExpression* self, ValaDataType* value); gint vala_array_creation_expression_get_rank (ValaArrayCreationExpression* self); void vala_array_creation_expression_set_rank (ValaArrayCreationExpression* self, gint value); ValaInitializerList* vala_array_creation_expression_get_initializer_list (ValaArrayCreationExpression* self); void vala_array_creation_expression_set_initializer_list (ValaArrayCreationExpression* self, ValaInitializerList* value); GType vala_lockable_get_type (void) G_GNUC_CONST; GType vala_array_length_field_get_type (void) G_GNUC_CONST; ValaArrayLengthField* vala_array_length_field_new (ValaSourceReference* source_reference); ValaArrayLengthField* vala_array_length_field_construct (GType object_type, ValaSourceReference* source_reference); GType vala_array_move_method_get_type (void) G_GNUC_CONST; ValaArrayMoveMethod* vala_array_move_method_new (ValaSourceReference* source_reference); ValaArrayMoveMethod* vala_array_move_method_construct (GType object_type, ValaSourceReference* source_reference); GType vala_array_resize_method_get_type (void) G_GNUC_CONST; ValaArrayResizeMethod* vala_array_resize_method_new (ValaSourceReference* source_reference); ValaArrayResizeMethod* vala_array_resize_method_construct (GType object_type, ValaSourceReference* source_reference); gpointer vala_scope_ref (gpointer instance); void vala_scope_unref (gpointer instance); GParamSpec* vala_param_spec_scope (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_scope (GValue* value, gpointer v_object); void vala_value_take_scope (GValue* value, gpointer v_object); gpointer vala_value_get_scope (const GValue* value); GType vala_scope_get_type (void) G_GNUC_CONST; GType vala_typeparameter_get_type (void) G_GNUC_CONST; GType vala_reference_type_get_type (void) G_GNUC_CONST; GType vala_array_type_get_type (void) G_GNUC_CONST; ValaArrayType* vala_array_type_new (ValaDataType* element_type, gint rank, ValaSourceReference* source_reference); ValaArrayType* vala_array_type_construct (GType object_type, ValaDataType* element_type, gint rank, ValaSourceReference* source_reference); ValaDataType* vala_array_type_get_element_type (ValaArrayType* self); void vala_array_type_set_element_type (ValaArrayType* self, ValaDataType* value); gboolean vala_array_type_get_invalid_syntax (ValaArrayType* self); void vala_array_type_set_invalid_syntax (ValaArrayType* self, gboolean value); gboolean vala_array_type_get_inline_allocated (ValaArrayType* self); void vala_array_type_set_inline_allocated (ValaArrayType* self, gboolean value); gboolean vala_array_type_get_fixed_length (ValaArrayType* self); void vala_array_type_set_fixed_length (ValaArrayType* self, gboolean value); ValaExpression* vala_array_type_get_length (ValaArrayType* self); void vala_array_type_set_length (ValaArrayType* self, ValaExpression* value); gint vala_array_type_get_rank (ValaArrayType* self); void vala_array_type_set_rank (ValaArrayType* self, gint value); GType vala_assignment_get_type (void) G_GNUC_CONST; GType vala_assignment_operator_get_type (void) G_GNUC_CONST; ValaAssignment* vala_assignment_new (ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference); ValaAssignment* vala_assignment_construct (GType object_type, ValaExpression* left, ValaExpression* right, ValaAssignmentOperator operator, ValaSourceReference* source_reference); ValaExpression* vala_assignment_get_left (ValaAssignment* self); void vala_assignment_set_left (ValaAssignment* self, ValaExpression* value); ValaAssignmentOperator vala_assignment_get_operator (ValaAssignment* self); void vala_assignment_set_operator (ValaAssignment* self, ValaAssignmentOperator value); ValaExpression* vala_assignment_get_right (ValaAssignment* self); void vala_assignment_set_right (ValaAssignment* self, ValaExpression* value); ValaAttribute* vala_attribute_new (const gchar* name, ValaSourceReference* source_reference); ValaAttribute* vala_attribute_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference); void vala_attribute_add_argument (ValaAttribute* self, const gchar* key, const gchar* value); gboolean vala_attribute_has_argument (ValaAttribute* self, const gchar* name); gchar* vala_attribute_get_string (ValaAttribute* self, const gchar* name, const gchar* default_value); gint vala_attribute_get_integer (ValaAttribute* self, const gchar* name, gint default_value); gdouble vala_attribute_get_double (ValaAttribute* self, const gchar* name, gdouble default_value); gboolean vala_attribute_get_bool (ValaAttribute* self, const gchar* name, gboolean default_value); const gchar* vala_attribute_get_name (ValaAttribute* self); void vala_attribute_set_name (ValaAttribute* self, const gchar* value); ValaMap* vala_attribute_get_args (ValaAttribute* self); GType vala_base_access_get_type (void) G_GNUC_CONST; ValaBaseAccess* vala_base_access_new (ValaSourceReference* source); ValaBaseAccess* vala_base_access_construct (GType object_type, ValaSourceReference* source); gpointer vala_basic_block_ref (gpointer instance); void vala_basic_block_unref (gpointer instance); GParamSpec* vala_param_spec_basic_block (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_basic_block (GValue* value, gpointer v_object); void vala_value_take_basic_block (GValue* value, gpointer v_object); gpointer vala_value_get_basic_block (const GValue* value); GType vala_basic_block_get_type (void) G_GNUC_CONST; ValaBasicBlock* vala_basic_block_new (void); ValaBasicBlock* vala_basic_block_construct (GType object_type); ValaBasicBlock* vala_basic_block_new_entry (void); ValaBasicBlock* vala_basic_block_construct_entry (GType object_type); ValaBasicBlock* vala_basic_block_new_exit (void); ValaBasicBlock* vala_basic_block_construct_exit (GType object_type); void vala_basic_block_add_node (ValaBasicBlock* self, ValaCodeNode* node); ValaList* vala_basic_block_get_nodes (ValaBasicBlock* self); void vala_basic_block_connect (ValaBasicBlock* self, ValaBasicBlock* target); ValaList* vala_basic_block_get_predecessors (ValaBasicBlock* self); ValaList* vala_basic_block_get_successors (ValaBasicBlock* self); void vala_basic_block_add_child (ValaBasicBlock* self, ValaBasicBlock* block); ValaList* vala_basic_block_get_children (ValaBasicBlock* self); void vala_basic_block_add_dominator_frontier (ValaBasicBlock* self, ValaBasicBlock* block); ValaSet* vala_basic_block_get_dominator_frontier (ValaBasicBlock* self); gpointer vala_phi_function_ref (gpointer instance); void vala_phi_function_unref (gpointer instance); GParamSpec* vala_param_spec_phi_function (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_phi_function (GValue* value, gpointer v_object); void vala_value_take_phi_function (GValue* value, gpointer v_object); gpointer vala_value_get_phi_function (const GValue* value); GType vala_phi_function_get_type (void) G_GNUC_CONST; void vala_basic_block_add_phi_function (ValaBasicBlock* self, ValaPhiFunction* phi); ValaSet* vala_basic_block_get_phi_functions (ValaBasicBlock* self); ValaBasicBlock* vala_basic_block_get_parent (ValaBasicBlock* self); gboolean vala_basic_block_get_postorder_visited (ValaBasicBlock* self); void vala_basic_block_set_postorder_visited (ValaBasicBlock* self, gboolean value); gint vala_basic_block_get_postorder_number (ValaBasicBlock* self); void vala_basic_block_set_postorder_number (ValaBasicBlock* self, gint value); GType vala_binary_expression_get_type (void) G_GNUC_CONST; GType vala_binary_operator_get_type (void) G_GNUC_CONST; ValaBinaryExpression* vala_binary_expression_new (ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source); ValaBinaryExpression* vala_binary_expression_construct (GType object_type, ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source); ValaBinaryExpression* vala_binary_expression_new_chained (ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source); ValaBinaryExpression* vala_binary_expression_construct_chained (GType object_type, ValaBinaryOperator op, ValaExpression* _left, ValaExpression* _right, ValaSourceReference* source); ValaBinaryOperator vala_binary_expression_get_operator (ValaBinaryExpression* self); void vala_binary_expression_set_operator (ValaBinaryExpression* self, ValaBinaryOperator value); ValaExpression* vala_binary_expression_get_left (ValaBinaryExpression* self); void vala_binary_expression_set_left (ValaBinaryExpression* self, ValaExpression* value); ValaExpression* vala_binary_expression_get_right (ValaBinaryExpression* self); void vala_binary_expression_set_right (ValaBinaryExpression* self, ValaExpression* value); gboolean vala_binary_expression_get_is_chained (ValaBinaryExpression* self); GType vala_statement_get_type (void) G_GNUC_CONST; GType vala_block_get_type (void) G_GNUC_CONST; ValaBlock* vala_block_new (ValaSourceReference* source_reference); ValaBlock* vala_block_construct (GType object_type, ValaSourceReference* source_reference); void vala_block_add_statement (ValaBlock* self, ValaStatement* stmt); void vala_block_insert_statement (ValaBlock* self, gint index, ValaStatement* stmt); ValaList* vala_block_get_statements (ValaBlock* self); GType vala_local_variable_get_type (void) G_GNUC_CONST; void vala_block_add_local_variable (ValaBlock* self, ValaLocalVariable* local); void vala_block_remove_local_variable (ValaBlock* self, ValaLocalVariable* local); ValaList* vala_block_get_local_variables (ValaBlock* self); void vala_block_add_local_constant (ValaBlock* self, ValaConstant* constant); void vala_block_insert_before (ValaBlock* self, ValaStatement* stmt, ValaStatement* new_stmt); void vala_block_replace_statement (ValaBlock* self, ValaStatement* old_stmt, ValaStatement* new_stmt); gboolean vala_block_get_contains_jump_statement (ValaBlock* self); void vala_block_set_contains_jump_statement (ValaBlock* self, gboolean value); gboolean vala_block_get_captured (ValaBlock* self); void vala_block_set_captured (ValaBlock* self, gboolean value); GType vala_literal_get_type (void) G_GNUC_CONST; GType vala_boolean_literal_get_type (void) G_GNUC_CONST; ValaBooleanLiteral* vala_boolean_literal_new (gboolean b, ValaSourceReference* source); ValaBooleanLiteral* vala_boolean_literal_construct (GType object_type, gboolean b, ValaSourceReference* source); gboolean vala_boolean_literal_get_value (ValaBooleanLiteral* self); void vala_boolean_literal_set_value (ValaBooleanLiteral* self, gboolean value); GType vala_value_type_get_type (void) G_GNUC_CONST; GType vala_boolean_type_get_type (void) G_GNUC_CONST; ValaBooleanType* vala_boolean_type_new (ValaStruct* type_symbol); ValaBooleanType* vala_boolean_type_construct (GType object_type, ValaStruct* type_symbol); GType vala_break_statement_get_type (void) G_GNUC_CONST; ValaBreakStatement* vala_break_statement_new (ValaSourceReference* source); ValaBreakStatement* vala_break_statement_construct (GType object_type, ValaSourceReference* source); void vala_callable_add_parameter (ValaCallable* self, ValaParameter* param); ValaList* vala_callable_get_parameters (ValaCallable* self); ValaDataType* vala_callable_get_return_type (ValaCallable* self); void vala_callable_set_return_type (ValaCallable* self, ValaDataType* value); GType vala_callable_type_get_type (void) G_GNUC_CONST; ValaCallableType* vala_callable_type_construct (GType object_type); GType vala_cast_expression_get_type (void) G_GNUC_CONST; ValaCastExpression* vala_cast_expression_new (ValaExpression* inner, ValaDataType* type_reference, ValaSourceReference* source_reference); ValaCastExpression* vala_cast_expression_construct (GType object_type, ValaExpression* inner, ValaDataType* type_reference, ValaSourceReference* source_reference); ValaCastExpression* vala_cast_expression_new_silent (ValaExpression* inner, ValaDataType* type_reference, ValaSourceReference* source_reference); ValaCastExpression* vala_cast_expression_construct_silent (GType object_type, ValaExpression* inner, ValaDataType* type_reference, ValaSourceReference* source_reference); ValaCastExpression* vala_cast_expression_new_non_null (ValaExpression* inner, ValaSourceReference* source_reference); ValaCastExpression* vala_cast_expression_construct_non_null (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference); ValaExpression* vala_cast_expression_get_inner (ValaCastExpression* self); void vala_cast_expression_set_inner (ValaCastExpression* self, ValaExpression* value); ValaDataType* vala_cast_expression_get_type_reference (ValaCastExpression* self); void vala_cast_expression_set_type_reference (ValaCastExpression* self, ValaDataType* value); gboolean vala_cast_expression_get_is_silent_cast (ValaCastExpression* self); gboolean vala_cast_expression_get_is_non_null_cast (ValaCastExpression* self); GType vala_catch_clause_get_type (void) G_GNUC_CONST; ValaCatchClause* vala_catch_clause_new (ValaDataType* error_type, const gchar* variable_name, ValaBlock* body, ValaSourceReference* source_reference); ValaCatchClause* vala_catch_clause_construct (GType object_type, ValaDataType* error_type, const gchar* variable_name, ValaBlock* body, ValaSourceReference* source_reference); ValaDataType* vala_catch_clause_get_error_type (ValaCatchClause* self); void vala_catch_clause_set_error_type (ValaCatchClause* self, ValaDataType* value); const gchar* vala_catch_clause_get_variable_name (ValaCatchClause* self); void vala_catch_clause_set_variable_name (ValaCatchClause* self, const gchar* value); ValaBlock* vala_catch_clause_get_body (ValaCatchClause* self); void vala_catch_clause_set_body (ValaCatchClause* self, ValaBlock* value); ValaLocalVariable* vala_catch_clause_get_error_variable (ValaCatchClause* self); void vala_catch_clause_set_error_variable (ValaCatchClause* self, ValaLocalVariable* value); const gchar* vala_catch_clause_get_clabel_name (ValaCatchClause* self); void vala_catch_clause_set_clabel_name (ValaCatchClause* self, const gchar* value); GType vala_character_literal_get_type (void) G_GNUC_CONST; ValaCharacterLiteral* vala_character_literal_new (const gchar* c, ValaSourceReference* source); ValaCharacterLiteral* vala_character_literal_construct (GType object_type, const gchar* c, ValaSourceReference* source); gunichar vala_character_literal_get_char (ValaCharacterLiteral* self); const gchar* vala_character_literal_get_value (ValaCharacterLiteral* self); void vala_character_literal_set_value (ValaCharacterLiteral* self, const gchar* value); ValaList* vala_class_get_classes (ValaClass* self); ValaList* vala_class_get_structs (ValaClass* self); ValaList* vala_class_get_enums (ValaClass* self); ValaList* vala_class_get_delegates (ValaClass* self); gpointer vala_comment_ref (gpointer instance); void vala_comment_unref (gpointer instance); GParamSpec* vala_param_spec_comment (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_comment (GValue* value, gpointer v_object); void vala_value_take_comment (GValue* value, gpointer v_object); gpointer vala_value_get_comment (const GValue* value); GType vala_comment_get_type (void) G_GNUC_CONST; ValaClass* vala_class_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaClass* vala_class_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); void vala_class_add_base_type (ValaClass* self, ValaDataType* type); ValaList* vala_class_get_base_types (ValaClass* self); ValaList* vala_class_get_fields (ValaClass* self); ValaList* vala_class_get_constants (ValaClass* self); gboolean vala_class_is_fundamental (ValaClass* self); ValaClass* vala_class_get_base_class (ValaClass* self); void vala_class_set_base_class (ValaClass* self, ValaClass* value); gboolean vala_class_get_is_abstract (ValaClass* self); void vala_class_set_is_abstract (ValaClass* self, gboolean value); gboolean vala_class_get_is_compact (ValaClass* self); void vala_class_set_is_compact (ValaClass* self, gboolean value); gboolean vala_class_get_is_immutable (ValaClass* self); void vala_class_set_is_immutable (ValaClass* self, gboolean value); gboolean vala_class_get_has_private_fields (ValaClass* self); void vala_class_set_has_private_fields (ValaClass* self, gboolean value); gboolean vala_class_get_has_class_private_fields (ValaClass* self); GType vala_creation_method_get_type (void) G_GNUC_CONST; ValaCreationMethod* vala_class_get_default_construction_method (ValaClass* self); void vala_class_set_default_construction_method (ValaClass* self, ValaCreationMethod* value); ValaConstructor* vala_class_get_constructor (ValaClass* self); void vala_class_set_constructor (ValaClass* self, ValaConstructor* value); ValaConstructor* vala_class_get_class_constructor (ValaClass* self); void vala_class_set_class_constructor (ValaClass* self, ValaConstructor* value); ValaConstructor* vala_class_get_static_constructor (ValaClass* self); void vala_class_set_static_constructor (ValaClass* self, ValaConstructor* value); ValaDestructor* vala_class_get_destructor (ValaClass* self); void vala_class_set_destructor (ValaClass* self, ValaDestructor* value); ValaDestructor* vala_class_get_static_destructor (ValaClass* self); void vala_class_set_static_destructor (ValaClass* self, ValaDestructor* value); ValaDestructor* vala_class_get_class_destructor (ValaClass* self); void vala_class_set_class_destructor (ValaClass* self, ValaDestructor* value); gboolean vala_class_get_is_error_base (ValaClass* self); GType vala_class_type_get_type (void) G_GNUC_CONST; ValaClassType* vala_class_type_new (ValaClass* class_symbol); ValaClassType* vala_class_type_construct (GType object_type, ValaClass* class_symbol); ValaClass* vala_class_type_get_class_symbol (ValaClassType* self); void vala_class_type_set_class_symbol (ValaClassType* self, ValaClass* value); gboolean vala_code_context_require_glib_version (ValaCodeContext* self, gint major, gint minor); ValaCodeContext* vala_code_context_new (void); ValaCodeContext* vala_code_context_construct (GType object_type); ValaCodeContext* vala_code_context_get (void); void vala_code_context_push (ValaCodeContext* context); void vala_code_context_pop (void); gpointer vala_source_file_ref (gpointer instance); void vala_source_file_unref (gpointer instance); GParamSpec* vala_param_spec_source_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_source_file (GValue* value, gpointer v_object); void vala_value_take_source_file (GValue* value, gpointer v_object); gpointer vala_value_get_source_file (const GValue* value); GType vala_source_file_get_type (void) G_GNUC_CONST; ValaList* vala_code_context_get_source_files (ValaCodeContext* self); ValaList* vala_code_context_get_c_source_files (ValaCodeContext* self); void vala_code_context_add_source_file (ValaCodeContext* self, ValaSourceFile* file); void vala_code_context_add_c_source_file (ValaCodeContext* self, const gchar* file); ValaList* vala_code_context_get_packages (ValaCodeContext* self); gboolean vala_code_context_has_package (ValaCodeContext* self, const gchar* pkg); void vala_code_context_add_package (ValaCodeContext* self, const gchar* pkg); gboolean vala_code_context_add_external_package (ValaCodeContext* self, const gchar* pkg); gboolean vala_code_context_add_packages_from_file (ValaCodeContext* self, const gchar* filename); gboolean vala_code_context_add_source_filename (ValaCodeContext* self, const gchar* filename, gboolean is_source, gboolean cmdline); void vala_code_context_accept (ValaCodeContext* self, ValaCodeVisitor* visitor); void vala_code_context_check (ValaCodeContext* self); void vala_code_context_add_define (ValaCodeContext* self, const gchar* define); gboolean vala_code_context_is_defined (ValaCodeContext* self, const gchar* define); gchar* vala_code_context_get_vapi_path (ValaCodeContext* self, const gchar* pkg); gchar* vala_code_context_get_gir_path (ValaCodeContext* self, const gchar* gir); gchar* vala_code_context_get_gresource_path (ValaCodeContext* self, const gchar* gresource, const gchar* resource); gchar* vala_code_context_get_metadata_path (ValaCodeContext* self, const gchar* gir_filename); void vala_code_context_write_dependencies (ValaCodeContext* self, const gchar* filename); gchar* vala_code_context_realpath (const gchar* name); gboolean vala_code_context_get_assert (ValaCodeContext* self); void vala_code_context_set_assert (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_checking (ValaCodeContext* self); void vala_code_context_set_checking (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_deprecated (ValaCodeContext* self); void vala_code_context_set_deprecated (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_hide_internal (ValaCodeContext* self); void vala_code_context_set_hide_internal (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_since_check (ValaCodeContext* self); void vala_code_context_set_since_check (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_experimental (ValaCodeContext* self); void vala_code_context_set_experimental (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_experimental_non_null (ValaCodeContext* self); void vala_code_context_set_experimental_non_null (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_gobject_tracing (ValaCodeContext* self); void vala_code_context_set_gobject_tracing (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_ccode_only (ValaCodeContext* self); void vala_code_context_set_ccode_only (ValaCodeContext* self, gboolean value); const gchar* vala_code_context_get_header_filename (ValaCodeContext* self); void vala_code_context_set_header_filename (ValaCodeContext* self, const gchar* value); const gchar* vala_code_context_get_internal_header_filename (ValaCodeContext* self); void vala_code_context_set_internal_header_filename (ValaCodeContext* self, const gchar* value); gboolean vala_code_context_get_use_header (ValaCodeContext* self); void vala_code_context_set_use_header (ValaCodeContext* self, gboolean value); const gchar* vala_code_context_get_includedir (ValaCodeContext* self); void vala_code_context_set_includedir (ValaCodeContext* self, const gchar* value); const gchar* vala_code_context_get_symbols_filename (ValaCodeContext* self); void vala_code_context_set_symbols_filename (ValaCodeContext* self, const gchar* value); gboolean vala_code_context_get_compile_only (ValaCodeContext* self); void vala_code_context_set_compile_only (ValaCodeContext* self, gboolean value); const gchar* vala_code_context_get_output (ValaCodeContext* self); void vala_code_context_set_output (ValaCodeContext* self, const gchar* value); const gchar* vala_code_context_get_basedir (ValaCodeContext* self); void vala_code_context_set_basedir (ValaCodeContext* self, const gchar* value); const gchar* vala_code_context_get_directory (ValaCodeContext* self); void vala_code_context_set_directory (ValaCodeContext* self, const gchar* value); gchar** vala_code_context_get_vapi_directories (ValaCodeContext* self, int* result_length1); void vala_code_context_set_vapi_directories (ValaCodeContext* self, gchar** value, int value_length1); gchar** vala_code_context_get_gir_directories (ValaCodeContext* self, int* result_length1); void vala_code_context_set_gir_directories (ValaCodeContext* self, gchar** value, int value_length1); gchar** vala_code_context_get_metadata_directories (ValaCodeContext* self, int* result_length1); void vala_code_context_set_metadata_directories (ValaCodeContext* self, gchar** value, int value_length1); gboolean vala_code_context_get_debug (ValaCodeContext* self); void vala_code_context_set_debug (ValaCodeContext* self, gboolean value); gint vala_code_context_get_optlevel (ValaCodeContext* self); void vala_code_context_set_optlevel (ValaCodeContext* self, gint value); gboolean vala_code_context_get_mem_profiler (ValaCodeContext* self); void vala_code_context_set_mem_profiler (ValaCodeContext* self, gboolean value); ValaMethod* vala_code_context_get_module_init_method (ValaCodeContext* self); void vala_code_context_set_module_init_method (ValaCodeContext* self, ValaMethod* value); gboolean vala_code_context_get_save_temps (ValaCodeContext* self); void vala_code_context_set_save_temps (ValaCodeContext* self, gboolean value); GType vala_profile_get_type (void) G_GNUC_CONST; ValaProfile vala_code_context_get_profile (ValaCodeContext* self); void vala_code_context_set_profile (ValaCodeContext* self, ValaProfile value); gint vala_code_context_get_target_glib_major (ValaCodeContext* self); void vala_code_context_set_target_glib_major (ValaCodeContext* self, gint value); gint vala_code_context_get_target_glib_minor (ValaCodeContext* self); void vala_code_context_set_target_glib_minor (ValaCodeContext* self, gint value); gboolean vala_code_context_get_verbose_mode (ValaCodeContext* self); void vala_code_context_set_verbose_mode (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_version_header (ValaCodeContext* self); void vala_code_context_set_version_header (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_nostdpkg (ValaCodeContext* self); void vala_code_context_set_nostdpkg (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_use_fast_vapi (ValaCodeContext* self); void vala_code_context_set_use_fast_vapi (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_vapi_comments (ValaCodeContext* self); void vala_code_context_set_vapi_comments (ValaCodeContext* self, gboolean value); gboolean vala_code_context_get_save_csources (ValaCodeContext* self); gpointer vala_report_ref (gpointer instance); void vala_report_unref (gpointer instance); GParamSpec* vala_param_spec_report (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_report (GValue* value, gpointer v_object); void vala_value_take_report (GValue* value, gpointer v_object); gpointer vala_value_get_report (const GValue* value); GType vala_report_get_type (void) G_GNUC_CONST; ValaReport* vala_code_context_get_report (ValaCodeContext* self); void vala_code_context_set_report (ValaCodeContext* self, ValaReport* value); ValaMethod* vala_code_context_get_entry_point (ValaCodeContext* self); void vala_code_context_set_entry_point (ValaCodeContext* self, ValaMethod* value); const gchar* vala_code_context_get_entry_point_name (ValaCodeContext* self); void vala_code_context_set_entry_point_name (ValaCodeContext* self, const gchar* value); gboolean vala_code_context_get_run_output (ValaCodeContext* self); void vala_code_context_set_run_output (ValaCodeContext* self, gboolean value); gchar** vala_code_context_get_gresources (ValaCodeContext* self, int* result_length1); void vala_code_context_set_gresources (ValaCodeContext* self, gchar** value, int value_length1); gchar** vala_code_context_get_gresources_directories (ValaCodeContext* self, int* result_length1); void vala_code_context_set_gresources_directories (ValaCodeContext* self, gchar** value, int value_length1); ValaNamespace* vala_code_context_get_root (ValaCodeContext* self); GType vala_symbol_resolver_get_type (void) G_GNUC_CONST; ValaSymbolResolver* vala_code_context_get_resolver (ValaCodeContext* self); GType vala_semantic_analyzer_get_type (void) G_GNUC_CONST; ValaSemanticAnalyzer* vala_code_context_get_analyzer (ValaCodeContext* self); GType vala_flow_analyzer_get_type (void) G_GNUC_CONST; ValaFlowAnalyzer* vala_code_context_get_flow_analyzer (ValaCodeContext* self); ValaCodeGenerator* vala_code_context_get_codegen (ValaCodeContext* self); void vala_code_context_set_codegen (ValaCodeContext* self, ValaCodeGenerator* value); GType vala_used_attr_get_type (void) G_GNUC_CONST; ValaUsedAttr* vala_code_context_get_used_attr (ValaCodeContext* self); void vala_code_context_set_used_attr (ValaCodeContext* self, ValaUsedAttr* value); GType vala_enum_value_get_type (void) G_GNUC_CONST; GType vala_error_code_get_type (void) G_GNUC_CONST; GType vala_property_accessor_get_type (void) G_GNUC_CONST; GType vala_using_directive_get_type (void) G_GNUC_CONST; GType vala_empty_statement_get_type (void) G_GNUC_CONST; GType vala_declaration_statement_get_type (void) G_GNUC_CONST; GType vala_expression_statement_get_type (void) G_GNUC_CONST; GType vala_if_statement_get_type (void) G_GNUC_CONST; GType vala_switch_statement_get_type (void) G_GNUC_CONST; GType vala_switch_section_get_type (void) G_GNUC_CONST; GType vala_switch_label_get_type (void) G_GNUC_CONST; GType vala_loop_get_type (void) G_GNUC_CONST; GType vala_while_statement_get_type (void) G_GNUC_CONST; GType vala_do_statement_get_type (void) G_GNUC_CONST; GType vala_for_statement_get_type (void) G_GNUC_CONST; GType vala_foreach_statement_get_type (void) G_GNUC_CONST; GType vala_continue_statement_get_type (void) G_GNUC_CONST; GType vala_return_statement_get_type (void) G_GNUC_CONST; GType vala_yield_statement_get_type (void) G_GNUC_CONST; GType vala_throw_statement_get_type (void) G_GNUC_CONST; GType vala_try_statement_get_type (void) G_GNUC_CONST; GType vala_lock_statement_get_type (void) G_GNUC_CONST; GType vala_unlock_statement_get_type (void) G_GNUC_CONST; GType vala_delete_statement_get_type (void) G_GNUC_CONST; GType vala_integer_literal_get_type (void) G_GNUC_CONST; GType vala_real_literal_get_type (void) G_GNUC_CONST; GType vala_regex_literal_get_type (void) G_GNUC_CONST; GType vala_string_literal_get_type (void) G_GNUC_CONST; GType vala_template_get_type (void) G_GNUC_CONST; GType vala_tuple_get_type (void) G_GNUC_CONST; GType vala_null_literal_get_type (void) G_GNUC_CONST; GType vala_member_access_get_type (void) G_GNUC_CONST; GType vala_method_call_get_type (void) G_GNUC_CONST; GType vala_element_access_get_type (void) G_GNUC_CONST; GType vala_slice_expression_get_type (void) G_GNUC_CONST; GType vala_postfix_expression_get_type (void) G_GNUC_CONST; GType vala_object_creation_expression_get_type (void) G_GNUC_CONST; GType vala_sizeof_expression_get_type (void) G_GNUC_CONST; GType vala_typeof_expression_get_type (void) G_GNUC_CONST; GType vala_unary_expression_get_type (void) G_GNUC_CONST; GType vala_named_argument_get_type (void) G_GNUC_CONST; GType vala_pointer_indirection_get_type (void) G_GNUC_CONST; GType vala_reference_transfer_expression_get_type (void) G_GNUC_CONST; GType vala_typecheck_get_type (void) G_GNUC_CONST; GType vala_conditional_expression_get_type (void) G_GNUC_CONST; GType vala_lambda_expression_get_type (void) G_GNUC_CONST; gpointer vala_target_value_ref (gpointer instance); void vala_target_value_unref (gpointer instance); GParamSpec* vala_param_spec_target_value (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_target_value (GValue* value, gpointer v_object); void vala_value_take_target_value (GValue* value, gpointer v_object); gpointer vala_value_get_target_value (const GValue* value); GType vala_target_value_get_type (void) G_GNUC_CONST; void vala_code_generator_emit (ValaCodeGenerator* self, ValaCodeContext* context); ValaTargetValue* vala_code_generator_load_local (ValaCodeGenerator* self, ValaLocalVariable* local); void vala_code_generator_store_local (ValaCodeGenerator* self, ValaLocalVariable* local, ValaTargetValue* value, gboolean initializer, ValaSourceReference* source_reference); ValaTargetValue* vala_code_generator_load_parameter (ValaCodeGenerator* self, ValaParameter* param); void vala_code_generator_store_parameter (ValaCodeGenerator* self, ValaParameter* param, ValaTargetValue* value, gboolean capturing_parameter, ValaSourceReference* source_reference); ValaTargetValue* vala_code_generator_load_field (ValaCodeGenerator* self, ValaField* field, ValaTargetValue* instance); void vala_code_generator_store_field (ValaCodeGenerator* self, ValaField* field, ValaTargetValue* instance, ValaTargetValue* value, ValaSourceReference* source_reference); ValaCodeGenerator* vala_code_generator_construct (GType object_type); ValaList* vala_code_node_get_error_types (ValaCodeNode* self); void vala_code_node_add_error_type (ValaCodeNode* self, ValaDataType* error_type); void vala_code_node_add_error_types (ValaCodeNode* self, ValaList* error_types); void vala_code_node_accept (ValaCodeNode* self, ValaCodeVisitor* visitor); void vala_code_node_accept_children (ValaCodeNode* self, ValaCodeVisitor* visitor); gboolean vala_code_node_check (ValaCodeNode* self, ValaCodeContext* context); void vala_code_node_emit (ValaCodeNode* self, ValaCodeGenerator* codegen); void vala_code_node_replace_type (ValaCodeNode* self, ValaDataType* old_type, ValaDataType* new_type); void vala_code_node_replace_expression (ValaCodeNode* self, ValaExpression* old_node, ValaExpression* new_node); ValaAttribute* vala_code_node_get_attribute (ValaCodeNode* self, const gchar* name); gboolean vala_code_node_has_attribute_argument (ValaCodeNode* self, const gchar* attribute, const gchar* argument); void vala_code_node_set_attribute (ValaCodeNode* self, const gchar* name, gboolean value, ValaSourceReference* source_reference); void vala_code_node_remove_attribute_argument (ValaCodeNode* self, const gchar* attribute, const gchar* argument); gchar* vala_code_node_get_attribute_string (ValaCodeNode* self, const gchar* attribute, const gchar* argument, const gchar* default_value); gint vala_code_node_get_attribute_integer (ValaCodeNode* self, const gchar* attribute, const gchar* argument, gint default_value); gdouble vala_code_node_get_attribute_double (ValaCodeNode* self, const gchar* attribute, const gchar* argument, gdouble default_value); gboolean vala_code_node_get_attribute_bool (ValaCodeNode* self, const gchar* attribute, const gchar* argument, gboolean default_value); void vala_code_node_set_attribute_string (ValaCodeNode* self, const gchar* attribute, const gchar* argument, const gchar* value, ValaSourceReference* source_reference); void vala_code_node_set_attribute_integer (ValaCodeNode* self, const gchar* attribute, const gchar* argument, gint value, ValaSourceReference* source_reference); void vala_code_node_set_attribute_double (ValaCodeNode* self, const gchar* attribute, const gchar* argument, gdouble value, ValaSourceReference* source_reference); void vala_code_node_set_attribute_bool (ValaCodeNode* self, const gchar* attribute, const gchar* argument, gboolean value, ValaSourceReference* source_reference); gpointer vala_attribute_cache_ref (gpointer instance); void vala_attribute_cache_unref (gpointer instance); GParamSpec* vala_param_spec_attribute_cache (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_attribute_cache (GValue* value, gpointer v_object); void vala_value_take_attribute_cache (GValue* value, gpointer v_object); gpointer vala_value_get_attribute_cache (const GValue* value); GType vala_attribute_cache_get_type (void) G_GNUC_CONST; ValaAttributeCache* vala_code_node_get_attribute_cache (ValaCodeNode* self, gint index); void vala_code_node_set_attribute_cache (ValaCodeNode* self, gint index, ValaAttributeCache* cache); gchar* vala_code_node_to_string (ValaCodeNode* self); void vala_code_node_get_defined_variables (ValaCodeNode* self, ValaCollection* collection); void vala_code_node_get_used_variables (ValaCodeNode* self, ValaCollection* collection); gchar* vala_code_node_get_temp_name (void); gint vala_code_node_get_attribute_cache_index (void); ValaCodeNode* vala_code_node_construct (GType object_type); ValaCodeNode* vala_code_node_get_parent_node (ValaCodeNode* self); void vala_code_node_set_parent_node (ValaCodeNode* self, ValaCodeNode* value); ValaSourceReference* vala_code_node_get_source_reference (ValaCodeNode* self); void vala_code_node_set_source_reference (ValaCodeNode* self, ValaSourceReference* value); gboolean vala_code_node_get_unreachable (ValaCodeNode* self); void vala_code_node_set_unreachable (ValaCodeNode* self, gboolean value); const gchar* vala_code_node_get_type_name (ValaCodeNode* self); gboolean vala_code_node_get_checked (ValaCodeNode* self); void vala_code_node_set_checked (ValaCodeNode* self, gboolean value); gboolean vala_code_node_get_error (ValaCodeNode* self); void vala_code_node_set_error (ValaCodeNode* self, gboolean value); gboolean vala_code_node_get_tree_can_fail (ValaCodeNode* self); ValaAttributeCache* vala_attribute_cache_new (void); ValaAttributeCache* vala_attribute_cache_construct (GType object_type); void vala_code_visitor_visit_source_file (ValaCodeVisitor* self, ValaSourceFile* source_file); void vala_code_visitor_visit_namespace (ValaCodeVisitor* self, ValaNamespace* ns); void vala_code_visitor_visit_class (ValaCodeVisitor* self, ValaClass* cl); void vala_code_visitor_visit_struct (ValaCodeVisitor* self, ValaStruct* st); void vala_code_visitor_visit_interface (ValaCodeVisitor* self, ValaInterface* iface); void vala_code_visitor_visit_enum (ValaCodeVisitor* self, ValaEnum* en); void vala_code_visitor_visit_enum_value (ValaCodeVisitor* self, ValaEnumValue* ev); void vala_code_visitor_visit_error_domain (ValaCodeVisitor* self, ValaErrorDomain* edomain); void vala_code_visitor_visit_error_code (ValaCodeVisitor* self, ValaErrorCode* ecode); void vala_code_visitor_visit_delegate (ValaCodeVisitor* self, ValaDelegate* d); void vala_code_visitor_visit_constant (ValaCodeVisitor* self, ValaConstant* c); void vala_code_visitor_visit_field (ValaCodeVisitor* self, ValaField* f); void vala_code_visitor_visit_method (ValaCodeVisitor* self, ValaMethod* m); void vala_code_visitor_visit_creation_method (ValaCodeVisitor* self, ValaCreationMethod* m); void vala_code_visitor_visit_formal_parameter (ValaCodeVisitor* self, ValaParameter* p); void vala_code_visitor_visit_property (ValaCodeVisitor* self, ValaProperty* prop); void vala_code_visitor_visit_property_accessor (ValaCodeVisitor* self, ValaPropertyAccessor* acc); void vala_code_visitor_visit_signal (ValaCodeVisitor* self, ValaSignal* sig); void vala_code_visitor_visit_constructor (ValaCodeVisitor* self, ValaConstructor* c); void vala_code_visitor_visit_destructor (ValaCodeVisitor* self, ValaDestructor* d); void vala_code_visitor_visit_type_parameter (ValaCodeVisitor* self, ValaTypeParameter* p); void vala_code_visitor_visit_using_directive (ValaCodeVisitor* self, ValaUsingDirective* ns); void vala_code_visitor_visit_data_type (ValaCodeVisitor* self, ValaDataType* type); void vala_code_visitor_visit_block (ValaCodeVisitor* self, ValaBlock* b); void vala_code_visitor_visit_empty_statement (ValaCodeVisitor* self, ValaEmptyStatement* stmt); void vala_code_visitor_visit_declaration_statement (ValaCodeVisitor* self, ValaDeclarationStatement* stmt); void vala_code_visitor_visit_local_variable (ValaCodeVisitor* self, ValaLocalVariable* local); void vala_code_visitor_visit_initializer_list (ValaCodeVisitor* self, ValaInitializerList* list); void vala_code_visitor_visit_expression_statement (ValaCodeVisitor* self, ValaExpressionStatement* stmt); void vala_code_visitor_visit_if_statement (ValaCodeVisitor* self, ValaIfStatement* stmt); void vala_code_visitor_visit_switch_statement (ValaCodeVisitor* self, ValaSwitchStatement* stmt); void vala_code_visitor_visit_switch_section (ValaCodeVisitor* self, ValaSwitchSection* section); void vala_code_visitor_visit_switch_label (ValaCodeVisitor* self, ValaSwitchLabel* label); void vala_code_visitor_visit_loop (ValaCodeVisitor* self, ValaLoop* stmt); void vala_code_visitor_visit_while_statement (ValaCodeVisitor* self, ValaWhileStatement* stmt); void vala_code_visitor_visit_do_statement (ValaCodeVisitor* self, ValaDoStatement* stmt); void vala_code_visitor_visit_for_statement (ValaCodeVisitor* self, ValaForStatement* stmt); void vala_code_visitor_visit_foreach_statement (ValaCodeVisitor* self, ValaForeachStatement* stmt); void vala_code_visitor_visit_break_statement (ValaCodeVisitor* self, ValaBreakStatement* stmt); void vala_code_visitor_visit_continue_statement (ValaCodeVisitor* self, ValaContinueStatement* stmt); void vala_code_visitor_visit_return_statement (ValaCodeVisitor* self, ValaReturnStatement* stmt); void vala_code_visitor_visit_yield_statement (ValaCodeVisitor* self, ValaYieldStatement* y); void vala_code_visitor_visit_throw_statement (ValaCodeVisitor* self, ValaThrowStatement* stmt); void vala_code_visitor_visit_try_statement (ValaCodeVisitor* self, ValaTryStatement* stmt); void vala_code_visitor_visit_catch_clause (ValaCodeVisitor* self, ValaCatchClause* clause); void vala_code_visitor_visit_lock_statement (ValaCodeVisitor* self, ValaLockStatement* stmt); void vala_code_visitor_visit_unlock_statement (ValaCodeVisitor* self, ValaUnlockStatement* stmt); void vala_code_visitor_visit_delete_statement (ValaCodeVisitor* self, ValaDeleteStatement* stmt); void vala_code_visitor_visit_expression (ValaCodeVisitor* self, ValaExpression* expr); void vala_code_visitor_visit_array_creation_expression (ValaCodeVisitor* self, ValaArrayCreationExpression* expr); void vala_code_visitor_visit_boolean_literal (ValaCodeVisitor* self, ValaBooleanLiteral* lit); void vala_code_visitor_visit_character_literal (ValaCodeVisitor* self, ValaCharacterLiteral* lit); void vala_code_visitor_visit_integer_literal (ValaCodeVisitor* self, ValaIntegerLiteral* lit); void vala_code_visitor_visit_real_literal (ValaCodeVisitor* self, ValaRealLiteral* lit); void vala_code_visitor_visit_regex_literal (ValaCodeVisitor* self, ValaRegexLiteral* lit); void vala_code_visitor_visit_string_literal (ValaCodeVisitor* self, ValaStringLiteral* lit); void vala_code_visitor_visit_template (ValaCodeVisitor* self, ValaTemplate* tmpl); void vala_code_visitor_visit_tuple (ValaCodeVisitor* self, ValaTuple* tuple); void vala_code_visitor_visit_null_literal (ValaCodeVisitor* self, ValaNullLiteral* lit); void vala_code_visitor_visit_member_access (ValaCodeVisitor* self, ValaMemberAccess* expr); void vala_code_visitor_visit_method_call (ValaCodeVisitor* self, ValaMethodCall* expr); void vala_code_visitor_visit_element_access (ValaCodeVisitor* self, ValaElementAccess* expr); void vala_code_visitor_visit_slice_expression (ValaCodeVisitor* self, ValaSliceExpression* expr); void vala_code_visitor_visit_base_access (ValaCodeVisitor* self, ValaBaseAccess* expr); void vala_code_visitor_visit_postfix_expression (ValaCodeVisitor* self, ValaPostfixExpression* expr); void vala_code_visitor_visit_object_creation_expression (ValaCodeVisitor* self, ValaObjectCreationExpression* expr); void vala_code_visitor_visit_sizeof_expression (ValaCodeVisitor* self, ValaSizeofExpression* expr); void vala_code_visitor_visit_typeof_expression (ValaCodeVisitor* self, ValaTypeofExpression* expr); void vala_code_visitor_visit_unary_expression (ValaCodeVisitor* self, ValaUnaryExpression* expr); void vala_code_visitor_visit_cast_expression (ValaCodeVisitor* self, ValaCastExpression* expr); void vala_code_visitor_visit_named_argument (ValaCodeVisitor* self, ValaNamedArgument* expr); void vala_code_visitor_visit_pointer_indirection (ValaCodeVisitor* self, ValaPointerIndirection* expr); void vala_code_visitor_visit_addressof_expression (ValaCodeVisitor* self, ValaAddressofExpression* expr); void vala_code_visitor_visit_reference_transfer_expression (ValaCodeVisitor* self, ValaReferenceTransferExpression* expr); void vala_code_visitor_visit_binary_expression (ValaCodeVisitor* self, ValaBinaryExpression* expr); void vala_code_visitor_visit_type_check (ValaCodeVisitor* self, ValaTypeCheck* expr); void vala_code_visitor_visit_conditional_expression (ValaCodeVisitor* self, ValaConditionalExpression* expr); void vala_code_visitor_visit_lambda_expression (ValaCodeVisitor* self, ValaLambdaExpression* expr); void vala_code_visitor_visit_assignment (ValaCodeVisitor* self, ValaAssignment* a); void vala_code_visitor_visit_end_full_expression (ValaCodeVisitor* self, ValaExpression* expr); ValaCodeVisitor* vala_code_visitor_construct (GType object_type); GType vala_code_writer_get_type (void) G_GNUC_CONST; GType vala_code_writer_type_get_type (void) G_GNUC_CONST; ValaCodeWriter* vala_code_writer_new (ValaCodeWriterType type); ValaCodeWriter* vala_code_writer_construct (GType object_type, ValaCodeWriterType type); void vala_code_writer_set_cheader_override (ValaCodeWriter* self, const gchar* original, const gchar* replacement); void vala_code_writer_write_file (ValaCodeWriter* self, ValaCodeContext* context, const gchar* filename); ValaComment* vala_comment_new (const gchar* comment, ValaSourceReference* _source_reference); ValaComment* vala_comment_construct (GType object_type, const gchar* comment, ValaSourceReference* _source_reference); const gchar* vala_comment_get_content (ValaComment* self); void vala_comment_set_content (ValaComment* self, const gchar* value); ValaSourceReference* vala_comment_get_source_reference (ValaComment* self); void vala_comment_set_source_reference (ValaComment* self, ValaSourceReference* value); GType vala_gir_comment_get_type (void) G_GNUC_CONST; ValaMapIterator* vala_gir_comment_parameter_iterator (ValaGirComment* self); ValaGirComment* vala_gir_comment_new (const gchar* comment, ValaSourceReference* _source_reference); ValaGirComment* vala_gir_comment_construct (GType object_type, const gchar* comment, ValaSourceReference* _source_reference); ValaComment* vala_gir_comment_get_content_for_parameter (ValaGirComment* self, const gchar* name); ValaComment* vala_gir_comment_get_return_content (ValaGirComment* self); void vala_gir_comment_set_return_content (ValaGirComment* self, ValaComment* value); ValaConditionalExpression* vala_conditional_expression_new (ValaExpression* cond, ValaExpression* true_expr, ValaExpression* false_expr, ValaSourceReference* source); ValaConditionalExpression* vala_conditional_expression_construct (GType object_type, ValaExpression* cond, ValaExpression* true_expr, ValaExpression* false_expr, ValaSourceReference* source); ValaExpression* vala_conditional_expression_get_condition (ValaConditionalExpression* self); void vala_conditional_expression_set_condition (ValaConditionalExpression* self, ValaExpression* value); ValaExpression* vala_conditional_expression_get_true_expression (ValaConditionalExpression* self); void vala_conditional_expression_set_true_expression (ValaConditionalExpression* self, ValaExpression* value); ValaExpression* vala_conditional_expression_get_false_expression (ValaConditionalExpression* self); void vala_conditional_expression_set_false_expression (ValaConditionalExpression* self, ValaExpression* value); ValaConstant* vala_constant_new (const gchar* name, ValaDataType* type_reference, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment); ValaConstant* vala_constant_construct (GType object_type, const gchar* name, ValaDataType* type_reference, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment); ValaDataType* vala_constant_get_type_reference (ValaConstant* self); void vala_constant_set_type_reference (ValaConstant* self, ValaDataType* value); ValaExpression* vala_constant_get_value (ValaConstant* self); void vala_constant_set_value (ValaConstant* self, ValaExpression* value); ValaConstructor* vala_constructor_new (ValaSourceReference* source); ValaConstructor* vala_constructor_construct (GType object_type, ValaSourceReference* source); ValaParameter* vala_constructor_get_this_parameter (ValaConstructor* self); void vala_constructor_set_this_parameter (ValaConstructor* self, ValaParameter* value); GType vala_member_binding_get_type (void) G_GNUC_CONST; ValaMemberBinding vala_constructor_get_binding (ValaConstructor* self); void vala_constructor_set_binding (ValaConstructor* self, ValaMemberBinding value); ValaContinueStatement* vala_continue_statement_new (ValaSourceReference* source); ValaContinueStatement* vala_continue_statement_construct (GType object_type, ValaSourceReference* source); ValaCreationMethod* vala_creation_method_new (const gchar* class_name, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaCreationMethod* vala_creation_method_construct (GType object_type, const gchar* class_name, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); const gchar* vala_creation_method_get_class_name (ValaCreationMethod* self); void vala_creation_method_set_class_name (ValaCreationMethod* self, const gchar* value); gboolean vala_creation_method_get_chain_up (ValaCreationMethod* self); void vala_creation_method_set_chain_up (ValaCreationMethod* self, gboolean value); void vala_data_type_add_type_argument (ValaDataType* self, ValaDataType* arg); ValaList* vala_data_type_get_type_arguments (ValaDataType* self); gboolean vala_data_type_has_type_arguments (ValaDataType* self); void vala_data_type_remove_all_type_arguments (ValaDataType* self); gchar* vala_data_type_to_qualified_string (ValaDataType* self, ValaScope* scope); ValaDataType* vala_data_type_copy (ValaDataType* self); gboolean vala_data_type_equals (ValaDataType* self, ValaDataType* type2); gboolean vala_data_type_stricter (ValaDataType* self, ValaDataType* type2); gboolean vala_data_type_compatible (ValaDataType* self, ValaDataType* target_type); gboolean vala_data_type_is_invokable (ValaDataType* self); ValaDataType* vala_data_type_get_return_type (ValaDataType* self); ValaList* vala_data_type_get_parameters (ValaDataType* self); gboolean vala_data_type_is_reference_type_or_type_parameter (ValaDataType* self); gboolean vala_data_type_is_array (ValaDataType* self); gboolean vala_data_type_is_accessible (ValaDataType* self, ValaSymbol* sym); ValaSymbol* vala_data_type_get_member (ValaDataType* self, const gchar* member_name); ValaSymbol* vala_data_type_get_pointer_member (ValaDataType* self, const gchar* member_name); gboolean vala_data_type_is_real_struct_type (ValaDataType* self); gboolean vala_data_type_is_real_non_null_struct_type (ValaDataType* self); gboolean vala_data_type_is_disposable (ValaDataType* self); ValaDataType* vala_data_type_get_actual_type (ValaDataType* self, ValaDataType* derived_instance_type, ValaList* method_type_arguments, ValaCodeNode* node_reference); ValaDataType* vala_data_type_infer_type_argument (ValaDataType* self, ValaTypeParameter* type_param, ValaDataType* value_type); gchar* vala_data_type_to_prototype_string (ValaDataType* self, const gchar* override_name); gboolean vala_data_type_is_weak (ValaDataType* self); ValaDataType* vala_data_type_construct (GType object_type); gboolean vala_data_type_get_value_owned (ValaDataType* self); void vala_data_type_set_value_owned (ValaDataType* self, gboolean value); gboolean vala_data_type_get_nullable (ValaDataType* self); void vala_data_type_set_nullable (ValaDataType* self, gboolean value); ValaTypeSymbol* vala_data_type_get_data_type (ValaDataType* self); void vala_data_type_set_data_type (ValaDataType* self, ValaTypeSymbol* value); gboolean vala_data_type_get_floating_reference (ValaDataType* self); void vala_data_type_set_floating_reference (ValaDataType* self, gboolean value); gboolean vala_data_type_get_is_dynamic (ValaDataType* self); void vala_data_type_set_is_dynamic (ValaDataType* self, gboolean value); ValaDeclarationStatement* vala_declaration_statement_new (ValaSymbol* declaration, ValaSourceReference* source_reference); ValaDeclarationStatement* vala_declaration_statement_construct (GType object_type, ValaSymbol* declaration, ValaSourceReference* source_reference); ValaSymbol* vala_declaration_statement_get_declaration (ValaDeclarationStatement* self); void vala_declaration_statement_set_declaration (ValaDeclarationStatement* self, ValaSymbol* value); ValaDelegate* vala_delegate_new (const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaDelegate* vala_delegate_construct (GType object_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); void vala_delegate_add_type_parameter (ValaDelegate* self, ValaTypeParameter* p); ValaList* vala_delegate_get_type_parameters (ValaDelegate* self); gboolean vala_delegate_matches_method (ValaDelegate* self, ValaMethod* m, ValaDataType* dt); gboolean vala_delegate_get_has_target (ValaDelegate* self); void vala_delegate_set_has_target (ValaDelegate* self, gboolean value); ValaDataType* vala_delegate_get_sender_type (ValaDelegate* self); void vala_delegate_set_sender_type (ValaDelegate* self, ValaDataType* value); GType vala_delegate_type_get_type (void) G_GNUC_CONST; ValaDelegateType* vala_delegate_type_new (ValaDelegate* delegate_symbol); ValaDelegateType* vala_delegate_type_construct (GType object_type, ValaDelegate* delegate_symbol); ValaDelegate* vala_delegate_type_get_delegate_symbol (ValaDelegateType* self); void vala_delegate_type_set_delegate_symbol (ValaDelegateType* self, ValaDelegate* value); gboolean vala_delegate_type_get_is_called_once (ValaDelegateType* self); void vala_delegate_type_set_is_called_once (ValaDelegateType* self, gboolean value); ValaDeleteStatement* vala_delete_statement_new (ValaExpression* expression, ValaSourceReference* source_reference); ValaDeleteStatement* vala_delete_statement_construct (GType object_type, ValaExpression* expression, ValaSourceReference* source_reference); ValaExpression* vala_delete_statement_get_expression (ValaDeleteStatement* self); void vala_delete_statement_set_expression (ValaDeleteStatement* self, ValaExpression* value); ValaDestructor* vala_destructor_new (ValaSourceReference* source_reference); ValaDestructor* vala_destructor_construct (GType object_type, ValaSourceReference* source_reference); ValaParameter* vala_destructor_get_this_parameter (ValaDestructor* self); void vala_destructor_set_this_parameter (ValaDestructor* self, ValaParameter* value); ValaMemberBinding vala_destructor_get_binding (ValaDestructor* self); void vala_destructor_set_binding (ValaDestructor* self, ValaMemberBinding value); ValaDoStatement* vala_do_statement_new (ValaBlock* body, ValaExpression* condition, ValaSourceReference* source_reference); ValaDoStatement* vala_do_statement_construct (GType object_type, ValaBlock* body, ValaExpression* condition, ValaSourceReference* source_reference); ValaBlock* vala_do_statement_get_body (ValaDoStatement* self); void vala_do_statement_set_body (ValaDoStatement* self, ValaBlock* value); ValaExpression* vala_do_statement_get_condition (ValaDoStatement* self); void vala_do_statement_set_condition (ValaDoStatement* self, ValaExpression* value); GType vala_dynamic_method_get_type (void) G_GNUC_CONST; ValaDynamicMethod* vala_dynamic_method_new (ValaDataType* dynamic_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaDynamicMethod* vala_dynamic_method_construct (GType object_type, ValaDataType* dynamic_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaDataType* vala_dynamic_method_get_dynamic_type (ValaDynamicMethod* self); void vala_dynamic_method_set_dynamic_type (ValaDynamicMethod* self, ValaDataType* value); ValaMethodCall* vala_dynamic_method_get_invocation (ValaDynamicMethod* self); void vala_dynamic_method_set_invocation (ValaDynamicMethod* self, ValaMethodCall* value); GType vala_dynamic_property_get_type (void) G_GNUC_CONST; ValaDynamicProperty* vala_dynamic_property_new (ValaDataType* dynamic_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaDynamicProperty* vala_dynamic_property_construct (GType object_type, ValaDataType* dynamic_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaDataType* vala_dynamic_property_get_dynamic_type (ValaDynamicProperty* self); void vala_dynamic_property_set_dynamic_type (ValaDynamicProperty* self, ValaDataType* value); GType vala_dynamic_signal_get_type (void) G_GNUC_CONST; ValaDynamicSignal* vala_dynamic_signal_new (ValaDataType* dynamic_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaDynamicSignal* vala_dynamic_signal_construct (GType object_type, ValaDataType* dynamic_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaDataType* vala_dynamic_signal_get_dynamic_type (ValaDynamicSignal* self); void vala_dynamic_signal_set_dynamic_type (ValaDynamicSignal* self, ValaDataType* value); ValaExpression* vala_dynamic_signal_get_handler (ValaDynamicSignal* self); void vala_dynamic_signal_set_handler (ValaDynamicSignal* self, ValaExpression* value); void vala_element_access_append_index (ValaElementAccess* self, ValaExpression* index); ValaList* vala_element_access_get_indices (ValaElementAccess* self); ValaElementAccess* vala_element_access_new (ValaExpression* container, ValaSourceReference* source_reference); ValaElementAccess* vala_element_access_construct (GType object_type, ValaExpression* container, ValaSourceReference* source_reference); ValaExpression* vala_element_access_get_container (ValaElementAccess* self); void vala_element_access_set_container (ValaElementAccess* self, ValaExpression* value); ValaEmptyStatement* vala_empty_statement_new (ValaSourceReference* source); ValaEmptyStatement* vala_empty_statement_construct (GType object_type, ValaSourceReference* source); ValaEnum* vala_enum_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaEnum* vala_enum_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); void vala_enum_add_value (ValaEnum* self, ValaEnumValue* value); ValaList* vala_enum_get_values (ValaEnum* self); void vala_enum_remove_all_values (ValaEnum* self); ValaList* vala_enum_get_methods (ValaEnum* self); ValaList* vala_enum_get_constants (ValaEnum* self); gboolean vala_enum_get_is_flags (ValaEnum* self); ValaEnumValue* vala_enum_value_new (const gchar* name, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment); ValaEnumValue* vala_enum_value_construct (GType object_type, const gchar* name, ValaExpression* value, ValaSourceReference* source_reference, ValaComment* comment); GType vala_enum_value_type_get_type (void) G_GNUC_CONST; ValaEnumValueType* vala_enum_value_type_new (ValaEnum* type_symbol); ValaEnumValueType* vala_enum_value_type_construct (GType object_type, ValaEnum* type_symbol); ValaMethod* vala_enum_value_type_get_to_string_method (ValaEnumValueType* self); ValaErrorCode* vala_error_code_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaErrorCode* vala_error_code_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaErrorCode* vala_error_code_new_with_value (const gchar* name, ValaExpression* value, ValaSourceReference* source_reference); ValaErrorCode* vala_error_code_construct_with_value (GType object_type, const gchar* name, ValaExpression* value, ValaSourceReference* source_reference); ValaExpression* vala_error_code_get_value (ValaErrorCode* self); void vala_error_code_set_value (ValaErrorCode* self, ValaExpression* value); ValaErrorDomain* vala_error_domain_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaErrorDomain* vala_error_domain_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); void vala_error_domain_add_code (ValaErrorDomain* self, ValaErrorCode* ecode); ValaList* vala_error_domain_get_codes (ValaErrorDomain* self); ValaList* vala_error_domain_get_methods (ValaErrorDomain* self); GType vala_error_type_get_type (void) G_GNUC_CONST; ValaErrorType* vala_error_type_new (ValaErrorDomain* error_domain, ValaErrorCode* error_code, ValaSourceReference* source_reference); ValaErrorType* vala_error_type_construct (GType object_type, ValaErrorDomain* error_domain, ValaErrorCode* error_code, ValaSourceReference* source_reference); ValaErrorDomain* vala_error_type_get_error_domain (ValaErrorType* self); void vala_error_type_set_error_domain (ValaErrorType* self, ValaErrorDomain* value); ValaErrorCode* vala_error_type_get_error_code (ValaErrorType* self); void vala_error_type_set_error_code (ValaErrorType* self, ValaErrorCode* value); gboolean vala_error_type_get_dynamic_error (ValaErrorType* self); void vala_error_type_set_dynamic_error (ValaErrorType* self, gboolean value); gboolean vala_expression_is_constant (ValaExpression* self); gboolean vala_expression_is_pure (ValaExpression* self); gboolean vala_expression_is_non_null (ValaExpression* self); gboolean vala_expression_is_accessible (ValaExpression* self, ValaSymbol* sym); void vala_expression_insert_statement (ValaExpression* self, ValaBlock* block, ValaStatement* stmt); ValaExpression* vala_expression_construct (GType object_type); ValaDataType* vala_expression_get_value_type (ValaExpression* self); void vala_expression_set_value_type (ValaExpression* self, ValaDataType* value); ValaDataType* vala_expression_get_formal_value_type (ValaExpression* self); void vala_expression_set_formal_value_type (ValaExpression* self, ValaDataType* value); ValaDataType* vala_expression_get_target_type (ValaExpression* self); void vala_expression_set_target_type (ValaExpression* self, ValaDataType* value); ValaDataType* vala_expression_get_formal_target_type (ValaExpression* self); void vala_expression_set_formal_target_type (ValaExpression* self, ValaDataType* value); ValaSymbol* vala_expression_get_symbol_reference (ValaExpression* self); void vala_expression_set_symbol_reference (ValaExpression* self, ValaSymbol* value); gboolean vala_expression_get_lvalue (ValaExpression* self); void vala_expression_set_lvalue (ValaExpression* self, gboolean value); ValaTargetValue* vala_expression_get_target_value (ValaExpression* self); void vala_expression_set_target_value (ValaExpression* self, ValaTargetValue* value); ValaStatement* vala_expression_get_parent_statement (ValaExpression* self); ValaExpressionStatement* vala_expression_statement_new (ValaExpression* expression, ValaSourceReference* source_reference); ValaExpressionStatement* vala_expression_statement_construct (GType object_type, ValaExpression* expression, ValaSourceReference* source_reference); ValaExpression* vala_expression_statement_get_expression (ValaExpressionStatement* self); void vala_expression_statement_set_expression (ValaExpressionStatement* self, ValaExpression* value); ValaField* vala_field_new (const gchar* name, ValaDataType* variable_type, ValaExpression* initializer, ValaSourceReference* source_reference, ValaComment* comment); ValaField* vala_field_construct (GType object_type, const gchar* name, ValaDataType* variable_type, ValaExpression* initializer, ValaSourceReference* source_reference, ValaComment* comment); ValaMemberBinding vala_field_get_binding (ValaField* self); void vala_field_set_binding (ValaField* self, ValaMemberBinding value); gboolean vala_field_get_is_volatile (ValaField* self); void vala_field_set_is_volatile (ValaField* self, gboolean value); GType vala_field_prototype_get_type (void) G_GNUC_CONST; ValaFieldPrototype* vala_field_prototype_new (ValaField* field_symbol); ValaFieldPrototype* vala_field_prototype_construct (GType object_type, ValaField* field_symbol); ValaField* vala_field_prototype_get_field_symbol (ValaFieldPrototype* self); void vala_field_prototype_set_field_symbol (ValaFieldPrototype* self, ValaField* value); GType vala_floating_type_get_type (void) G_GNUC_CONST; ValaFloatingType* vala_floating_type_new (ValaStruct* type_symbol); ValaFloatingType* vala_floating_type_construct (GType object_type, ValaStruct* type_symbol); ValaFlowAnalyzer* vala_flow_analyzer_new (void); ValaFlowAnalyzer* vala_flow_analyzer_construct (GType object_type); void vala_flow_analyzer_analyze (ValaFlowAnalyzer* self, ValaCodeContext* context); ValaForeachStatement* vala_foreach_statement_new (ValaDataType* type_reference, const gchar* variable_name, ValaExpression* collection, ValaBlock* body, ValaSourceReference* source_reference); ValaForeachStatement* vala_foreach_statement_construct (GType object_type, ValaDataType* type_reference, const gchar* variable_name, ValaExpression* collection, ValaBlock* body, ValaSourceReference* source_reference); ValaDataType* vala_foreach_statement_get_type_reference (ValaForeachStatement* self); void vala_foreach_statement_set_type_reference (ValaForeachStatement* self, ValaDataType* value); const gchar* vala_foreach_statement_get_variable_name (ValaForeachStatement* self); void vala_foreach_statement_set_variable_name (ValaForeachStatement* self, const gchar* value); ValaExpression* vala_foreach_statement_get_collection (ValaForeachStatement* self); void vala_foreach_statement_set_collection (ValaForeachStatement* self, ValaExpression* value); ValaBlock* vala_foreach_statement_get_body (ValaForeachStatement* self); void vala_foreach_statement_set_body (ValaForeachStatement* self, ValaBlock* value); gboolean vala_foreach_statement_get_use_iterator (ValaForeachStatement* self); ValaLocalVariable* vala_foreach_statement_get_element_variable (ValaForeachStatement* self); void vala_foreach_statement_set_element_variable (ValaForeachStatement* self, ValaLocalVariable* value); ValaLocalVariable* vala_foreach_statement_get_collection_variable (ValaForeachStatement* self); void vala_foreach_statement_set_collection_variable (ValaForeachStatement* self, ValaLocalVariable* value); ValaLocalVariable* vala_foreach_statement_get_iterator_variable (ValaForeachStatement* self); void vala_foreach_statement_set_iterator_variable (ValaForeachStatement* self, ValaLocalVariable* value); ValaForStatement* vala_for_statement_new (ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference); ValaForStatement* vala_for_statement_construct (GType object_type, ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference); void vala_for_statement_add_initializer (ValaForStatement* self, ValaExpression* init); ValaList* vala_for_statement_get_initializer (ValaForStatement* self); void vala_for_statement_add_iterator (ValaForStatement* self, ValaExpression* iter); ValaList* vala_for_statement_get_iterator (ValaForStatement* self); ValaExpression* vala_for_statement_get_condition (ValaForStatement* self); void vala_for_statement_set_condition (ValaForStatement* self, ValaExpression* value); ValaBlock* vala_for_statement_get_body (ValaForStatement* self); void vala_for_statement_set_body (ValaForStatement* self, ValaBlock* value); GType vala_gir_parser_get_type (void) G_GNUC_CONST; void vala_gir_parser_parse (ValaGirParser* self, ValaCodeContext* context); void vala_gir_parser_parse_file (ValaGirParser* self, ValaSourceFile* source_file); ValaGirParser* vala_gir_parser_new (void); ValaGirParser* vala_gir_parser_construct (GType object_type); GType vala_generic_type_get_type (void) G_GNUC_CONST; ValaGenericType* vala_generic_type_new (ValaTypeParameter* type_parameter); ValaGenericType* vala_generic_type_construct (GType object_type, ValaTypeParameter* type_parameter); ValaTypeParameter* vala_generic_type_get_type_parameter (ValaGenericType* self); void vala_generic_type_set_type_parameter (ValaGenericType* self, ValaTypeParameter* value); GType vala_genie_parser_get_type (void) G_GNUC_CONST; ValaGenieParser* vala_genie_parser_new (void); ValaGenieParser* vala_genie_parser_construct (GType object_type); void vala_genie_parser_parse (ValaGenieParser* self, ValaCodeContext* context); void vala_genie_parser_parse_file (ValaGenieParser* self, ValaSourceFile* source_file); gpointer vala_genie_scanner_ref (gpointer instance); void vala_genie_scanner_unref (gpointer instance); GParamSpec* vala_genie_param_spec_scanner (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_genie_value_set_scanner (GValue* value, gpointer v_object); void vala_genie_value_take_scanner (GValue* value, gpointer v_object); gpointer vala_genie_value_get_scanner (const GValue* value); GType vala_genie_scanner_get_type (void) G_GNUC_CONST; ValaGenieScanner* vala_genie_scanner_new (ValaSourceFile* source_file); ValaGenieScanner* vala_genie_scanner_construct (GType object_type, ValaSourceFile* source_file); GType vala_source_location_get_type (void) G_GNUC_CONST; ValaSourceLocation* vala_source_location_dup (const ValaSourceLocation* self); void vala_source_location_free (ValaSourceLocation* self); GType vala_genie_token_type_get_type (void) G_GNUC_CONST; ValaGenieTokenType vala_genie_scanner_read_regex_token (ValaGenieScanner* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end); void vala_genie_scanner_seek (ValaGenieScanner* self, ValaSourceLocation* location); ValaGenieTokenType vala_genie_scanner_get_identifier_or_keyword (gchar* begin, gint len); ValaGenieTokenType vala_genie_scanner_read_template_token (ValaGenieScanner* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end); ValaGenieTokenType vala_genie_scanner_read_token (ValaGenieScanner* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end); void vala_genie_scanner_parse_file_comments (ValaGenieScanner* self); ValaComment* vala_genie_scanner_pop_comment (ValaGenieScanner* self); ValaSourceFile* vala_genie_scanner_get_source_file (ValaGenieScanner* self); gint vala_genie_scanner_get_indent_spaces (ValaGenieScanner* self); void vala_genie_scanner_set_indent_spaces (ValaGenieScanner* self, gint value); const gchar* vala_genie_token_type_to_string (ValaGenieTokenType self); ValaIfStatement* vala_if_statement_new (ValaExpression* cond, ValaBlock* true_stmt, ValaBlock* false_stmt, ValaSourceReference* source); ValaIfStatement* vala_if_statement_construct (GType object_type, ValaExpression* cond, ValaBlock* true_stmt, ValaBlock* false_stmt, ValaSourceReference* source); ValaExpression* vala_if_statement_get_condition (ValaIfStatement* self); void vala_if_statement_set_condition (ValaIfStatement* self, ValaExpression* value); ValaBlock* vala_if_statement_get_true_statement (ValaIfStatement* self); void vala_if_statement_set_true_statement (ValaIfStatement* self, ValaBlock* value); ValaBlock* vala_if_statement_get_false_statement (ValaIfStatement* self); void vala_if_statement_set_false_statement (ValaIfStatement* self, ValaBlock* value); void vala_initializer_list_append (ValaInitializerList* self, ValaExpression* expr); ValaList* vala_initializer_list_get_initializers (ValaInitializerList* self); ValaInitializerList* vala_initializer_list_new (ValaSourceReference* source_reference); ValaInitializerList* vala_initializer_list_construct (GType object_type, ValaSourceReference* source_reference); gint vala_initializer_list_get_size (ValaInitializerList* self); ValaIntegerLiteral* vala_integer_literal_new (const gchar* i, ValaSourceReference* source); ValaIntegerLiteral* vala_integer_literal_construct (GType object_type, const gchar* i, ValaSourceReference* source); const gchar* vala_integer_literal_get_value (ValaIntegerLiteral* self); void vala_integer_literal_set_value (ValaIntegerLiteral* self, const gchar* value); const gchar* vala_integer_literal_get_type_suffix (ValaIntegerLiteral* self); void vala_integer_literal_set_type_suffix (ValaIntegerLiteral* self, const gchar* value); GType vala_integer_type_get_type (void) G_GNUC_CONST; ValaIntegerType* vala_integer_type_new (ValaStruct* type_symbol, const gchar* literal_value, const gchar* literal_type_name); ValaIntegerType* vala_integer_type_construct (GType object_type, ValaStruct* type_symbol, const gchar* literal_value, const gchar* literal_type_name); ValaList* vala_interface_get_classes (ValaInterface* self); ValaList* vala_interface_get_structs (ValaInterface* self); ValaList* vala_interface_get_enums (ValaInterface* self); ValaList* vala_interface_get_delegates (ValaInterface* self); ValaInterface* vala_interface_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaInterface* vala_interface_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); void vala_interface_add_prerequisite (ValaInterface* self, ValaDataType* type); void vala_interface_prepend_prerequisite (ValaInterface* self, ValaDataType* type); ValaList* vala_interface_get_prerequisites (ValaInterface* self); ValaList* vala_interface_get_fields (ValaInterface* self); ValaList* vala_interface_get_constants (ValaInterface* self); ValaList* vala_interface_get_virtuals (ValaInterface* self); GType vala_interface_type_get_type (void) G_GNUC_CONST; ValaInterfaceType* vala_interface_type_new (ValaInterface* interface_symbol); ValaInterfaceType* vala_interface_type_construct (GType object_type, ValaInterface* interface_symbol); ValaInterface* vala_interface_type_get_interface_symbol (ValaInterfaceType* self); void vala_interface_type_set_interface_symbol (ValaInterfaceType* self, ValaInterface* value); GType vala_invalid_type_get_type (void) G_GNUC_CONST; ValaInvalidType* vala_invalid_type_new (void); ValaInvalidType* vala_invalid_type_construct (GType object_type); ValaLambdaExpression* vala_lambda_expression_new (ValaExpression* expression_body, ValaSourceReference* source_reference); ValaLambdaExpression* vala_lambda_expression_construct (GType object_type, ValaExpression* expression_body, ValaSourceReference* source_reference); ValaLambdaExpression* vala_lambda_expression_new_with_statement_body (ValaBlock* statement_body, ValaSourceReference* source_reference); ValaLambdaExpression* vala_lambda_expression_construct_with_statement_body (GType object_type, ValaBlock* statement_body, ValaSourceReference* source_reference); void vala_lambda_expression_add_parameter (ValaLambdaExpression* self, ValaParameter* param); ValaList* vala_lambda_expression_get_parameters (ValaLambdaExpression* self); ValaExpression* vala_lambda_expression_get_expression_body (ValaLambdaExpression* self); void vala_lambda_expression_set_expression_body (ValaLambdaExpression* self, ValaExpression* value); ValaBlock* vala_lambda_expression_get_statement_body (ValaLambdaExpression* self); void vala_lambda_expression_set_statement_body (ValaLambdaExpression* self, ValaBlock* value); ValaMethod* vala_lambda_expression_get_method (ValaLambdaExpression* self); void vala_lambda_expression_set_method (ValaLambdaExpression* self, ValaMethod* value); ValaLiteral* vala_literal_construct (GType object_type); ValaLocalVariable* vala_local_variable_new (ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference); ValaLocalVariable* vala_local_variable_construct (GType object_type, ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference); gboolean vala_local_variable_get_is_result (ValaLocalVariable* self); void vala_local_variable_set_is_result (ValaLocalVariable* self, gboolean value); gboolean vala_local_variable_get_captured (ValaLocalVariable* self); void vala_local_variable_set_captured (ValaLocalVariable* self, gboolean value); gboolean vala_local_variable_get_init (ValaLocalVariable* self); void vala_local_variable_set_init (ValaLocalVariable* self, gboolean value); gboolean vala_lockable_get_lock_used (ValaLockable* self); void vala_lockable_set_lock_used (ValaLockable* self, gboolean used); ValaLockStatement* vala_lock_statement_new (ValaExpression* resource, ValaBlock* body, ValaSourceReference* source_reference); ValaLockStatement* vala_lock_statement_construct (GType object_type, ValaExpression* resource, ValaBlock* body, ValaSourceReference* source_reference); ValaExpression* vala_lock_statement_get_resource (ValaLockStatement* self); void vala_lock_statement_set_resource (ValaLockStatement* self, ValaExpression* value); ValaBlock* vala_lock_statement_get_body (ValaLockStatement* self); void vala_lock_statement_set_body (ValaLockStatement* self, ValaBlock* value); ValaLoop* vala_loop_new (ValaBlock* body, ValaSourceReference* source_reference); ValaLoop* vala_loop_construct (GType object_type, ValaBlock* body, ValaSourceReference* source_reference); ValaBlock* vala_loop_get_body (ValaLoop* self); void vala_loop_set_body (ValaLoop* self, ValaBlock* value); gpointer vala_markup_reader_ref (gpointer instance); void vala_markup_reader_unref (gpointer instance); GParamSpec* vala_param_spec_markup_reader (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_markup_reader (GValue* value, gpointer v_object); void vala_value_take_markup_reader (GValue* value, gpointer v_object); gpointer vala_value_get_markup_reader (const GValue* value); GType vala_markup_reader_get_type (void) G_GNUC_CONST; ValaMarkupReader* vala_markup_reader_new (const gchar* filename); ValaMarkupReader* vala_markup_reader_construct (GType object_type, const gchar* filename); ValaMarkupReader* vala_markup_reader_new_from_string (const gchar* filename, const gchar* content); ValaMarkupReader* vala_markup_reader_construct_from_string (GType object_type, const gchar* filename, const gchar* content); gchar* vala_markup_reader_get_attribute (ValaMarkupReader* self, const gchar* attr); ValaMap* vala_markup_reader_get_attributes (ValaMarkupReader* self); GType vala_markup_token_type_get_type (void) G_GNUC_CONST; ValaMarkupTokenType vala_markup_reader_read_token (ValaMarkupReader* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end); const gchar* vala_markup_reader_get_filename (ValaMarkupReader* self); const gchar* vala_markup_reader_get_name (ValaMarkupReader* self); const gchar* vala_markup_reader_get_content (ValaMarkupReader* self); const gchar* vala_markup_token_type_to_string (ValaMarkupTokenType self); ValaMemberAccess* vala_member_access_new (ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference); ValaMemberAccess* vala_member_access_construct (GType object_type, ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference); ValaMemberAccess* vala_member_access_new_simple (const gchar* member_name, ValaSourceReference* source_reference); ValaMemberAccess* vala_member_access_construct_simple (GType object_type, const gchar* member_name, ValaSourceReference* source_reference); ValaMemberAccess* vala_member_access_new_pointer (ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference); ValaMemberAccess* vala_member_access_construct_pointer (GType object_type, ValaExpression* inner, const gchar* member_name, ValaSourceReference* source_reference); void vala_member_access_add_type_argument (ValaMemberAccess* self, ValaDataType* arg); ValaList* vala_member_access_get_type_arguments (ValaMemberAccess* self); void vala_member_access_check_lvalue_access (ValaMemberAccess* self); ValaExpression* vala_member_access_get_inner (ValaMemberAccess* self); void vala_member_access_set_inner (ValaMemberAccess* self, ValaExpression* value); const gchar* vala_member_access_get_member_name (ValaMemberAccess* self); void vala_member_access_set_member_name (ValaMemberAccess* self, const gchar* value); gboolean vala_member_access_get_pointer_member_access (ValaMemberAccess* self); void vala_member_access_set_pointer_member_access (ValaMemberAccess* self, gboolean value); gboolean vala_member_access_get_prototype_access (ValaMemberAccess* self); void vala_member_access_set_prototype_access (ValaMemberAccess* self, gboolean value); gboolean vala_member_access_get_creation_member (ValaMemberAccess* self); void vala_member_access_set_creation_member (ValaMemberAccess* self, gboolean value); gboolean vala_member_access_get_qualified (ValaMemberAccess* self); void vala_member_access_set_qualified (ValaMemberAccess* self, gboolean value); GType vala_member_initializer_get_type (void) G_GNUC_CONST; ValaMemberInitializer* vala_member_initializer_new (const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference); ValaMemberInitializer* vala_member_initializer_construct (GType object_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference); const gchar* vala_member_initializer_get_name (ValaMemberInitializer* self); void vala_member_initializer_set_name (ValaMemberInitializer* self, const gchar* value); ValaExpression* vala_member_initializer_get_initializer (ValaMemberInitializer* self); void vala_member_initializer_set_initializer (ValaMemberInitializer* self, ValaExpression* value); ValaSymbol* vala_member_initializer_get_symbol_reference (ValaMemberInitializer* self); void vala_member_initializer_set_symbol_reference (ValaMemberInitializer* self, ValaSymbol* value); ValaMethod* vala_method_new (const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaMethod* vala_method_construct (GType object_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); void vala_method_clear_parameters (ValaMethod* self); gboolean vala_method_is_variadic (ValaMethod* self); gboolean vala_method_compatible (ValaMethod* self, ValaMethod* base_method, gchar* * invalid_match); void vala_method_add_type_parameter (ValaMethod* self, ValaTypeParameter* p); ValaList* vala_method_get_type_parameters (ValaMethod* self); gint vala_method_get_type_parameter_index (ValaMethod* self, const gchar* name); void vala_method_add_precondition (ValaMethod* self, ValaExpression* precondition); ValaList* vala_method_get_preconditions (ValaMethod* self); void vala_method_add_postcondition (ValaMethod* self, ValaExpression* postcondition); ValaList* vala_method_get_postconditions (ValaMethod* self); gint vala_method_get_required_arguments (ValaMethod* self); ValaMethod* vala_method_get_end_method (ValaMethod* self); ValaMethod* vala_method_get_callback_method (ValaMethod* self); ValaList* vala_method_get_async_begin_parameters (ValaMethod* self); ValaList* vala_method_get_async_end_parameters (ValaMethod* self); void vala_method_add_captured_variable (ValaMethod* self, ValaLocalVariable* local); void vala_method_get_captured_variables (ValaMethod* self, ValaCollection* variables); gint vala_method_get_format_arg_index (ValaMethod* self); ValaMemberBinding vala_method_get_binding (ValaMethod* self); void vala_method_set_binding (ValaMethod* self, ValaMemberBinding value); gboolean vala_method_get_is_abstract (ValaMethod* self); void vala_method_set_is_abstract (ValaMethod* self, gboolean value); gboolean vala_method_get_is_virtual (ValaMethod* self); void vala_method_set_is_virtual (ValaMethod* self, gboolean value); gboolean vala_method_get_overrides (ValaMethod* self); void vala_method_set_overrides (ValaMethod* self, gboolean value); gboolean vala_method_get_is_inline (ValaMethod* self); void vala_method_set_is_inline (ValaMethod* self, gboolean value); gboolean vala_method_get_returns_floating_reference (ValaMethod* self); void vala_method_set_returns_floating_reference (ValaMethod* self, gboolean value); gboolean vala_method_get_returns_modified_pointer (ValaMethod* self); void vala_method_set_returns_modified_pointer (ValaMethod* self, gboolean value); ValaMethod* vala_method_get_base_method (ValaMethod* self); ValaMethod* vala_method_get_base_interface_method (ValaMethod* self); ValaDataType* vala_method_get_base_interface_type (ValaMethod* self); void vala_method_set_base_interface_type (ValaMethod* self, ValaDataType* value); gboolean vala_method_get_entry_point (ValaMethod* self); ValaParameter* vala_method_get_this_parameter (ValaMethod* self); void vala_method_set_this_parameter (ValaMethod* self, ValaParameter* value); gboolean vala_method_get_printf_format (ValaMethod* self); void vala_method_set_printf_format (ValaMethod* self, gboolean value); gboolean vala_method_get_scanf_format (ValaMethod* self); void vala_method_set_scanf_format (ValaMethod* self, gboolean value); gboolean vala_method_get_has_construct_function (ValaMethod* self); void vala_method_set_has_construct_function (ValaMethod* self, gboolean value); ValaSignal* vala_method_get_signal_reference (ValaMethod* self); void vala_method_set_signal_reference (ValaMethod* self, ValaSignal* value); gboolean vala_method_get_closure (ValaMethod* self); void vala_method_set_closure (ValaMethod* self, gboolean value); gboolean vala_method_get_coroutine (ValaMethod* self); void vala_method_set_coroutine (ValaMethod* self, gboolean value); gboolean vala_method_get_is_async_callback (ValaMethod* self); void vala_method_set_is_async_callback (ValaMethod* self, gboolean value); ValaMethodCall* vala_method_call_new (ValaExpression* call, ValaSourceReference* source_reference); ValaMethodCall* vala_method_call_construct (GType object_type, ValaExpression* call, ValaSourceReference* source_reference); void vala_method_call_add_argument (ValaMethodCall* self, ValaExpression* arg); ValaList* vala_method_call_get_argument_list (ValaMethodCall* self); ValaStringLiteral* vala_method_call_get_format_literal (ValaMethodCall* self); ValaExpression* vala_method_call_get_call (ValaMethodCall* self); void vala_method_call_set_call (ValaMethodCall* self, ValaExpression* value); gboolean vala_method_call_get_is_yield_expression (ValaMethodCall* self); void vala_method_call_set_is_yield_expression (ValaMethodCall* self, gboolean value); gboolean vala_method_call_get_is_assert (ValaMethodCall* self); gboolean vala_method_call_get_is_constructv_chainup (ValaMethodCall* self); gboolean vala_method_call_get_is_chainup (ValaMethodCall* self); GType vala_method_type_get_type (void) G_GNUC_CONST; ValaMethodType* vala_method_type_new (ValaMethod* method_symbol); ValaMethodType* vala_method_type_construct (GType object_type, ValaMethod* method_symbol); ValaMethod* vala_method_type_get_method_symbol (ValaMethodType* self); void vala_method_type_set_method_symbol (ValaMethodType* self, ValaMethod* value); ValaNamedArgument* vala_named_argument_new (const gchar* name, ValaExpression* inner, ValaSourceReference* source_reference); ValaNamedArgument* vala_named_argument_construct (GType object_type, const gchar* name, ValaExpression* inner, ValaSourceReference* source_reference); const gchar* vala_named_argument_get_name (ValaNamedArgument* self); void vala_named_argument_set_name (ValaNamedArgument* self, const gchar* value); ValaExpression* vala_named_argument_get_inner (ValaNamedArgument* self); void vala_named_argument_set_inner (ValaNamedArgument* self, ValaExpression* value); ValaNamespace* vala_namespace_new (const gchar* name, ValaSourceReference* source_reference); ValaNamespace* vala_namespace_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference); void vala_namespace_add_using_directive (ValaNamespace* self, ValaUsingDirective* ns); void vala_namespace_add_comment (ValaNamespace* self, ValaComment* comment); ValaList* vala_namespace_get_comments (ValaNamespace* self); ValaList* vala_namespace_get_namespaces (ValaNamespace* self); void vala_namespace_remove_struct (ValaNamespace* self, ValaStruct* st); ValaList* vala_namespace_get_structs (ValaNamespace* self); ValaList* vala_namespace_get_classes (ValaNamespace* self); ValaList* vala_namespace_get_interfaces (ValaNamespace* self); ValaList* vala_namespace_get_enums (ValaNamespace* self); ValaList* vala_namespace_get_error_domains (ValaNamespace* self); ValaList* vala_namespace_get_fields (ValaNamespace* self); ValaList* vala_namespace_get_constants (ValaNamespace* self); ValaList* vala_namespace_get_delegates (ValaNamespace* self); ValaList* vala_namespace_get_methods (ValaNamespace* self); ValaNullLiteral* vala_null_literal_new (ValaSourceReference* source); ValaNullLiteral* vala_null_literal_construct (GType object_type, ValaSourceReference* source); GType vala_null_type_get_type (void) G_GNUC_CONST; ValaNullType* vala_null_type_new (ValaSourceReference* source_reference); ValaNullType* vala_null_type_construct (GType object_type, ValaSourceReference* source_reference); ValaObjectCreationExpression* vala_object_creation_expression_new (ValaMemberAccess* member_name, ValaSourceReference* source_reference); ValaObjectCreationExpression* vala_object_creation_expression_construct (GType object_type, ValaMemberAccess* member_name, ValaSourceReference* source_reference); void vala_object_creation_expression_add_argument (ValaObjectCreationExpression* self, ValaExpression* arg); ValaList* vala_object_creation_expression_get_argument_list (ValaObjectCreationExpression* self); void vala_object_creation_expression_add_member_initializer (ValaObjectCreationExpression* self, ValaMemberInitializer* init); ValaList* vala_object_creation_expression_get_object_initializer (ValaObjectCreationExpression* self); ValaDataType* vala_object_creation_expression_get_type_reference (ValaObjectCreationExpression* self); void vala_object_creation_expression_set_type_reference (ValaObjectCreationExpression* self, ValaDataType* value); ValaMemberAccess* vala_object_creation_expression_get_member_name (ValaObjectCreationExpression* self); void vala_object_creation_expression_set_member_name (ValaObjectCreationExpression* self, ValaMemberAccess* value); gboolean vala_object_creation_expression_get_is_yield_expression (ValaObjectCreationExpression* self); void vala_object_creation_expression_set_is_yield_expression (ValaObjectCreationExpression* self, gboolean value); gboolean vala_object_creation_expression_get_struct_creation (ValaObjectCreationExpression* self); void vala_object_creation_expression_set_struct_creation (ValaObjectCreationExpression* self, gboolean value); GType vala_object_type_get_type (void) G_GNUC_CONST; ValaObjectType* vala_object_type_new (ValaObjectTypeSymbol* type_symbol); ValaObjectType* vala_object_type_construct (GType object_type, ValaObjectTypeSymbol* type_symbol); ValaObjectTypeSymbol* vala_object_type_get_type_symbol (ValaObjectType* self); void vala_object_type_set_type_symbol (ValaObjectType* self, ValaObjectTypeSymbol* value); ValaObjectTypeSymbol* vala_object_type_symbol_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaList* vala_object_type_symbol_get_methods (ValaObjectTypeSymbol* self); ValaList* vala_object_type_symbol_get_signals (ValaObjectTypeSymbol* self); ValaList* vala_object_type_symbol_get_properties (ValaObjectTypeSymbol* self); void vala_object_type_symbol_add_type_parameter (ValaObjectTypeSymbol* self, ValaTypeParameter* p); ValaList* vala_object_type_symbol_get_type_parameters (ValaObjectTypeSymbol* self); ValaObjectType* vala_object_type_symbol_get_this_type (ValaObjectTypeSymbol* self); void vala_object_type_symbol_add_hidden_method (ValaObjectTypeSymbol* self, ValaMethod* m); ValaParameter* vala_parameter_new (const gchar* name, ValaDataType* variable_type, ValaSourceReference* source_reference); ValaParameter* vala_parameter_construct (GType object_type, const gchar* name, ValaDataType* variable_type, ValaSourceReference* source_reference); ValaParameter* vala_parameter_new_with_ellipsis (ValaSourceReference* source_reference); ValaParameter* vala_parameter_construct_with_ellipsis (GType object_type, ValaSourceReference* source_reference); ValaParameter* vala_parameter_copy (ValaParameter* self); GType vala_parameter_direction_get_type (void) G_GNUC_CONST; ValaParameterDirection vala_parameter_get_direction (ValaParameter* self); void vala_parameter_set_direction (ValaParameter* self, ValaParameterDirection value); gboolean vala_parameter_get_ellipsis (ValaParameter* self); void vala_parameter_set_ellipsis (ValaParameter* self, gboolean value); gboolean vala_parameter_get_params_array (ValaParameter* self); void vala_parameter_set_params_array (ValaParameter* self, gboolean value); gboolean vala_parameter_get_captured (ValaParameter* self); void vala_parameter_set_captured (ValaParameter* self, gboolean value); gboolean vala_parameter_get_format_arg (ValaParameter* self); ValaParameter* vala_parameter_get_base_parameter (ValaParameter* self); void vala_parameter_set_base_parameter (ValaParameter* self, ValaParameter* value); GType vala_parser_get_type (void) G_GNUC_CONST; ValaParser* vala_parser_new (void); ValaParser* vala_parser_construct (GType object_type); void vala_parser_parse (ValaParser* self, ValaCodeContext* context); void vala_parser_parse_file (ValaParser* self, ValaSourceFile* source_file); GQuark vala_parse_error_quark (void); ValaPhiFunction* vala_phi_function_new (ValaVariable* variable, gint num_of_ops); ValaPhiFunction* vala_phi_function_construct (GType object_type, ValaVariable* variable, gint num_of_ops); ValaVariable* vala_phi_function_get_original_variable (ValaPhiFunction* self); ValaList* vala_phi_function_get_operands (ValaPhiFunction* self); ValaPointerIndirection* vala_pointer_indirection_new (ValaExpression* inner, ValaSourceReference* source_reference); ValaPointerIndirection* vala_pointer_indirection_construct (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference); ValaExpression* vala_pointer_indirection_get_inner (ValaPointerIndirection* self); void vala_pointer_indirection_set_inner (ValaPointerIndirection* self, ValaExpression* value); GType vala_pointer_type_get_type (void) G_GNUC_CONST; ValaPointerType* vala_pointer_type_new (ValaDataType* base_type, ValaSourceReference* source_reference); ValaPointerType* vala_pointer_type_construct (GType object_type, ValaDataType* base_type, ValaSourceReference* source_reference); ValaDataType* vala_pointer_type_get_base_type (ValaPointerType* self); void vala_pointer_type_set_base_type (ValaPointerType* self, ValaDataType* value); ValaPostfixExpression* vala_postfix_expression_new (ValaExpression* _inner, gboolean inc, ValaSourceReference* source); ValaPostfixExpression* vala_postfix_expression_construct (GType object_type, ValaExpression* _inner, gboolean inc, ValaSourceReference* source); ValaExpression* vala_postfix_expression_get_inner (ValaPostfixExpression* self); void vala_postfix_expression_set_inner (ValaPostfixExpression* self, ValaExpression* value); gboolean vala_postfix_expression_get_increment (ValaPostfixExpression* self); void vala_postfix_expression_set_increment (ValaPostfixExpression* self, gboolean value); ValaPropertyAccessor* vala_property_accessor_new (gboolean readable, gboolean writable, gboolean construction, ValaDataType* value_type, ValaBlock* body, ValaSourceReference* source_reference, ValaComment* comment); ValaPropertyAccessor* vala_property_accessor_construct (GType object_type, gboolean readable, gboolean writable, gboolean construction, ValaDataType* value_type, ValaBlock* body, ValaSourceReference* source_reference, ValaComment* comment); ValaMethod* vala_property_accessor_get_method (ValaPropertyAccessor* self); ValaProperty* vala_property_accessor_get_prop (ValaPropertyAccessor* self); ValaDataType* vala_property_accessor_get_value_type (ValaPropertyAccessor* self); gboolean vala_property_accessor_get_readable (ValaPropertyAccessor* self); gboolean vala_property_accessor_get_writable (ValaPropertyAccessor* self); gboolean vala_property_accessor_get_construction (ValaPropertyAccessor* self); gboolean vala_property_accessor_get_automatic_body (ValaPropertyAccessor* self); ValaParameter* vala_property_accessor_get_value_parameter (ValaPropertyAccessor* self); ValaProperty* vala_property_new (const gchar* name, ValaDataType* property_type, ValaPropertyAccessor* get_accessor, ValaPropertyAccessor* set_accessor, ValaSourceReference* source_reference, ValaComment* comment); ValaProperty* vala_property_construct (GType object_type, const gchar* name, ValaDataType* property_type, ValaPropertyAccessor* get_accessor, ValaPropertyAccessor* set_accessor, ValaSourceReference* source_reference, ValaComment* comment); gboolean vala_property_compatible (ValaProperty* self, ValaProperty* base_property, gchar* * invalid_match); ValaDataType* vala_property_get_property_type (ValaProperty* self); void vala_property_set_property_type (ValaProperty* self, ValaDataType* value); ValaPropertyAccessor* vala_property_get_get_accessor (ValaProperty* self); void vala_property_set_get_accessor (ValaProperty* self, ValaPropertyAccessor* value); ValaPropertyAccessor* vala_property_get_set_accessor (ValaProperty* self); void vala_property_set_set_accessor (ValaProperty* self, ValaPropertyAccessor* value); ValaParameter* vala_property_get_this_parameter (ValaProperty* self); void vala_property_set_this_parameter (ValaProperty* self, ValaParameter* value); gboolean vala_property_get_interface_only (ValaProperty* self); void vala_property_set_interface_only (ValaProperty* self, gboolean value); gboolean vala_property_get_is_abstract (ValaProperty* self); void vala_property_set_is_abstract (ValaProperty* self, gboolean value); gboolean vala_property_get_is_virtual (ValaProperty* self); void vala_property_set_is_virtual (ValaProperty* self, gboolean value); gboolean vala_property_get_overrides (ValaProperty* self); void vala_property_set_overrides (ValaProperty* self, gboolean value); ValaField* vala_property_get_field (ValaProperty* self); void vala_property_set_field (ValaProperty* self, ValaField* value); ValaMemberBinding vala_property_get_binding (ValaProperty* self); void vala_property_set_binding (ValaProperty* self, ValaMemberBinding value); const gchar* vala_property_get_nick (ValaProperty* self); const gchar* vala_property_get_blurb (ValaProperty* self); gboolean vala_property_get_notify (ValaProperty* self); ValaProperty* vala_property_get_base_property (ValaProperty* self); ValaProperty* vala_property_get_base_interface_property (ValaProperty* self); ValaExpression* vala_property_get_initializer (ValaProperty* self); void vala_property_set_initializer (ValaProperty* self, ValaExpression* value); ValaRealLiteral* vala_real_literal_new (const gchar* r, ValaSourceReference* source); ValaRealLiteral* vala_real_literal_construct (GType object_type, const gchar* r, ValaSourceReference* source); gchar* vala_real_literal_get_type_name (ValaRealLiteral* self); const gchar* vala_real_literal_get_value (ValaRealLiteral* self); void vala_real_literal_set_value (ValaRealLiteral* self, const gchar* value); ValaReferenceTransferExpression* vala_reference_transfer_expression_new (ValaExpression* inner, ValaSourceReference* source_reference); ValaReferenceTransferExpression* vala_reference_transfer_expression_construct (GType object_type, ValaExpression* inner, ValaSourceReference* source_reference); ValaExpression* vala_reference_transfer_expression_get_inner (ValaReferenceTransferExpression* self); void vala_reference_transfer_expression_set_inner (ValaReferenceTransferExpression* self, ValaExpression* value); ValaReferenceType* vala_reference_type_construct (GType object_type); ValaRegexLiteral* vala_regex_literal_new (const gchar* value, ValaSourceReference* source_reference); ValaRegexLiteral* vala_regex_literal_construct (GType object_type, const gchar* value, ValaSourceReference* source_reference); const gchar* vala_regex_literal_get_value (ValaRegexLiteral* self); void vala_regex_literal_set_value (ValaRegexLiteral* self, const gchar* value); GType vala_report_colored_get_type (void) G_GNUC_CONST; gboolean vala_report_set_colors (ValaReport* self, const gchar* str, ValaReportColored colored_output); void vala_report_set_verbose_errors (ValaReport* self, gboolean verbose); gint vala_report_get_warnings (ValaReport* self); gint vala_report_get_errors (ValaReport* self); void vala_report_note (ValaReport* self, ValaSourceReference* source, const gchar* message); void vala_report_depr (ValaReport* self, ValaSourceReference* source, const gchar* message); void vala_report_warn (ValaReport* self, ValaSourceReference* source, const gchar* message); void vala_report_err (ValaReport* self, ValaSourceReference* source, const gchar* message); void vala_report_notice (ValaSourceReference* source, const gchar* message); void vala_report_deprecated (ValaSourceReference* source, const gchar* message); void vala_report_experimental (ValaSourceReference* source, const gchar* message); void vala_report_warning (ValaSourceReference* source, const gchar* message); void vala_report_error (ValaSourceReference* source, const gchar* message); ValaReport* vala_report_new (void); ValaReport* vala_report_construct (GType object_type); gboolean vala_report_get_enable_warnings (ValaReport* self); void vala_report_set_enable_warnings (ValaReport* self, gboolean value); ValaReturnStatement* vala_return_statement_new (ValaExpression* return_expression, ValaSourceReference* source_reference); ValaReturnStatement* vala_return_statement_construct (GType object_type, ValaExpression* return_expression, ValaSourceReference* source_reference); ValaExpression* vala_return_statement_get_return_expression (ValaReturnStatement* self); void vala_return_statement_set_return_expression (ValaReturnStatement* self, ValaExpression* value); gpointer vala_scanner_ref (gpointer instance); void vala_scanner_unref (gpointer instance); GParamSpec* vala_param_spec_scanner (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_scanner (GValue* value, gpointer v_object); void vala_value_take_scanner (GValue* value, gpointer v_object); gpointer vala_value_get_scanner (const GValue* value); GType vala_scanner_get_type (void) G_GNUC_CONST; ValaScanner* vala_scanner_new (ValaSourceFile* source_file); ValaScanner* vala_scanner_construct (GType object_type, ValaSourceFile* source_file); void vala_scanner_seek (ValaScanner* self, ValaSourceLocation* location); GType vala_token_type_get_type (void) G_GNUC_CONST; ValaTokenType vala_scanner_read_regex_token (ValaScanner* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end); ValaTokenType vala_scanner_get_identifier_or_keyword (gchar* begin, gint len); ValaTokenType vala_scanner_read_template_token (ValaScanner* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end); ValaTokenType vala_scanner_read_token (ValaScanner* self, ValaSourceLocation* token_begin, ValaSourceLocation* token_end); void vala_scanner_parse_file_comments (ValaScanner* self); ValaComment* vala_scanner_pop_comment (ValaScanner* self); ValaSourceFile* vala_scanner_get_source_file (ValaScanner* self); ValaScope* vala_scope_new (ValaSymbol* owner); ValaScope* vala_scope_construct (GType object_type, ValaSymbol* owner); void vala_scope_add (ValaScope* self, const gchar* name, ValaSymbol* sym); void vala_scope_remove (ValaScope* self, const gchar* name); ValaSymbol* vala_scope_lookup (ValaScope* self, const gchar* name); gboolean vala_scope_is_subscope_of (ValaScope* self, ValaScope* scope); ValaMap* vala_scope_get_symbol_table (ValaScope* self); ValaSymbol* vala_scope_get_owner (ValaScope* self); void vala_scope_set_owner (ValaScope* self, ValaSymbol* value); ValaScope* vala_scope_get_parent_scope (ValaScope* self); void vala_scope_set_parent_scope (ValaScope* self, ValaScope* value); GType vala_struct_value_type_get_type (void) G_GNUC_CONST; ValaSemanticAnalyzer* vala_semantic_analyzer_new (void); ValaSemanticAnalyzer* vala_semantic_analyzer_construct (GType object_type); void vala_semantic_analyzer_analyze (ValaSemanticAnalyzer* self, ValaCodeContext* context); void vala_semantic_analyzer_add_replaced_node (ValaSemanticAnalyzer* self, ValaCodeNode* node); gboolean vala_semantic_analyzer_is_type_accessible (ValaSemanticAnalyzer* self, ValaSymbol* sym, ValaDataType* type); ValaDataType* vala_semantic_analyzer_get_value_type_for_symbol (ValaSemanticAnalyzer* self, ValaSymbol* sym, gboolean lvalue); ValaSymbol* vala_semantic_analyzer_symbol_lookup_inherited (ValaSymbol* sym, const gchar* name); ValaDataType* vala_semantic_analyzer_get_data_type_for_symbol (ValaSymbol* sym); ValaSymbol* vala_semantic_analyzer_get_symbol_for_data_type (ValaDataType* type); gboolean vala_semantic_analyzer_check_arguments (ValaSemanticAnalyzer* self, ValaExpression* expr, ValaDataType* mtype, ValaList* params, ValaList* args); gboolean vala_semantic_analyzer_check_variadic_arguments (ValaSemanticAnalyzer* self, ValaIterator* arg_it, gint i, ValaSourceReference* source_reference); gboolean vala_semantic_analyzer_check_print_format (ValaSemanticAnalyzer* self, const gchar* format, ValaIterator* arg_it, ValaSourceReference* source_reference); ValaDataType* vala_semantic_analyzer_get_actual_type (ValaDataType* derived_instance_type, ValaList* method_type_arguments, ValaGenericType* generic_type, ValaCodeNode* node_reference); gboolean vala_semantic_analyzer_is_in_instance_method (ValaSemanticAnalyzer* self); ValaExpression* vala_semantic_analyzer_create_temp_access (ValaLocalVariable* local, ValaDataType* target_type); void vala_semantic_analyzer_visit_member_initializer (ValaSemanticAnalyzer* self, ValaMemberInitializer* init, ValaDataType* type); ValaDataType* vala_semantic_analyzer_get_arithmetic_result_type (ValaSemanticAnalyzer* self, ValaDataType* left_type, ValaDataType* right_type); ValaMethod* vala_semantic_analyzer_find_current_method (ValaSemanticAnalyzer* self); ValaMethod* vala_semantic_analyzer_find_parent_method (ValaSemanticAnalyzer* self, ValaSymbol* sym); ValaSymbol* vala_semantic_analyzer_find_parent_method_or_property_accessor (ValaSemanticAnalyzer* self, ValaSymbol* sym); gboolean vala_semantic_analyzer_is_in_constructor (ValaSemanticAnalyzer* self); gboolean vala_semantic_analyzer_is_in_destructor (ValaSemanticAnalyzer* self); ValaSymbol* vala_semantic_analyzer_get_current_symbol (ValaSemanticAnalyzer* self); void vala_semantic_analyzer_set_current_symbol (ValaSemanticAnalyzer* self, ValaSymbol* value); ValaSourceFile* vala_semantic_analyzer_get_current_source_file (ValaSemanticAnalyzer* self); void vala_semantic_analyzer_set_current_source_file (ValaSemanticAnalyzer* self, ValaSourceFile* value); ValaTypeSymbol* vala_semantic_analyzer_get_current_type_symbol (ValaSemanticAnalyzer* self); ValaClass* vala_semantic_analyzer_get_current_class (ValaSemanticAnalyzer* self); ValaStruct* vala_semantic_analyzer_get_current_struct (ValaSemanticAnalyzer* self); ValaMethod* vala_semantic_analyzer_get_current_method (ValaSemanticAnalyzer* self); ValaMethod* vala_semantic_analyzer_get_current_async_method (ValaSemanticAnalyzer* self); ValaPropertyAccessor* vala_semantic_analyzer_get_current_property_accessor (ValaSemanticAnalyzer* self); ValaSymbol* vala_semantic_analyzer_get_current_method_or_property_accessor (ValaSemanticAnalyzer* self); ValaDataType* vala_semantic_analyzer_get_current_return_type (ValaSemanticAnalyzer* self); ValaSignal* vala_signal_new (const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaSignal* vala_signal_construct (GType object_type, const gchar* name, ValaDataType* return_type, ValaSourceReference* source_reference, ValaComment* comment); ValaDelegate* vala_signal_get_delegate (ValaSignal* self, ValaDataType* sender_type, ValaCodeNode* node_reference); ValaBlock* vala_signal_get_body (ValaSignal* self); void vala_signal_set_body (ValaSignal* self, ValaBlock* value); gboolean vala_signal_get_is_virtual (ValaSignal* self); void vala_signal_set_is_virtual (ValaSignal* self, gboolean value); ValaMethod* vala_signal_get_default_handler (ValaSignal* self); ValaMethod* vala_signal_get_emitter (ValaSignal* self); GType vala_signal_type_get_type (void) G_GNUC_CONST; ValaSignalType* vala_signal_type_new (ValaSignal* signal_symbol); ValaSignalType* vala_signal_type_construct (GType object_type, ValaSignal* signal_symbol); ValaDelegateType* vala_signal_type_get_handler_type (ValaSignalType* self); ValaSignal* vala_signal_type_get_signal_symbol (ValaSignalType* self); void vala_signal_type_set_signal_symbol (ValaSignalType* self, ValaSignal* value); ValaSizeofExpression* vala_sizeof_expression_new (ValaDataType* type, ValaSourceReference* source); ValaSizeofExpression* vala_sizeof_expression_construct (GType object_type, ValaDataType* type, ValaSourceReference* source); ValaDataType* vala_sizeof_expression_get_type_reference (ValaSizeofExpression* self); void vala_sizeof_expression_set_type_reference (ValaSizeofExpression* self, ValaDataType* value); ValaSliceExpression* vala_slice_expression_new (ValaExpression* container, ValaExpression* start, ValaExpression* stop, ValaSourceReference* source_reference); ValaSliceExpression* vala_slice_expression_construct (GType object_type, ValaExpression* container, ValaExpression* start, ValaExpression* stop, ValaSourceReference* source_reference); ValaExpression* vala_slice_expression_get_container (ValaSliceExpression* self); void vala_slice_expression_set_container (ValaSliceExpression* self, ValaExpression* value); ValaExpression* vala_slice_expression_get_start (ValaSliceExpression* self); ValaExpression* vala_slice_expression_get_stop (ValaSliceExpression* self); GType vala_source_file_type_get_type (void) G_GNUC_CONST; ValaSourceFile* vala_source_file_new (ValaCodeContext* context, ValaSourceFileType type, const gchar* filename, const gchar* content, gboolean cmdline); ValaSourceFile* vala_source_file_construct (GType object_type, ValaCodeContext* context, ValaSourceFileType type, const gchar* filename, const gchar* content, gboolean cmdline); void vala_source_file_add_comment (ValaSourceFile* self, ValaComment* comment); ValaList* vala_source_file_get_comments (ValaSourceFile* self); void vala_source_file_add_using_directive (ValaSourceFile* self, ValaUsingDirective* ns); void vala_source_file_add_node (ValaSourceFile* self, ValaCodeNode* node); void vala_source_file_remove_node (ValaSourceFile* self, ValaCodeNode* node); ValaList* vala_source_file_get_nodes (ValaSourceFile* self); void vala_source_file_accept (ValaSourceFile* self, ValaCodeVisitor* visitor); void vala_source_file_accept_children (ValaSourceFile* self, ValaCodeVisitor* visitor); gchar* vala_source_file_get_relative_filename (ValaSourceFile* self); gchar* vala_source_file_get_csource_filename (ValaSourceFile* self); gchar* vala_source_file_get_cinclude_filename (ValaSourceFile* self); gchar* vala_source_file_get_source_line (ValaSourceFile* self, gint lineno); gchar* vala_source_file_get_mapped_contents (ValaSourceFile* self); gsize vala_source_file_get_mapped_length (ValaSourceFile* self); gboolean vala_source_file_check (ValaSourceFile* self, ValaCodeContext* context); const gchar* vala_source_file_get_filename (ValaSourceFile* self); void vala_source_file_set_filename (ValaSourceFile* self, const gchar* value); void vala_source_file_set_relative_filename (ValaSourceFile* self, const gchar* value); const gchar* vala_source_file_get_package_name (ValaSourceFile* self); void vala_source_file_set_package_name (ValaSourceFile* self, const gchar* value); const gchar* vala_source_file_get_installed_version (ValaSourceFile* self); void vala_source_file_set_installed_version (ValaSourceFile* self, const gchar* value); ValaSourceFileType vala_source_file_get_file_type (ValaSourceFile* self); void vala_source_file_set_file_type (ValaSourceFile* self, ValaSourceFileType value); gboolean vala_source_file_get_from_commandline (ValaSourceFile* self); void vala_source_file_set_from_commandline (ValaSourceFile* self, gboolean value); const gchar* vala_source_file_get_gir_namespace (ValaSourceFile* self); void vala_source_file_set_gir_namespace (ValaSourceFile* self, const gchar* value); const gchar* vala_source_file_get_gir_version (ValaSourceFile* self); void vala_source_file_set_gir_version (ValaSourceFile* self, const gchar* value); ValaCodeContext* vala_source_file_get_context (ValaSourceFile* self); void vala_source_file_set_context (ValaSourceFile* self, ValaCodeContext* value); const gchar* vala_source_file_get_content (ValaSourceFile* self); void vala_source_file_set_content (ValaSourceFile* self, const gchar* value); gboolean vala_source_file_get_used (ValaSourceFile* self); void vala_source_file_set_used (ValaSourceFile* self, gboolean value); gboolean vala_source_file_get_explicit (ValaSourceFile* self); void vala_source_file_set_explicit (ValaSourceFile* self, gboolean value); ValaList* vala_source_file_get_current_using_directives (ValaSourceFile* self); void vala_source_file_set_current_using_directives (ValaSourceFile* self, ValaList* value); void vala_source_location_init (ValaSourceLocation *self, gchar* _pos, gint _line, gint _column); ValaSourceReference* vala_source_reference_new (ValaSourceFile* _file, ValaSourceLocation* begin, ValaSourceLocation* end); ValaSourceReference* vala_source_reference_construct (GType object_type, ValaSourceFile* _file, ValaSourceLocation* begin, ValaSourceLocation* end); gchar* vala_source_reference_to_string (ValaSourceReference* self); ValaSourceFile* vala_source_reference_get_file (ValaSourceReference* self); void vala_source_reference_set_file (ValaSourceReference* self, ValaSourceFile* value); void vala_source_reference_get_begin (ValaSourceReference* self, ValaSourceLocation * result); void vala_source_reference_set_begin (ValaSourceReference* self, ValaSourceLocation * value); void vala_source_reference_get_end (ValaSourceReference* self, ValaSourceLocation * result); void vala_source_reference_set_end (ValaSourceReference* self, ValaSourceLocation * value); ValaList* vala_source_reference_get_using_directives (ValaSourceReference* self); GType vala_statement_list_get_type (void) G_GNUC_CONST; ValaStatementList* vala_statement_list_new (ValaSourceReference* source_reference); ValaStatementList* vala_statement_list_construct (GType object_type, ValaSourceReference* source_reference); ValaStatement* vala_statement_list_get (ValaStatementList* self, gint index); void vala_statement_list_set (ValaStatementList* self, gint index, ValaStatement* stmt); void vala_statement_list_add (ValaStatementList* self, ValaStatement* stmt); void vala_statement_list_insert (ValaStatementList* self, gint index, ValaStatement* stmt); gint vala_statement_list_get_length (ValaStatementList* self); ValaStringLiteral* vala_string_literal_new (const gchar* value, ValaSourceReference* source_reference); ValaStringLiteral* vala_string_literal_construct (GType object_type, const gchar* value, ValaSourceReference* source_reference); gchar* vala_string_literal_eval (ValaStringLiteral* self); ValaStringLiteral* vala_string_literal_get_format_literal (ValaExpression* expr); const gchar* vala_string_literal_get_value (ValaStringLiteral* self); void vala_string_literal_set_value (ValaStringLiteral* self, const gchar* value); gboolean vala_string_literal_get_translate (ValaStringLiteral* self); void vala_string_literal_set_translate (ValaStringLiteral* self, gboolean value); ValaStruct* vala_struct_new (const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaStruct* vala_struct_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); void vala_struct_add_type_parameter (ValaStruct* self, ValaTypeParameter* p); ValaList* vala_struct_get_type_parameters (ValaStruct* self); ValaList* vala_struct_get_fields (ValaStruct* self); ValaList* vala_struct_get_constants (ValaStruct* self); ValaList* vala_struct_get_methods (ValaStruct* self); ValaList* vala_struct_get_properties (ValaStruct* self); gboolean vala_struct_is_boolean_type (ValaStruct* self); gboolean vala_struct_is_integer_type (ValaStruct* self); gboolean vala_struct_is_floating_type (ValaStruct* self); gboolean vala_struct_is_decimal_floating_type (ValaStruct* self); gint vala_struct_get_rank (ValaStruct* self); void vala_struct_set_rank (ValaStruct* self, gint rank); gboolean vala_struct_is_simple_type (ValaStruct* self); void vala_struct_set_simple_type (ValaStruct* self, gboolean simple_type); gboolean vala_struct_is_disposable (ValaStruct* self); ValaDataType* vala_struct_get_base_type (ValaStruct* self); void vala_struct_set_base_type (ValaStruct* self, ValaDataType* value); ValaStruct* vala_struct_get_base_struct (ValaStruct* self); ValaMethod* vala_struct_get_default_construction_method (ValaStruct* self); void vala_struct_set_default_construction_method (ValaStruct* self, ValaMethod* value); gboolean vala_struct_get_is_immutable (ValaStruct* self); void vala_struct_set_is_immutable (ValaStruct* self, gboolean value); gint vala_struct_get_width (ValaStruct* self); void vala_struct_set_width (ValaStruct* self, gint value); gboolean vala_struct_get_signed (ValaStruct* self); void vala_struct_set_signed (ValaStruct* self, gboolean value); ValaStructValueType* vala_struct_value_type_new (ValaStruct* type_symbol); ValaStructValueType* vala_struct_value_type_construct (GType object_type, ValaStruct* type_symbol); ValaSubroutine* vala_subroutine_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); ValaBasicBlock* vala_subroutine_get_entry_block (ValaSubroutine* self); void vala_subroutine_set_entry_block (ValaSubroutine* self, ValaBasicBlock* value); ValaBasicBlock* vala_subroutine_get_return_block (ValaSubroutine* self); void vala_subroutine_set_return_block (ValaSubroutine* self, ValaBasicBlock* value); ValaBasicBlock* vala_subroutine_get_exit_block (ValaSubroutine* self); void vala_subroutine_set_exit_block (ValaSubroutine* self, ValaBasicBlock* value); ValaLocalVariable* vala_subroutine_get_result_var (ValaSubroutine* self); void vala_subroutine_set_result_var (ValaSubroutine* self, ValaLocalVariable* value); gboolean vala_subroutine_get_has_result (ValaSubroutine* self); ValaBlock* vala_subroutine_get_body (ValaSubroutine* self); void vala_subroutine_set_body (ValaSubroutine* self, ValaBlock* value); ValaSwitchLabel* vala_switch_label_new (ValaExpression* expr, ValaSourceReference* source); ValaSwitchLabel* vala_switch_label_construct (GType object_type, ValaExpression* expr, ValaSourceReference* source); ValaSwitchLabel* vala_switch_label_new_with_default (ValaSourceReference* source); ValaSwitchLabel* vala_switch_label_construct_with_default (GType object_type, ValaSourceReference* source); ValaExpression* vala_switch_label_get_expression (ValaSwitchLabel* self); void vala_switch_label_set_expression (ValaSwitchLabel* self, ValaExpression* value); ValaSwitchSection* vala_switch_label_get_section (ValaSwitchLabel* self); void vala_switch_label_set_section (ValaSwitchLabel* self, ValaSwitchSection* value); ValaSwitchSection* vala_switch_section_new (ValaSourceReference* source_reference); ValaSwitchSection* vala_switch_section_construct (GType object_type, ValaSourceReference* source_reference); void vala_switch_section_add_label (ValaSwitchSection* self, ValaSwitchLabel* label); ValaList* vala_switch_section_get_labels (ValaSwitchSection* self); gboolean vala_switch_section_has_default_label (ValaSwitchSection* self); ValaSwitchStatement* vala_switch_statement_new (ValaExpression* expression, ValaSourceReference* source_reference); ValaSwitchStatement* vala_switch_statement_construct (GType object_type, ValaExpression* expression, ValaSourceReference* source_reference); void vala_switch_statement_add_section (ValaSwitchStatement* self, ValaSwitchSection* section); ValaList* vala_switch_statement_get_sections (ValaSwitchStatement* self); ValaExpression* vala_switch_statement_get_expression (ValaSwitchStatement* self); void vala_switch_statement_set_expression (ValaSwitchStatement* self, ValaExpression* value); gboolean vala_symbol_is_internal_symbol (ValaSymbol* self); gboolean vala_symbol_is_private_symbol (ValaSymbol* self); ValaSymbol* vala_symbol_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); gchar* vala_symbol_get_full_name (ValaSymbol* self); gchar* vala_symbol_camel_case_to_lower_case (const gchar* camel_case); gchar* vala_symbol_lower_case_to_camel_case (const gchar* lower_case); ValaScope* vala_symbol_get_top_accessible_scope (ValaSymbol* self, gboolean is_internal); gboolean vala_symbol_is_instance_member (ValaSymbol* self); gboolean vala_symbol_is_class_member (ValaSymbol* self); ValaSymbol* vala_symbol_get_hidden_member (ValaSymbol* self); gboolean vala_symbol_is_accessible (ValaSymbol* self, ValaSymbol* sym); void vala_symbol_add_namespace (ValaSymbol* self, ValaNamespace* ns); void vala_symbol_add_class (ValaSymbol* self, ValaClass* cl); void vala_symbol_add_interface (ValaSymbol* self, ValaInterface* iface); void vala_symbol_add_struct (ValaSymbol* self, ValaStruct* st); void vala_symbol_add_enum (ValaSymbol* self, ValaEnum* en); void vala_symbol_add_error_domain (ValaSymbol* self, ValaErrorDomain* edomain); void vala_symbol_add_delegate (ValaSymbol* self, ValaDelegate* d); void vala_symbol_add_constant (ValaSymbol* self, ValaConstant* constant); void vala_symbol_add_field (ValaSymbol* self, ValaField* f); void vala_symbol_add_method (ValaSymbol* self, ValaMethod* m); void vala_symbol_add_property (ValaSymbol* self, ValaProperty* prop); void vala_symbol_add_signal (ValaSymbol* self, ValaSignal* sig); void vala_symbol_add_constructor (ValaSymbol* self, ValaConstructor* c); void vala_symbol_add_destructor (ValaSymbol* self, ValaDestructor* d); ValaSymbol* vala_symbol_get_parent_symbol (ValaSymbol* self); ValaScope* vala_symbol_get_owner (ValaSymbol* self); void vala_symbol_set_owner (ValaSymbol* self, ValaScope* value); const gchar* vala_symbol_get_name (ValaSymbol* self); void vala_symbol_set_name (ValaSymbol* self, const gchar* value); gboolean vala_symbol_get_active (ValaSymbol* self); void vala_symbol_set_active (ValaSymbol* self, gboolean value); gboolean vala_symbol_get_used (ValaSymbol* self); void vala_symbol_set_used (ValaSymbol* self, gboolean value); GType vala_symbol_accessibility_get_type (void) G_GNUC_CONST; ValaSymbolAccessibility vala_symbol_get_access (ValaSymbol* self); void vala_symbol_set_access (ValaSymbol* self, ValaSymbolAccessibility value); ValaComment* vala_symbol_get_comment (ValaSymbol* self); void vala_symbol_set_comment (ValaSymbol* self, ValaComment* value); gpointer vala_version_attribute_ref (gpointer instance); void vala_version_attribute_unref (gpointer instance); GParamSpec* vala_param_spec_version_attribute (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_version_attribute (GValue* value, gpointer v_object); void vala_value_take_version_attribute (GValue* value, gpointer v_object); gpointer vala_value_get_version_attribute (const GValue* value); GType vala_version_attribute_get_type (void) G_GNUC_CONST; ValaVersionAttribute* vala_symbol_get_version (ValaSymbol* self); gboolean vala_symbol_get_hides (ValaSymbol* self); void vala_symbol_set_hides (ValaSymbol* self, gboolean value); ValaScope* vala_symbol_get_scope (ValaSymbol* self); gboolean vala_symbol_get_external (ValaSymbol* self); void vala_symbol_set_external (ValaSymbol* self, gboolean value); gboolean vala_symbol_get_external_package (ValaSymbol* self); gboolean vala_symbol_get_from_commandline (ValaSymbol* self); ValaSourceFileType vala_symbol_get_source_type (ValaSymbol* self); void vala_symbol_resolver_resolve (ValaSymbolResolver* self, ValaCodeContext* context); ValaSymbolResolver* vala_symbol_resolver_new (void); ValaSymbolResolver* vala_symbol_resolver_construct (GType object_type); ValaTargetValue* vala_target_value_construct (GType object_type, ValaDataType* value_type); ValaDataType* vala_target_value_get_value_type (ValaTargetValue* self); void vala_target_value_set_value_type (ValaTargetValue* self, ValaDataType* value); ValaDataType* vala_target_value_get_actual_value_type (ValaTargetValue* self); void vala_target_value_set_actual_value_type (ValaTargetValue* self, ValaDataType* value); ValaTemplate* vala_template_new (ValaSourceReference* source_reference); ValaTemplate* vala_template_construct (GType object_type, ValaSourceReference* source_reference); void vala_template_add_expression (ValaTemplate* self, ValaExpression* expr); ValaList* vala_template_get_expressions (ValaTemplate* self); ValaThrowStatement* vala_throw_statement_new (ValaExpression* error_expression, ValaSourceReference* source_reference); ValaThrowStatement* vala_throw_statement_construct (GType object_type, ValaExpression* error_expression, ValaSourceReference* source_reference); ValaExpression* vala_throw_statement_get_error_expression (ValaThrowStatement* self); void vala_throw_statement_set_error_expression (ValaThrowStatement* self, ValaExpression* value); const gchar* vala_token_type_to_string (ValaTokenType self); ValaTryStatement* vala_try_statement_new (ValaBlock* body, ValaBlock* finally_body, ValaSourceReference* source_reference); ValaTryStatement* vala_try_statement_construct (GType object_type, ValaBlock* body, ValaBlock* finally_body, ValaSourceReference* source_reference); void vala_try_statement_add_catch_clause (ValaTryStatement* self, ValaCatchClause* clause); ValaList* vala_try_statement_get_catch_clauses (ValaTryStatement* self); ValaBlock* vala_try_statement_get_body (ValaTryStatement* self); void vala_try_statement_set_body (ValaTryStatement* self, ValaBlock* value); ValaBlock* vala_try_statement_get_finally_body (ValaTryStatement* self); void vala_try_statement_set_finally_body (ValaTryStatement* self, ValaBlock* value); gboolean vala_try_statement_get_after_try_block_reachable (ValaTryStatement* self); void vala_try_statement_set_after_try_block_reachable (ValaTryStatement* self, gboolean value); ValaTuple* vala_tuple_new (ValaSourceReference* source_reference); ValaTuple* vala_tuple_construct (GType object_type, ValaSourceReference* source_reference); void vala_tuple_add_expression (ValaTuple* self, ValaExpression* expr); ValaList* vala_tuple_get_expressions (ValaTuple* self); ValaTypeCheck* vala_typecheck_new (ValaExpression* expr, ValaDataType* type, ValaSourceReference* source); ValaTypeCheck* vala_typecheck_construct (GType object_type, ValaExpression* expr, ValaDataType* type, ValaSourceReference* source); ValaExpression* vala_typecheck_get_expression (ValaTypeCheck* self); void vala_typecheck_set_expression (ValaTypeCheck* self, ValaExpression* value); ValaDataType* vala_typecheck_get_type_reference (ValaTypeCheck* self); void vala_typecheck_set_type_reference (ValaTypeCheck* self, ValaDataType* value); ValaTypeofExpression* vala_typeof_expression_new (ValaDataType* type, ValaSourceReference* source); ValaTypeofExpression* vala_typeof_expression_construct (GType object_type, ValaDataType* type, ValaSourceReference* source); ValaDataType* vala_typeof_expression_get_type_reference (ValaTypeofExpression* self); void vala_typeof_expression_set_type_reference (ValaTypeofExpression* self, ValaDataType* value); ValaTypeParameter* vala_typeparameter_new (const gchar* name, ValaSourceReference* source_reference); ValaTypeParameter* vala_typeparameter_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference); gboolean vala_typeparameter_equals (ValaTypeParameter* self, ValaTypeParameter* param2); ValaTypeSymbol* vala_typesymbol_construct (GType object_type, const gchar* name, ValaSourceReference* source_reference, ValaComment* comment); gboolean vala_typesymbol_is_reference_type (ValaTypeSymbol* self); gboolean vala_typesymbol_is_subtype_of (ValaTypeSymbol* self, ValaTypeSymbol* t); gint vala_typesymbol_get_type_parameter_index (ValaTypeSymbol* self, const gchar* name); GType vala_unary_operator_get_type (void) G_GNUC_CONST; ValaUnaryExpression* vala_unary_expression_new (ValaUnaryOperator op, ValaExpression* _inner, ValaSourceReference* source); ValaUnaryExpression* vala_unary_expression_construct (GType object_type, ValaUnaryOperator op, ValaExpression* _inner, ValaSourceReference* source); ValaUnaryOperator vala_unary_expression_get_operator (ValaUnaryExpression* self); void vala_unary_expression_set_operator (ValaUnaryExpression* self, ValaUnaryOperator value); ValaExpression* vala_unary_expression_get_inner (ValaUnaryExpression* self); void vala_unary_expression_set_inner (ValaUnaryExpression* self, ValaExpression* value); ValaUnlockStatement* vala_unlock_statement_new (ValaExpression* resource, ValaSourceReference* source_reference); ValaUnlockStatement* vala_unlock_statement_construct (GType object_type, ValaExpression* resource, ValaSourceReference* source_reference); ValaExpression* vala_unlock_statement_get_resource (ValaUnlockStatement* self); void vala_unlock_statement_set_resource (ValaUnlockStatement* self, ValaExpression* value); GType vala_unresolved_symbol_get_type (void) G_GNUC_CONST; ValaUnresolvedSymbol* vala_unresolved_symbol_new (ValaUnresolvedSymbol* inner, const gchar* name, ValaSourceReference* source_reference); ValaUnresolvedSymbol* vala_unresolved_symbol_construct (GType object_type, ValaUnresolvedSymbol* inner, const gchar* name, ValaSourceReference* source_reference); ValaUnresolvedSymbol* vala_unresolved_symbol_new_from_expression (ValaExpression* expr); ValaUnresolvedSymbol* vala_unresolved_symbol_copy (ValaUnresolvedSymbol* self); ValaUnresolvedSymbol* vala_unresolved_symbol_get_inner (ValaUnresolvedSymbol* self); void vala_unresolved_symbol_set_inner (ValaUnresolvedSymbol* self, ValaUnresolvedSymbol* value); gboolean vala_unresolved_symbol_get_qualified (ValaUnresolvedSymbol* self); void vala_unresolved_symbol_set_qualified (ValaUnresolvedSymbol* self, gboolean value); GType vala_unresolved_type_get_type (void) G_GNUC_CONST; ValaUnresolvedType* vala_unresolved_type_new (void); ValaUnresolvedType* vala_unresolved_type_construct (GType object_type); ValaUnresolvedType* vala_unresolved_type_new_from_symbol (ValaUnresolvedSymbol* symbol, ValaSourceReference* source); ValaUnresolvedType* vala_unresolved_type_construct_from_symbol (GType object_type, ValaUnresolvedSymbol* symbol, ValaSourceReference* source); ValaUnresolvedType* vala_unresolved_type_new_from_expression (ValaExpression* expr); ValaUnresolvedSymbol* vala_unresolved_type_get_unresolved_symbol (ValaUnresolvedType* self); void vala_unresolved_type_set_unresolved_symbol (ValaUnresolvedType* self, ValaUnresolvedSymbol* value); ValaUsedAttr* vala_used_attr_new (void); ValaUsedAttr* vala_used_attr_construct (GType object_type); void vala_used_attr_mark (ValaUsedAttr* self, const gchar* attribute, const gchar* argument); void vala_used_attr_check_unused (ValaUsedAttr* self, ValaCodeContext* context); ValaUsingDirective* vala_using_directive_new (ValaSymbol* namespace_symbol, ValaSourceReference* source_reference); ValaUsingDirective* vala_using_directive_construct (GType object_type, ValaSymbol* namespace_symbol, ValaSourceReference* source_reference); ValaSymbol* vala_using_directive_get_namespace_symbol (ValaUsingDirective* self); void vala_using_directive_set_namespace_symbol (ValaUsingDirective* self, ValaSymbol* value); ValaValueType* vala_value_type_construct (GType object_type, ValaTypeSymbol* type_symbol); ValaTypeSymbol* vala_value_type_get_type_symbol (ValaValueType* self); void vala_value_type_set_type_symbol (ValaValueType* self, ValaTypeSymbol* value); ValaVariable* vala_variable_new (ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference, ValaComment* comment); ValaVariable* vala_variable_construct (GType object_type, ValaDataType* variable_type, const gchar* name, ValaExpression* initializer, ValaSourceReference* source_reference, ValaComment* comment); ValaExpression* vala_variable_get_initializer (ValaVariable* self); void vala_variable_set_initializer (ValaVariable* self, ValaExpression* value); ValaDataType* vala_variable_get_variable_type (ValaVariable* self); void vala_variable_set_variable_type (ValaVariable* self, ValaDataType* value); gboolean vala_variable_get_single_assignment (ValaVariable* self); void vala_variable_set_single_assignment (ValaVariable* self, gboolean value); ValaVersionAttribute* vala_version_attribute_new (ValaSymbol* symbol); ValaVersionAttribute* vala_version_attribute_construct (GType object_type, ValaSymbol* symbol); gboolean vala_version_attribute_check (ValaVersionAttribute* self, ValaSourceReference* source_ref); gint vala_version_attribute_cmp_versions (const gchar* v1str, const gchar* v2str); gboolean vala_version_attribute_get_deprecated (ValaVersionAttribute* self); void vala_version_attribute_set_deprecated (ValaVersionAttribute* self, gboolean value); gchar* vala_version_attribute_get_deprecated_since (ValaVersionAttribute* self); void vala_version_attribute_set_deprecated_since (ValaVersionAttribute* self, const gchar* value); gchar* vala_version_attribute_get_replacement (ValaVersionAttribute* self); void vala_version_attribute_set_replacement (ValaVersionAttribute* self, const gchar* value); gboolean vala_version_attribute_get_experimental (ValaVersionAttribute* self); void vala_version_attribute_set_experimental (ValaVersionAttribute* self, gboolean value); gchar* vala_version_attribute_get_experimental_until (ValaVersionAttribute* self); void vala_version_attribute_set_experimental_until (ValaVersionAttribute* self, const gchar* value); gchar* vala_version_attribute_get_since (ValaVersionAttribute* self); void vala_version_attribute_set_since (ValaVersionAttribute* self, const gchar* value); GType vala_void_type_get_type (void) G_GNUC_CONST; ValaVoidType* vala_void_type_new (ValaSourceReference* source_reference); ValaVoidType* vala_void_type_construct (GType object_type, ValaSourceReference* source_reference); ValaWhileStatement* vala_while_statement_new (ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference); ValaWhileStatement* vala_while_statement_construct (GType object_type, ValaExpression* condition, ValaBlock* body, ValaSourceReference* source_reference); ValaExpression* vala_while_statement_get_condition (ValaWhileStatement* self); void vala_while_statement_set_condition (ValaWhileStatement* self, ValaExpression* value); ValaBlock* vala_while_statement_get_body (ValaWhileStatement* self); void vala_while_statement_set_body (ValaWhileStatement* self, ValaBlock* value); ValaYieldStatement* vala_yield_statement_new (ValaExpression* yield_expression, ValaSourceReference* source_reference); ValaYieldStatement* vala_yield_statement_construct (GType object_type, ValaExpression* yield_expression, ValaSourceReference* source_reference); ValaExpression* vala_yield_statement_get_yield_expression (ValaYieldStatement* self); void vala_yield_statement_set_yield_expression (ValaYieldStatement* self, ValaExpression* value); G_END_DECLS #endif valabind-1.5.0/private/vala.vapi000066400000000000000000003653271323123274000165700ustar00rootroot00000000000000/* vala.vapi generated by valac, do not modify. */ namespace Vala { namespace Genie { [CCode (cheader_filename = "vala.h")] public class Parser : Vala.CodeVisitor { public Parser (); public void parse (Vala.CodeContext context); public void parse_file (Vala.SourceFile source_file); public override void visit_source_file (Vala.SourceFile source_file); } [CCode (cheader_filename = "vala.h")] public class Scanner { public Scanner (Vala.SourceFile source_file); public static Vala.Genie.TokenType get_identifier_or_keyword (char* begin, int len); public void parse_file_comments (); public Vala.Comment? pop_comment (); public Vala.Genie.TokenType read_regex_token (out Vala.SourceLocation token_begin, out Vala.SourceLocation token_end); public Vala.Genie.TokenType read_template_token (out Vala.SourceLocation token_begin, out Vala.SourceLocation token_end); public Vala.Genie.TokenType read_token (out Vala.SourceLocation token_begin, out Vala.SourceLocation token_end); public void seek (Vala.SourceLocation location); public int indent_spaces { get; set; } public Vala.SourceFile source_file { get; private set; } } [CCode (cheader_filename = "vala.h")] public enum TokenType { NONE, ABSTRACT, ARRAY, AS, ASSERT, ASSIGN, ASSIGN_ADD, ASSIGN_BITWISE_AND, ASSIGN_BITWISE_OR, ASSIGN_BITWISE_XOR, ASSIGN_DIV, ASSIGN_MUL, ASSIGN_PERCENT, ASSIGN_SHIFT_LEFT, ASSIGN_SUB, ASYNC, BITWISE_AND, BITWISE_OR, BREAK, CARRET, CASE, CHARACTER_LITERAL, CLASS, CLOSE_BRACE, CLOSE_BRACKET, CLOSE_PARENS, CLOSE_REGEX_LITERAL, CLOSE_TEMPLATE, COLON, COMMA, CONST, CONSTRUCT, CONTINUE, DEDENT, DEF, DEFAULT, DELEGATE, DELETE, DICT, DIV, DO, DOT, DOWNTO, DYNAMIC, ELLIPSIS, ELSE, ENUM, ENSURES, ERRORDOMAIN, EOF, EOL, EVENT, EXCEPT, EXTERN, FALSE, FINAL, FINALLY, FOR, GET, HASH, IDENTIFIER, IF, IMPLEMENTS, IN, INDENT, INIT, INLINE, INTEGER_LITERAL, INTERFACE, INTERNAL, INTERR, IS, ISA, LAMBDA, LIST, LOCK, MINUS, NAMESPACE, NEW, NULL, OF, OUT, OP_AND, OP_DEC, OP_EQ, OP_GE, OP_GT, OP_INC, OP_LE, OP_LT, OP_NE, OP_NEG, OP_OR, OP_PTR, OP_SHIFT_LEFT, OPEN_BRACE, OPEN_BRACKET, OPEN_PARENS, OPEN_REGEX_LITERAL, OPEN_TEMPLATE, OVERRIDE, OWNED, PARAMS, PASS, PERCENT, PLUS, PRINT, PRIVATE, PROP, PROTECTED, PUBLIC, RAISE, RAISES, READONLY, REAL_LITERAL, REF, REGEX_LITERAL, REQUIRES, RETURN, SEALED, SEMICOLON, SET, SIZEOF, STAR, STATIC, STRING_LITERAL, STRUCT, SUPER, TEMPLATE_STRING_LITERAL, THIS, TILDE, TO, TRUE, TRY, TYPEOF, UNOWNED, USES, VAR, VERBATIM_STRING_LITERAL, VIRTUAL, VOID, VOLATILE, WEAK, WHEN, WHILE, WRITEONLY, YIELD; public unowned string to_string (); } } [CCode (cheader_filename = "vala.h")] public class AddressofExpression : Vala.Expression { public AddressofExpression (Vala.Expression inner, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression inner { get; set; } } [CCode (cheader_filename = "vala.h")] public class ArrayCopyMethod : Vala.Method { public ArrayCopyMethod (Vala.SourceReference source_reference); } [CCode (cheader_filename = "vala.h")] public class ArrayCreationExpression : Vala.Expression { public ArrayCreationExpression (Vala.DataType element_type, int rank, Vala.InitializerList? initializer_list, Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void append_size (Vala.Expression size); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_sizes (); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.DataType element_type { get; set; } public Vala.InitializerList? initializer_list { get; set; } public int rank { get; set; } } [CCode (cheader_filename = "vala.h")] public class ArrayLengthField : Vala.Field { public ArrayLengthField (Vala.SourceReference source_reference); } [CCode (cheader_filename = "vala.h")] public class ArrayMoveMethod : Vala.Method { public ArrayMoveMethod (Vala.SourceReference source_reference); } [CCode (cheader_filename = "vala.h")] public class ArrayResizeMethod : Vala.Method { public ArrayResizeMethod (Vala.SourceReference source_reference); } [CCode (cheader_filename = "vala.h")] public class ArrayType : Vala.ReferenceType { public ArrayType (Vala.DataType element_type, int rank, Vala.SourceReference? source_reference); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); public override Vala.DataType get_actual_type (Vala.DataType? derived_instance_type, Vala.List? method_type_arguments, Vala.CodeNode node_reference); public override Vala.Symbol? get_member (string member_name); public override Vala.DataType? infer_type_argument (Vala.TypeParameter type_param, Vala.DataType value_type); public override bool is_accessible (Vala.Symbol sym); public override bool is_array (); public override bool is_disposable (); public override bool is_reference_type_or_type_parameter (); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public override string to_qualified_string (Vala.Scope? scope); public Vala.DataType element_type { get; set; } public bool fixed_length { get; set; } public bool inline_allocated { get; set; } public bool invalid_syntax { get; set; } public Vala.Expression? length { get; set; } public int rank { get; set; } } [CCode (cheader_filename = "vala.h")] public class Assignment : Vala.Expression { public Assignment (Vala.Expression left, Vala.Expression right, Vala.AssignmentOperator operator = AssignmentOperator.SIMPLE, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression left { get; set; } public Vala.AssignmentOperator operator { get; set; } public Vala.Expression right { get; set; } } [CCode (cheader_filename = "vala.h")] public class Attribute : Vala.CodeNode { public Attribute (string name, Vala.SourceReference? source_reference = null); public void add_argument (string key, string value); public bool get_bool (string name, bool default_value = false); public double get_double (string name, double default_value = 0); public int get_integer (string name, int default_value = 0); public string? get_string (string name, string? default_value = null); public bool has_argument (string name); public Vala.Map args { get; private set; } public string name { get; set; } } [CCode (cheader_filename = "vala.h")] public class AttributeCache { public AttributeCache (); } [CCode (cheader_filename = "vala.h")] public class BaseAccess : Vala.Expression { public BaseAccess (Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_pure (); public override string to_string (); } [CCode (cheader_filename = "vala.h")] public class BasicBlock { public BasicBlock (); public void add_child (Vala.BasicBlock block); public void add_dominator_frontier (Vala.BasicBlock block); public void add_node (Vala.CodeNode node); public void add_phi_function (Vala.PhiFunction phi); public void connect (Vala.BasicBlock target); public BasicBlock.entry (); public BasicBlock.exit (); public Vala.List get_children (); public Vala.Set get_dominator_frontier (); public Vala.List get_nodes (); public Vala.Set get_phi_functions (); public Vala.List get_predecessors (); public Vala.List get_successors (); public Vala.BasicBlock parent { get; private set; } public int postorder_number { get; set; } public bool postorder_visited { get; set; } } [CCode (cheader_filename = "vala.h")] public class BinaryExpression : Vala.Expression { public BinaryExpression (Vala.BinaryOperator op, Vala.Expression _left, Vala.Expression _right, Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public BinaryExpression.chained (Vala.BinaryOperator op, Vala.Expression _left, Vala.Expression _right, Vala.SourceReference? source = null); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_constant (); public override bool is_non_null (); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override string to_string (); public bool is_chained { get; private set; } public Vala.Expression left { get; set; } public Vala.BinaryOperator operator { get; set; } public Vala.Expression right { get; set; } } [CCode (cheader_filename = "vala.h")] public class Block : Vala.Symbol, Vala.Statement { public Block (Vala.SourceReference? source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_local_constant (Vala.Constant constant); public void add_local_variable (Vala.LocalVariable local); public void add_statement (Vala.Statement stmt); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_local_variables (); public Vala.List get_statements (); public void insert_before (Vala.Statement stmt, Vala.Statement new_stmt); public void insert_statement (int index, Vala.Statement stmt); public void remove_local_variable (Vala.LocalVariable local); public void replace_statement (Vala.Statement old_stmt, Vala.Statement new_stmt); public bool captured { get; set; } public bool contains_jump_statement { get; set; } } [CCode (cheader_filename = "vala.h")] public class BooleanLiteral : Vala.Literal { public BooleanLiteral (bool b, Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_pure (); public override string to_string (); public bool value { get; set; } } [CCode (cheader_filename = "vala.h")] public class BooleanType : Vala.ValueType { public BooleanType (Vala.Struct type_symbol); public override Vala.DataType copy (); } [CCode (cheader_filename = "vala.h")] public class BreakStatement : Vala.CodeNode, Vala.Statement { public BreakStatement (Vala.SourceReference? source); public override void accept (Vala.CodeVisitor visitor); public override void emit (Vala.CodeGenerator codegen); } [CCode (cheader_filename = "vala.h")] public abstract class CallableType : Vala.DataType { public CallableType (); public override string to_prototype_string (string? override_name = null); } [CCode (cheader_filename = "vala.h")] public class CastExpression : Vala.Expression { public CastExpression (Vala.Expression inner, Vala.DataType type_reference, Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_constant (); public override bool is_pure (); public CastExpression.non_null (Vala.Expression inner, Vala.SourceReference source_reference); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public CastExpression.silent (Vala.Expression inner, Vala.DataType type_reference, Vala.SourceReference source_reference); public Vala.Expression inner { get; set; } public bool is_non_null_cast { get; private set; } public bool is_silent_cast { get; private set; } public Vala.DataType type_reference { get; set; } } [CCode (cheader_filename = "vala.h")] public class CatchClause : Vala.CodeNode { public CatchClause (Vala.DataType? error_type, string? variable_name, Vala.Block body, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.Block body { get; set; } public string? clabel_name { get; set; } public Vala.DataType? error_type { get; set; } public Vala.LocalVariable error_variable { get; set; } public string? variable_name { get; set; } } [CCode (cheader_filename = "vala.h")] public class CharacterLiteral : Vala.Literal { public CharacterLiteral (string c, Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public unichar get_char (); public override bool is_pure (); public override string to_string (); public string value { get; set; } } [CCode (cheader_filename = "vala.h")] public class Class : Vala.ObjectTypeSymbol { public Class (string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_base_type (Vala.DataType type); public override void add_class (Vala.Class cl); public override void add_constant (Vala.Constant c); public override void add_constructor (Vala.Constructor c); public override void add_delegate (Vala.Delegate d); public override void add_destructor (Vala.Destructor d); public override void add_enum (Vala.Enum en); public override void add_field (Vala.Field f); public override void add_method (Vala.Method m); public override void add_property (Vala.Property prop); public override void add_signal (Vala.Signal sig); public override void add_struct (Vala.Struct st); public override bool check (Vala.CodeContext context); public Vala.List get_base_types (); public Vala.List get_classes (); public Vala.List get_constants (); public Vala.List get_delegates (); public Vala.List get_enums (); public Vala.List get_fields (); public override Vala.List get_methods (); public override Vala.List get_properties (); public override Vala.List get_signals (); public Vala.List get_structs (); public bool is_fundamental (); public override bool is_reference_type (); public override bool is_subtype_of (Vala.TypeSymbol t); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.Class base_class { get; set; } public Vala.Constructor class_constructor { get; set; } public Vala.Destructor? class_destructor { get; set; } public Vala.Constructor constructor { get; set; } public Vala.CreationMethod default_construction_method { get; set; } public Vala.Destructor? destructor { get; set; } public bool has_class_private_fields { get; private set; } public bool has_private_fields { get; set; } public bool is_abstract { get; set; } public bool is_compact { get; set; } public bool is_error_base { get; } public bool is_immutable { get; set; } public Vala.Constructor static_constructor { get; set; } public Vala.Destructor? static_destructor { get; set; } } [CCode (cheader_filename = "vala.h")] public class ClassType : Vala.ReferenceType { public ClassType (Vala.Class class_symbol); public override Vala.DataType copy (); public Vala.Class class_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public class CodeContext { public CodeContext (); public void accept (Vala.CodeVisitor visitor); public void add_c_source_file (string file); public void add_define (string define); public bool add_external_package (string pkg); public void add_package (string pkg); public bool add_packages_from_file (string filename); public void add_source_file (Vala.SourceFile file); public bool add_source_filename (string filename, bool is_source = false, bool cmdline = false); public void check (); public static Vala.CodeContext @get (); public Vala.List get_c_source_files (); public string? get_gir_path (string gir); public string? get_gresource_path (string gresource, string resource); public string? get_metadata_path (string gir_filename); public Vala.List get_packages (); public Vala.List get_source_files (); public string? get_vapi_path (string pkg); public bool has_package (string pkg); public bool is_defined (string define); public static void pop (); public static void push (Vala.CodeContext context); public static string realpath (string name); public bool require_glib_version (int major, int minor); public void write_dependencies (string filename); public Vala.SemanticAnalyzer analyzer { get; private set; } public bool assert { get; set; } public string basedir { get; set; } public bool ccode_only { get; set; } public bool checking { get; set; } public Vala.CodeGenerator codegen { get; set; } public bool compile_only { get; set; } public bool debug { get; set; } public bool deprecated { get; set; } public string directory { get; set; } public Vala.Method? entry_point { get; set; } public string entry_point_name { get; set; } public bool experimental { get; set; } public bool experimental_non_null { get; set; } public Vala.FlowAnalyzer flow_analyzer { get; private set; } public string[] gir_directories { get; set; } public bool gobject_tracing { get; set; } public string[] gresources { get; set; } public string[] gresources_directories { get; set; } public string? header_filename { get; set; } public bool hide_internal { get; set; } public string? includedir { get; set; } public string? internal_header_filename { get; set; } public bool mem_profiler { get; set; } public string[] metadata_directories { get; set; } public Vala.Method module_init_method { get; set; } public bool nostdpkg { get; set; } public int optlevel { get; set; } public string output { get; set; } public Vala.Profile profile { get; set; } public Vala.Report report { get; set; } public Vala.SymbolResolver resolver { get; private set; } public Vala.Namespace root { get; } public bool run_output { get; set; } public bool save_csources { get; } public bool save_temps { get; set; } public bool since_check { get; set; } public string? symbols_filename { get; set; } public int target_glib_major { get; set; } public int target_glib_minor { get; set; } public bool use_fast_vapi { get; set; } public bool use_header { get; set; } public Vala.UsedAttr used_attr { get; set; } public bool vapi_comments { get; set; } public string[] vapi_directories { get; set; } public bool verbose_mode { get; set; } public bool version_header { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class CodeGenerator : Vala.CodeVisitor { public CodeGenerator (); public virtual void emit (Vala.CodeContext context); public abstract Vala.TargetValue load_field (Vala.Field field, Vala.TargetValue? instance); public abstract Vala.TargetValue load_local (Vala.LocalVariable local); public abstract Vala.TargetValue load_parameter (Vala.Parameter param); public abstract void store_field (Vala.Field field, Vala.TargetValue? instance, Vala.TargetValue value, Vala.SourceReference? source_reference = null); public abstract void store_local (Vala.LocalVariable local, Vala.TargetValue value, bool initializer, Vala.SourceReference? source_reference = null); public abstract void store_parameter (Vala.Parameter param, Vala.TargetValue value, bool capturing_parameter = false, Vala.SourceReference? source_reference = null); } [CCode (cheader_filename = "vala.h")] public abstract class CodeNode { public GLib.List attributes; public CodeNode (); public virtual void accept (Vala.CodeVisitor visitor); public virtual void accept_children (Vala.CodeVisitor visitor); public void add_error_type (Vala.DataType error_type); public void add_error_types (Vala.List error_types); public virtual bool check (Vala.CodeContext context); public virtual void emit (Vala.CodeGenerator codegen); public Vala.Attribute? get_attribute (string name); public bool get_attribute_bool (string attribute, string argument, bool default_value = false); public Vala.AttributeCache? get_attribute_cache (int index); public static int get_attribute_cache_index (); public double get_attribute_double (string attribute, string argument, double default_value = 0); public int get_attribute_integer (string attribute, string argument, int default_value = 0); public string? get_attribute_string (string attribute, string argument, string? default_value = null); public virtual void get_defined_variables (Vala.Collection collection); public Vala.List get_error_types (); public static string get_temp_name (); public virtual void get_used_variables (Vala.Collection collection); public bool has_attribute_argument (string attribute, string argument); public void remove_attribute_argument (string attribute, string argument); public virtual void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public virtual void replace_type (Vala.DataType old_type, Vala.DataType new_type); public void set_attribute (string name, bool value, Vala.SourceReference? source_reference = null); public void set_attribute_bool (string attribute, string argument, bool value, Vala.SourceReference? source_reference = null); public void set_attribute_cache (int index, Vala.AttributeCache cache); public void set_attribute_double (string attribute, string argument, double value, Vala.SourceReference? source_reference = null); public void set_attribute_integer (string attribute, string argument, int value, Vala.SourceReference? source_reference = null); public void set_attribute_string (string attribute, string argument, string? value, Vala.SourceReference? source_reference = null); public virtual string to_string (); public bool checked { get; set; } public bool error { get; set; } public Vala.CodeNode? parent_node { get; set; } public Vala.SourceReference? source_reference { get; set; } public bool tree_can_fail { get; } public string type_name { get; } public bool unreachable { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class CodeVisitor { public CodeVisitor (); public virtual void visit_addressof_expression (Vala.AddressofExpression expr); public virtual void visit_array_creation_expression (Vala.ArrayCreationExpression expr); public virtual void visit_assignment (Vala.Assignment a); public virtual void visit_base_access (Vala.BaseAccess expr); public virtual void visit_binary_expression (Vala.BinaryExpression expr); public virtual void visit_block (Vala.Block b); public virtual void visit_boolean_literal (Vala.BooleanLiteral lit); public virtual void visit_break_statement (Vala.BreakStatement stmt); public virtual void visit_cast_expression (Vala.CastExpression expr); public virtual void visit_catch_clause (Vala.CatchClause clause); public virtual void visit_character_literal (Vala.CharacterLiteral lit); public virtual void visit_class (Vala.Class cl); public virtual void visit_conditional_expression (Vala.ConditionalExpression expr); public virtual void visit_constant (Vala.Constant c); public virtual void visit_constructor (Vala.Constructor c); public virtual void visit_continue_statement (Vala.ContinueStatement stmt); public virtual void visit_creation_method (Vala.CreationMethod m); public virtual void visit_data_type (Vala.DataType type); public virtual void visit_declaration_statement (Vala.DeclarationStatement stmt); public virtual void visit_delegate (Vala.Delegate d); public virtual void visit_delete_statement (Vala.DeleteStatement stmt); public virtual void visit_destructor (Vala.Destructor d); public virtual void visit_do_statement (Vala.DoStatement stmt); public virtual void visit_element_access (Vala.ElementAccess expr); public virtual void visit_empty_statement (Vala.EmptyStatement stmt); public virtual void visit_end_full_expression (Vala.Expression expr); public virtual void visit_enum (Vala.Enum en); public virtual void visit_enum_value (Vala.EnumValue ev); public virtual void visit_error_code (Vala.ErrorCode ecode); public virtual void visit_error_domain (Vala.ErrorDomain edomain); public virtual void visit_expression (Vala.Expression expr); public virtual void visit_expression_statement (Vala.ExpressionStatement stmt); public virtual void visit_field (Vala.Field f); public virtual void visit_for_statement (Vala.ForStatement stmt); public virtual void visit_foreach_statement (Vala.ForeachStatement stmt); public virtual void visit_formal_parameter (Vala.Parameter p); public virtual void visit_if_statement (Vala.IfStatement stmt); public virtual void visit_initializer_list (Vala.InitializerList list); public virtual void visit_integer_literal (Vala.IntegerLiteral lit); public virtual void visit_interface (Vala.Interface iface); public virtual void visit_lambda_expression (Vala.LambdaExpression expr); public virtual void visit_local_variable (Vala.LocalVariable local); public virtual void visit_lock_statement (Vala.LockStatement stmt); public virtual void visit_loop (Vala.Loop stmt); public virtual void visit_member_access (Vala.MemberAccess expr); public virtual void visit_method (Vala.Method m); public virtual void visit_method_call (Vala.MethodCall expr); public virtual void visit_named_argument (Vala.NamedArgument expr); public virtual void visit_namespace (Vala.Namespace ns); public virtual void visit_null_literal (Vala.NullLiteral lit); public virtual void visit_object_creation_expression (Vala.ObjectCreationExpression expr); public virtual void visit_pointer_indirection (Vala.PointerIndirection expr); public virtual void visit_postfix_expression (Vala.PostfixExpression expr); public virtual void visit_property (Vala.Property prop); public virtual void visit_property_accessor (Vala.PropertyAccessor acc); public virtual void visit_real_literal (Vala.RealLiteral lit); public virtual void visit_reference_transfer_expression (Vala.ReferenceTransferExpression expr); public virtual void visit_regex_literal (Vala.RegexLiteral lit); public virtual void visit_return_statement (Vala.ReturnStatement stmt); public virtual void visit_signal (Vala.Signal sig); public virtual void visit_sizeof_expression (Vala.SizeofExpression expr); public virtual void visit_slice_expression (Vala.SliceExpression expr); public virtual void visit_source_file (Vala.SourceFile source_file); public virtual void visit_string_literal (Vala.StringLiteral lit); public virtual void visit_struct (Vala.Struct st); public virtual void visit_switch_label (Vala.SwitchLabel label); public virtual void visit_switch_section (Vala.SwitchSection section); public virtual void visit_switch_statement (Vala.SwitchStatement stmt); public virtual void visit_template (Vala.Template tmpl); public virtual void visit_throw_statement (Vala.ThrowStatement stmt); public virtual void visit_try_statement (Vala.TryStatement stmt); public virtual void visit_tuple (Vala.Tuple tuple); public virtual void visit_type_check (Vala.TypeCheck expr); public virtual void visit_type_parameter (Vala.TypeParameter p); public virtual void visit_typeof_expression (Vala.TypeofExpression expr); public virtual void visit_unary_expression (Vala.UnaryExpression expr); public virtual void visit_unlock_statement (Vala.UnlockStatement stmt); public virtual void visit_using_directive (Vala.UsingDirective ns); public virtual void visit_while_statement (Vala.WhileStatement stmt); public virtual void visit_yield_statement (Vala.YieldStatement y); } [CCode (cheader_filename = "vala.h")] public class CodeWriter : Vala.CodeVisitor { public CodeWriter (Vala.CodeWriterType type = CodeWriterType.EXTERNAL); public void set_cheader_override (string original, string replacement); public override void visit_addressof_expression (Vala.AddressofExpression expr); public override void visit_array_creation_expression (Vala.ArrayCreationExpression expr); public override void visit_assignment (Vala.Assignment a); public override void visit_base_access (Vala.BaseAccess expr); public override void visit_binary_expression (Vala.BinaryExpression expr); public override void visit_block (Vala.Block b); public override void visit_boolean_literal (Vala.BooleanLiteral lit); public override void visit_break_statement (Vala.BreakStatement stmt); public override void visit_cast_expression (Vala.CastExpression expr); public override void visit_catch_clause (Vala.CatchClause clause); public override void visit_character_literal (Vala.CharacterLiteral lit); public override void visit_class (Vala.Class cl); public override void visit_conditional_expression (Vala.ConditionalExpression expr); public override void visit_constant (Vala.Constant c); public override void visit_constructor (Vala.Constructor c); public override void visit_continue_statement (Vala.ContinueStatement stmt); public override void visit_creation_method (Vala.CreationMethod m); public override void visit_declaration_statement (Vala.DeclarationStatement stmt); public override void visit_delegate (Vala.Delegate cb); public override void visit_delete_statement (Vala.DeleteStatement stmt); public override void visit_do_statement (Vala.DoStatement stmt); public override void visit_element_access (Vala.ElementAccess expr); public override void visit_empty_statement (Vala.EmptyStatement stmt); public override void visit_enum (Vala.Enum en); public override void visit_error_domain (Vala.ErrorDomain edomain); public override void visit_expression_statement (Vala.ExpressionStatement stmt); public override void visit_field (Vala.Field f); public override void visit_for_statement (Vala.ForStatement stmt); public override void visit_foreach_statement (Vala.ForeachStatement stmt); public override void visit_if_statement (Vala.IfStatement stmt); public override void visit_initializer_list (Vala.InitializerList list); public override void visit_integer_literal (Vala.IntegerLiteral lit); public override void visit_interface (Vala.Interface iface); public override void visit_lambda_expression (Vala.LambdaExpression expr); public override void visit_local_variable (Vala.LocalVariable local); public override void visit_lock_statement (Vala.LockStatement stmt); public override void visit_loop (Vala.Loop stmt); public override void visit_member_access (Vala.MemberAccess expr); public override void visit_method (Vala.Method m); public override void visit_method_call (Vala.MethodCall expr); public override void visit_namespace (Vala.Namespace ns); public override void visit_null_literal (Vala.NullLiteral lit); public override void visit_object_creation_expression (Vala.ObjectCreationExpression expr); public override void visit_pointer_indirection (Vala.PointerIndirection expr); public override void visit_postfix_expression (Vala.PostfixExpression expr); public override void visit_property (Vala.Property prop); public override void visit_real_literal (Vala.RealLiteral lit); public override void visit_reference_transfer_expression (Vala.ReferenceTransferExpression expr); public override void visit_return_statement (Vala.ReturnStatement stmt); public override void visit_signal (Vala.Signal sig); public override void visit_sizeof_expression (Vala.SizeofExpression expr); public override void visit_slice_expression (Vala.SliceExpression expr); public override void visit_string_literal (Vala.StringLiteral lit); public override void visit_struct (Vala.Struct st); public override void visit_switch_label (Vala.SwitchLabel label); public override void visit_switch_section (Vala.SwitchSection section); public override void visit_switch_statement (Vala.SwitchStatement stmt); public override void visit_throw_statement (Vala.ThrowStatement stmt); public override void visit_try_statement (Vala.TryStatement stmt); public override void visit_type_check (Vala.TypeCheck expr); public override void visit_typeof_expression (Vala.TypeofExpression expr); public override void visit_unary_expression (Vala.UnaryExpression expr); public override void visit_using_directive (Vala.UsingDirective ns); public override void visit_while_statement (Vala.WhileStatement stmt); public override void visit_yield_statement (Vala.YieldStatement y); public void write_file (Vala.CodeContext context, string filename); } [CCode (cheader_filename = "vala.h")] public class Comment { public Comment (string comment, Vala.SourceReference _source_reference); public string content { get; set; } public Vala.SourceReference source_reference { get; set; } } [CCode (cheader_filename = "vala.h")] public class ConditionalExpression : Vala.Expression { public ConditionalExpression (Vala.Expression cond, Vala.Expression true_expr, Vala.Expression false_expr, Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public Vala.Expression condition { get; set; } public Vala.Expression false_expression { get; set; } public Vala.Expression true_expression { get; set; } } [CCode (cheader_filename = "vala.h")] public class Constant : Vala.Symbol, Vala.Lockable { public Constant (string name, Vala.DataType? type_reference, Vala.Expression? value, Vala.SourceReference? source_reference, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.DataType type_reference { get; set; } public Vala.Expression? value { get; set; } } [CCode (cheader_filename = "vala.h")] public class Constructor : Vala.Subroutine { public Constructor (Vala.SourceReference? source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public Vala.MemberBinding binding { get; set; } public override bool has_result { get; } public Vala.Parameter this_parameter { get; set; } } [CCode (cheader_filename = "vala.h")] public class ContinueStatement : Vala.CodeNode, Vala.Statement { public ContinueStatement (Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void emit (Vala.CodeGenerator codegen); } [CCode (cheader_filename = "vala.h")] public class CreationMethod : Vala.Method { public CreationMethod (string? class_name, string? name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public bool chain_up { get; set; } public string class_name { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class DataType : Vala.CodeNode { public DataType (); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_type_argument (Vala.DataType arg); public virtual bool compatible (Vala.DataType target_type); public abstract Vala.DataType copy (); public virtual bool equals (Vala.DataType type2); public virtual Vala.DataType get_actual_type (Vala.DataType? derived_instance_type, Vala.List? method_type_arguments, Vala.CodeNode node_reference); public virtual Vala.Symbol? get_member (string member_name); public virtual Vala.List? get_parameters (); public virtual Vala.Symbol? get_pointer_member (string member_name); public virtual Vala.DataType? get_return_type (); public Vala.List get_type_arguments (); public bool has_type_arguments (); public virtual Vala.DataType? infer_type_argument (Vala.TypeParameter type_param, Vala.DataType value_type); public virtual bool is_accessible (Vala.Symbol sym); public virtual bool is_array (); public virtual bool is_disposable (); public virtual bool is_invokable (); public bool is_real_non_null_struct_type (); public virtual bool is_real_struct_type (); public virtual bool is_reference_type_or_type_parameter (); public bool is_weak (); public void remove_all_type_arguments (); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public virtual bool stricter (Vala.DataType type2); public virtual string to_prototype_string (string? override_name = null); public virtual string to_qualified_string (Vala.Scope? scope = null); public override string to_string (); public Vala.TypeSymbol data_type { get; set; } public bool floating_reference { get; set; } public bool is_dynamic { get; set; } public bool nullable { get; set; } public bool value_owned { get; set; } } [CCode (cheader_filename = "vala.h")] public class DeclarationStatement : Vala.CodeNode, Vala.Statement { public DeclarationStatement (Vala.Symbol declaration, Vala.SourceReference? source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public Vala.Symbol declaration { get; set; } } [CCode (cheader_filename = "vala.h")] public class Delegate : Vala.TypeSymbol, Vala.Callable { public Delegate (string? name, Vala.DataType return_type, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_type_parameter (Vala.TypeParameter p); public override bool check (Vala.CodeContext context); public override int get_type_parameter_index (string name); public Vala.List get_type_parameters (); public override bool is_reference_type (); public bool matches_method (Vala.Method m, Vala.DataType dt); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public bool has_target { get; set; } public Vala.DataType? sender_type { get; set; } } [CCode (cheader_filename = "vala.h")] public class DelegateType : Vala.CallableType { public DelegateType (Vala.Delegate delegate_symbol); public override bool check (Vala.CodeContext context); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); public override Vala.List? get_parameters (); public override Vala.DataType? get_return_type (); public override bool is_accessible (Vala.Symbol sym); public override bool is_disposable (); public override bool is_invokable (); public override string to_qualified_string (Vala.Scope? scope); public Vala.Delegate delegate_symbol { get; set; } public bool is_called_once { get; set; } } [CCode (cheader_filename = "vala.h")] public class DeleteStatement : Vala.CodeNode, Vala.Statement { public DeleteStatement (Vala.Expression expression, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.Expression expression { get; set; } } [CCode (cheader_filename = "vala.h")] public class Destructor : Vala.Subroutine { public Destructor (Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public Vala.MemberBinding binding { get; set; } public override bool has_result { get; } public Vala.Parameter this_parameter { get; set; } } [CCode (cheader_filename = "vala.h")] public class DoStatement : Vala.CodeNode, Vala.Statement { public DoStatement (Vala.Block body, Vala.Expression condition, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public Vala.Block body { get; set; } public Vala.Expression condition { get; set; } } [CCode (cheader_filename = "vala.h")] public class DynamicMethod : Vala.Method { public DynamicMethod (Vala.DataType dynamic_type, string name, Vala.DataType return_type, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override bool check (Vala.CodeContext context); public Vala.DataType dynamic_type { get; set; } public Vala.MethodCall invocation { get; set; } } [CCode (cheader_filename = "vala.h")] public class DynamicProperty : Vala.Property { public DynamicProperty (Vala.DataType dynamic_type, string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override bool check (Vala.CodeContext context); public Vala.DataType dynamic_type { get; set; } } [CCode (cheader_filename = "vala.h")] public class DynamicSignal : Vala.Signal { public DynamicSignal (Vala.DataType dynamic_type, string name, Vala.DataType return_type, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override bool check (Vala.CodeContext context); public Vala.DataType dynamic_type { get; set; } public Vala.Expression handler { get; set; } } [CCode (cheader_filename = "vala.h")] public class ElementAccess : Vala.Expression { public ElementAccess (Vala.Expression container, Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void append_index (Vala.Expression index); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public Vala.List get_indices (); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression container { get; set; } } [CCode (cheader_filename = "vala.h")] public class EmptyStatement : Vala.CodeNode, Vala.Statement { public EmptyStatement (Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void emit (Vala.CodeGenerator codegen); } [CCode (cheader_filename = "vala.h")] public class Enum : Vala.TypeSymbol { public Enum (string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override void add_constant (Vala.Constant c); public override void add_method (Vala.Method m); public void add_value (Vala.EnumValue value); public override bool check (Vala.CodeContext context); public Vala.List get_constants (); public Vala.List get_methods (); public Vala.List get_values (); public override bool is_reference_type (); public void remove_all_values (); public bool is_flags { get; } } [CCode (cheader_filename = "vala.h")] public class EnumValue : Vala.Constant { public EnumValue (string name, Vala.Expression? value, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); } [CCode (cheader_filename = "vala.h")] public class EnumValueType : Vala.ValueType { public EnumValueType (Vala.Enum type_symbol); public override Vala.DataType copy (); public override Vala.Symbol? get_member (string member_name); public Vala.Method get_to_string_method (); } [CCode (cheader_filename = "vala.h")] public class ErrorCode : Vala.TypeSymbol { public ErrorCode (string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public ErrorCode.with_value (string name, Vala.Expression value, Vala.SourceReference? source_reference = null); public Vala.Expression value { get; set; } } [CCode (cheader_filename = "vala.h")] public class ErrorDomain : Vala.TypeSymbol { public ErrorDomain (string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_code (Vala.ErrorCode ecode); public override void add_method (Vala.Method m); public override bool check (Vala.CodeContext context); public Vala.List get_codes (); public Vala.List get_methods (); public override bool is_reference_type (); } [CCode (cheader_filename = "vala.h")] public class ErrorType : Vala.ReferenceType { public ErrorType (Vala.ErrorDomain? error_domain, Vala.ErrorCode? error_code, Vala.SourceReference? source_reference = null); public override bool check (Vala.CodeContext context); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); public override bool equals (Vala.DataType type2); public override Vala.Symbol? get_member (string member_name); public override bool is_reference_type_or_type_parameter (); public override string to_qualified_string (Vala.Scope? scope); public bool dynamic_error { get; set; } public Vala.ErrorCode? error_code { get; set; } public Vala.ErrorDomain? error_domain { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class Expression : Vala.CodeNode { public Expression (); public void insert_statement (Vala.Block block, Vala.Statement stmt); public virtual bool is_accessible (Vala.Symbol sym); public virtual bool is_constant (); public virtual bool is_non_null (); public abstract bool is_pure (); public Vala.DataType? formal_target_type { get; set; } public Vala.DataType? formal_value_type { get; set; } public bool lvalue { get; set; } public Vala.Statement? parent_statement { get; } public Vala.Symbol symbol_reference { get; set; } public Vala.DataType target_type { get; set; } public Vala.TargetValue? target_value { get; set; } public Vala.DataType value_type { get; set; } } [CCode (cheader_filename = "vala.h")] public class ExpressionStatement : Vala.CodeNode, Vala.Statement { public ExpressionStatement (Vala.Expression expression, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression expression { get; set; } } [CCode (cheader_filename = "vala.h")] public class Field : Vala.Variable, Vala.Lockable { public Field (string name, Vala.DataType variable_type, Vala.Expression? initializer, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.MemberBinding binding { get; set; } public bool is_volatile { get; set; } } [CCode (cheader_filename = "vala.h")] public class FieldPrototype : Vala.DataType { public FieldPrototype (Vala.Field field_symbol); public override Vala.DataType copy (); public override string to_qualified_string (Vala.Scope? scope); public Vala.Field field_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public class FloatingType : Vala.ValueType { public FloatingType (Vala.Struct type_symbol); public override Vala.DataType copy (); } [CCode (cheader_filename = "vala.h")] public class FlowAnalyzer : Vala.CodeVisitor { public FlowAnalyzer (); public void analyze (Vala.CodeContext context); public override void visit_block (Vala.Block b); public override void visit_break_statement (Vala.BreakStatement stmt); public override void visit_class (Vala.Class cl); public override void visit_continue_statement (Vala.ContinueStatement stmt); public override void visit_creation_method (Vala.CreationMethod m); public override void visit_declaration_statement (Vala.DeclarationStatement stmt); public override void visit_enum (Vala.Enum en); public override void visit_error_domain (Vala.ErrorDomain ed); public override void visit_expression (Vala.Expression expr); public override void visit_expression_statement (Vala.ExpressionStatement stmt); public override void visit_field (Vala.Field f); public override void visit_foreach_statement (Vala.ForeachStatement stmt); public override void visit_if_statement (Vala.IfStatement stmt); public override void visit_interface (Vala.Interface iface); public override void visit_lambda_expression (Vala.LambdaExpression le); public override void visit_local_variable (Vala.LocalVariable local); public override void visit_lock_statement (Vala.LockStatement stmt); public override void visit_loop (Vala.Loop stmt); public override void visit_method (Vala.Method m); public override void visit_property (Vala.Property prop); public override void visit_property_accessor (Vala.PropertyAccessor acc); public override void visit_return_statement (Vala.ReturnStatement stmt); public override void visit_signal (Vala.Signal sig); public override void visit_source_file (Vala.SourceFile source_file); public override void visit_struct (Vala.Struct st); public override void visit_switch_statement (Vala.SwitchStatement stmt); public override void visit_throw_statement (Vala.ThrowStatement stmt); public override void visit_try_statement (Vala.TryStatement stmt); public override void visit_unlock_statement (Vala.UnlockStatement stmt); public override void visit_yield_statement (Vala.YieldStatement stmt); } [CCode (cheader_filename = "vala.h")] public class ForStatement : Vala.CodeNode, Vala.Statement { public ForStatement (Vala.Expression? condition, Vala.Block body, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_initializer (Vala.Expression init); public void add_iterator (Vala.Expression iter); public override bool check (Vala.CodeContext context); public Vala.List get_initializer (); public Vala.List get_iterator (); public Vala.Block body { get; set; } public Vala.Expression? condition { get; set; } } [CCode (cheader_filename = "vala.h")] public class ForeachStatement : Vala.Block { public ForeachStatement (Vala.DataType? type_reference, string variable_name, Vala.Expression collection, Vala.Block body, Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.Block body { get; set; } public Vala.Expression collection { get; set; } public Vala.LocalVariable collection_variable { get; set; } public Vala.LocalVariable element_variable { get; set; } public Vala.LocalVariable iterator_variable { get; set; } public Vala.DataType? type_reference { get; set; } public bool use_iterator { get; private set; } public string variable_name { get; set; } } [CCode (cheader_filename = "vala.h")] public class GenericType : Vala.DataType { public GenericType (Vala.TypeParameter type_parameter); public override Vala.DataType copy (); public override Vala.Symbol? get_member (string member_name); public override Vala.DataType? infer_type_argument (Vala.TypeParameter type_param, Vala.DataType value_type); public override string to_qualified_string (Vala.Scope? scope = null); public Vala.TypeParameter type_parameter { get; set; } } [CCode (cheader_filename = "vala.h")] public class GirComment : Vala.Comment { public GirComment (string? comment, Vala.SourceReference _source_reference); public Vala.Comment? get_content_for_parameter (string name); public Vala.MapIterator parameter_iterator (); public Vala.Comment? return_content { get; set; } } [CCode (cheader_filename = "vala.h")] public class GirParser : Vala.CodeVisitor { public GirParser (); public void parse (Vala.CodeContext context); public void parse_file (Vala.SourceFile source_file); public override void visit_source_file (Vala.SourceFile source_file); } [CCode (cheader_filename = "vala.h")] public class IfStatement : Vala.CodeNode, Vala.Statement { public IfStatement (Vala.Expression cond, Vala.Block true_stmt, Vala.Block? false_stmt, Vala.SourceReference? source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression condition { get; set; } public Vala.Block? false_statement { get; set; } public Vala.Block true_statement { get; set; } } [CCode (cheader_filename = "vala.h")] public class InitializerList : Vala.Expression { public InitializerList (Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void append (Vala.Expression expr); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_initializers (); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_constant (); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public int size { get; } } [CCode (cheader_filename = "vala.h")] public class IntegerLiteral : Vala.Literal { public IntegerLiteral (string i, Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_pure (); public override string to_string (); public string type_suffix { get; set; } public string value { get; set; } } [CCode (cheader_filename = "vala.h")] public class IntegerType : Vala.ValueType { public IntegerType (Vala.Struct type_symbol, string? literal_value = null, string? literal_type_name = null); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); } [CCode (cheader_filename = "vala.h")] public class Interface : Vala.ObjectTypeSymbol { public Interface (string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override void add_class (Vala.Class cl); public override void add_constant (Vala.Constant c); public override void add_delegate (Vala.Delegate d); public override void add_enum (Vala.Enum en); public override void add_field (Vala.Field f); public override void add_method (Vala.Method m); public void add_prerequisite (Vala.DataType type); public override void add_property (Vala.Property prop); public override void add_signal (Vala.Signal sig); public override void add_struct (Vala.Struct st); public override bool check (Vala.CodeContext context); public Vala.List get_classes (); public Vala.List get_constants (); public Vala.List get_delegates (); public Vala.List get_enums (); public Vala.List get_fields (); public override Vala.List get_methods (); public Vala.List get_prerequisites (); public override Vala.List get_properties (); public override Vala.List get_signals (); public Vala.List get_structs (); public virtual Vala.List get_virtuals (); public override bool is_reference_type (); public override bool is_subtype_of (Vala.TypeSymbol t); public void prepend_prerequisite (Vala.DataType type); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); } [CCode (cheader_filename = "vala.h")] public class InterfaceType : Vala.ReferenceType { public InterfaceType (Vala.Interface interface_symbol); public override Vala.DataType copy (); public Vala.Interface interface_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public class InvalidType : Vala.DataType { public InvalidType (); public override Vala.DataType copy (); } [CCode (cheader_filename = "vala.h")] public class LambdaExpression : Vala.Expression { public LambdaExpression (Vala.Expression expression_body, Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_parameter (Vala.Parameter param); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_parameters (); public override void get_used_variables (Vala.Collection collection); public override bool is_pure (); public LambdaExpression.with_statement_body (Vala.Block statement_body, Vala.SourceReference source_reference); public Vala.Expression expression_body { get; set; } public Vala.Method method { get; set; } public Vala.Block statement_body { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class Literal : Vala.Expression { public Literal (); public override bool is_constant (); public override bool is_pure (); } [CCode (cheader_filename = "vala.h")] public class LocalVariable : Vala.Variable { public LocalVariable (Vala.DataType? variable_type, string name, Vala.Expression? initializer = null, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public bool captured { get; set; } public bool init { get; set; } public bool is_result { get; set; } } [CCode (cheader_filename = "vala.h")] public class LockStatement : Vala.CodeNode, Vala.Statement { public LockStatement (Vala.Expression resource, Vala.Block? body, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.Block? body { get; set; } public Vala.Expression resource { get; set; } } [CCode (cheader_filename = "vala.h")] public class Loop : Vala.CodeNode, Vala.Statement { public Loop (Vala.Block body, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.Block body { get; set; } } [CCode (cheader_filename = "vala.h")] public class MarkupReader { public MarkupReader (string filename); public MarkupReader.from_string (string filename, string content); public string? get_attribute (string attr); public Vala.Map get_attributes (); public Vala.MarkupTokenType read_token (out Vala.SourceLocation token_begin, out Vala.SourceLocation token_end); public string content { get; private set; } public string filename { get; private set; } public string name { get; private set; } } [CCode (cheader_filename = "vala.h")] public class MemberAccess : Vala.Expression { public MemberAccess (Vala.Expression? inner, string member_name, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_type_argument (Vala.DataType arg); public override bool check (Vala.CodeContext context); public void check_lvalue_access (); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public Vala.List get_type_arguments (); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_constant (); public override bool is_non_null (); public override bool is_pure (); public MemberAccess.pointer (Vala.Expression inner, string member_name, Vala.SourceReference? source_reference = null); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public MemberAccess.simple (string member_name, Vala.SourceReference? source_reference = null); public override string to_string (); public bool creation_member { get; set; } public Vala.Expression? inner { get; set; } public string member_name { get; set; } public bool pointer_member_access { get; set; } public bool prototype_access { get; set; } public bool qualified { get; set; } } [CCode (cheader_filename = "vala.h")] public class MemberInitializer : Vala.CodeNode { public MemberInitializer (string name, Vala.Expression initializer, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_used_variables (Vala.Collection collection); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression initializer { get; set; } public string name { get; set; } public Vala.Symbol symbol_reference { get; set; } } [CCode (cheader_filename = "vala.h")] public class Method : Vala.Subroutine, Vala.Callable { public Method (string? name, Vala.DataType return_type, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_captured_variable (Vala.LocalVariable local); public void add_postcondition (Vala.Expression postcondition); public void add_precondition (Vala.Expression precondition); public void add_type_parameter (Vala.TypeParameter p); public override bool check (Vala.CodeContext context); public void clear_parameters (); public bool compatible (Vala.Method base_method, out string? invalid_match); public Vala.List get_async_begin_parameters (); public Vala.List get_async_end_parameters (); public Vala.Method get_callback_method (); public void get_captured_variables (Vala.Collection variables); public override void get_defined_variables (Vala.Collection collection); public Vala.Method get_end_method (); public int get_format_arg_index (); public Vala.List get_postconditions (); public Vala.List get_preconditions (); public int get_required_arguments (); public int get_type_parameter_index (string name); public Vala.List get_type_parameters (); public bool is_variadic (); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.Method base_interface_method { get; } public Vala.DataType base_interface_type { get; set; } public Vala.Method base_method { get; } public Vala.MemberBinding binding { get; set; } public bool closure { get; set; } public bool coroutine { get; set; } public bool entry_point { get; private set; } public bool has_construct_function { get; set; } public override bool has_result { get; } public bool is_abstract { get; set; } public bool is_async_callback { get; set; } public bool is_inline { get; set; } public bool is_virtual { get; set; } public bool overrides { get; set; } public bool printf_format { get; set; } public bool returns_floating_reference { get; set; } public bool returns_modified_pointer { get; set; } public bool scanf_format { get; set; } public Vala.Signal signal_reference { get; set; } public Vala.Parameter this_parameter { get; set; } } [CCode (cheader_filename = "vala.h")] public class MethodCall : Vala.Expression { public MethodCall (Vala.Expression call, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_argument (Vala.Expression arg); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_argument_list (); public override void get_defined_variables (Vala.Collection collection); public Vala.StringLiteral? get_format_literal (); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_constant (); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression call { get; set; } public bool is_assert { get; private set; } public bool is_chainup { get; private set; } public bool is_constructv_chainup { get; private set; } public bool is_yield_expression { get; set; } } [CCode (cheader_filename = "vala.h")] public class MethodType : Vala.CallableType { public MethodType (Vala.Method method_symbol); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); public override Vala.Symbol? get_member (string member_name); public override Vala.List? get_parameters (); public override Vala.DataType? get_return_type (); public override bool is_invokable (); public override string to_qualified_string (Vala.Scope? scope); public Vala.Method method_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public class NamedArgument : Vala.Expression { public NamedArgument (string name, Vala.Expression inner, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression inner { get; set; } public string name { get; set; } } [CCode (cheader_filename = "vala.h")] public class Namespace : Vala.Symbol { public Namespace (string? name, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override void add_class (Vala.Class cl); public void add_comment (Vala.Comment comment); public override void add_constant (Vala.Constant constant); public override void add_delegate (Vala.Delegate d); public override void add_enum (Vala.Enum en); public override void add_error_domain (Vala.ErrorDomain edomain); public override void add_field (Vala.Field f); public override void add_interface (Vala.Interface iface); public override void add_method (Vala.Method m); public override void add_namespace (Vala.Namespace ns); public override void add_struct (Vala.Struct st); public void add_using_directive (Vala.UsingDirective ns); public override bool check (Vala.CodeContext context); public Vala.List get_classes (); public Vala.List get_comments (); public Vala.List get_constants (); public Vala.List get_delegates (); public Vala.List get_enums (); public Vala.List get_error_domains (); public Vala.List get_fields (); public Vala.List get_interfaces (); public Vala.List get_methods (); public Vala.List get_namespaces (); public Vala.List get_structs (); public void remove_struct (Vala.Struct st); } [CCode (cheader_filename = "vala.h")] public class NullLiteral : Vala.Literal { public NullLiteral (Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_pure (); public override string to_string (); } [CCode (cheader_filename = "vala.h")] public class NullType : Vala.ReferenceType { public NullType (Vala.SourceReference? source_reference); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); public override bool is_disposable (); public override string to_qualified_string (Vala.Scope? scope = null); } [CCode (cheader_filename = "vala.h")] public class ObjectCreationExpression : Vala.Expression { public ObjectCreationExpression (Vala.MemberAccess member_name, Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_argument (Vala.Expression arg); public void add_member_initializer (Vala.MemberInitializer init); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_argument_list (); public override void get_defined_variables (Vala.Collection collection); public Vala.List get_object_initializer (); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public bool is_yield_expression { get; set; } public Vala.MemberAccess member_name { get; set; } public bool struct_creation { get; set; } public Vala.DataType type_reference { get; set; } } [CCode (cheader_filename = "vala.h")] public class ObjectType : Vala.ReferenceType { public ObjectType (Vala.ObjectTypeSymbol type_symbol); public override bool check (Vala.CodeContext context); public override Vala.DataType copy (); public override Vala.List? get_parameters (); public override Vala.DataType? get_return_type (); public override bool is_invokable (); public override bool stricter (Vala.DataType target_type); public Vala.ObjectTypeSymbol type_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class ObjectTypeSymbol : Vala.TypeSymbol { public ObjectTypeSymbol (string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public void add_hidden_method (Vala.Method m); public void add_type_parameter (Vala.TypeParameter p); public abstract Vala.List get_methods (); public abstract Vala.List get_properties (); public abstract Vala.List get_signals (); public Vala.ObjectType get_this_type (); public override int get_type_parameter_index (string name); public Vala.List get_type_parameters (); } [CCode (cheader_filename = "vala.h")] public class Parameter : Vala.Variable { public Parameter (string name, Vala.DataType? variable_type, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public Vala.Parameter copy (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Parameter.with_ellipsis (Vala.SourceReference? source_reference = null); public Vala.Parameter base_parameter { get; set; } public bool captured { get; set; } public Vala.ParameterDirection direction { get; set; } public bool ellipsis { get; set; } public bool format_arg { get; } public bool params_array { get; set; } } [CCode (cheader_filename = "vala.h")] public class Parser : Vala.CodeVisitor { public Parser (); public void parse (Vala.CodeContext context); public void parse_file (Vala.SourceFile source_file); public override void visit_source_file (Vala.SourceFile source_file); } [CCode (cheader_filename = "vala.h")] public class PhiFunction { public PhiFunction (Vala.Variable variable, int num_of_ops); public Vala.List operands { get; private set; } public Vala.Variable original_variable { get; private set; } } [CCode (cheader_filename = "vala.h")] public class PointerIndirection : Vala.Expression { public PointerIndirection (Vala.Expression inner, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression inner { get; set; } } [CCode (cheader_filename = "vala.h")] public class PointerType : Vala.DataType { public PointerType (Vala.DataType base_type, Vala.SourceReference? source_reference = null); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); public override Vala.DataType get_actual_type (Vala.DataType? derived_instance_type, Vala.List? method_type_arguments, Vala.CodeNode node_reference); public override Vala.Symbol? get_member (string member_name); public override Vala.Symbol? get_pointer_member (string member_name); public override Vala.DataType? infer_type_argument (Vala.TypeParameter type_param, Vala.DataType value_type); public override bool is_accessible (Vala.Symbol sym); public override bool is_disposable (); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public override string to_qualified_string (Vala.Scope? scope); public Vala.DataType base_type { get; set; } } [CCode (cheader_filename = "vala.h")] public class PostfixExpression : Vala.Expression { public PostfixExpression (Vala.Expression _inner, bool inc, Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public bool increment { get; set; } public Vala.Expression inner { get; set; } } [CCode (cheader_filename = "vala.h")] public class Property : Vala.Symbol, Vala.Lockable { public Property (string name, Vala.DataType? property_type, Vala.PropertyAccessor? get_accessor, Vala.PropertyAccessor? set_accessor, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public bool compatible (Vala.Property base_property, out string? invalid_match); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.Property base_interface_property { get; } public Vala.Property base_property { get; } public Vala.MemberBinding binding { get; set; } public string blurb { get; } public Vala.Field field { get; set; } public Vala.PropertyAccessor? get_accessor { get; set; } public Vala.Expression initializer { get; set; } public bool interface_only { get; set; } public bool is_abstract { get; set; } public bool is_virtual { get; set; } public string nick { get; } public bool notify { get; } public bool overrides { get; set; } public Vala.DataType? property_type { get; set; } public Vala.PropertyAccessor? set_accessor { get; set; } public Vala.Parameter this_parameter { get; set; } } [CCode (cheader_filename = "vala.h")] public class PropertyAccessor : Vala.Subroutine { public PropertyAccessor (bool readable, bool writable, bool construction, Vala.DataType? value_type, Vala.Block? body, Vala.SourceReference? source_reference, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public Vala.Method? get_method (); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public bool automatic_body { get; private set; } public bool construction { get; private set; } public override bool has_result { get; } public Vala.Property prop { get; } public bool readable { get; private set; } public Vala.Parameter value_parameter { get; private set; } public Vala.DataType? value_type { get; private set; } public bool writable { get; private set; } } [CCode (cheader_filename = "vala.h")] public class RealLiteral : Vala.Literal { public RealLiteral (string r, Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public string get_type_name (); public override bool is_pure (); public override string to_string (); public string value { get; set; } } [CCode (cheader_filename = "vala.h")] public class ReferenceTransferExpression : Vala.Expression { public ReferenceTransferExpression (Vala.Expression inner, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression inner { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class ReferenceType : Vala.DataType { public ReferenceType (); } [CCode (cheader_filename = "vala.h")] public class RegexLiteral : Vala.Literal { public RegexLiteral (string value, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_non_null (); public override bool is_pure (); public override string to_string (); public string value { get; set; } } [CCode (cheader_filename = "vala.h")] public class Report { public enum Colored { AUTO, NEVER, ALWAYS } protected int errors; protected int warnings; public Report (); public virtual void depr (Vala.SourceReference? source, string message); public static void deprecated (Vala.SourceReference? source, string message); public virtual void err (Vala.SourceReference? source, string message); public static void error (Vala.SourceReference? source, string message); public static void experimental (Vala.SourceReference? source, string message); public int get_errors (); public int get_warnings (); public virtual void note (Vala.SourceReference? source, string message); public static void notice (Vala.SourceReference? source, string message); public bool set_colors (string str, Vala.Report.Colored colored_output = Report.Colored.AUTO); public void set_verbose_errors (bool verbose); public virtual void warn (Vala.SourceReference? source, string message); public static void warning (Vala.SourceReference? source, string message); public bool enable_warnings { get; set; } } [CCode (cheader_filename = "vala.h")] public class ReturnStatement : Vala.CodeNode, Vala.Statement { public ReturnStatement (Vala.Expression? return_expression = null, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression? return_expression { get; set; } } [CCode (cheader_filename = "vala.h")] public class Scanner { public Scanner (Vala.SourceFile source_file); public static Vala.TokenType get_identifier_or_keyword (char* begin, int len); public void parse_file_comments (); public Vala.Comment? pop_comment (); public Vala.TokenType read_regex_token (out Vala.SourceLocation token_begin, out Vala.SourceLocation token_end); public Vala.TokenType read_template_token (out Vala.SourceLocation token_begin, out Vala.SourceLocation token_end); public Vala.TokenType read_token (out Vala.SourceLocation token_begin, out Vala.SourceLocation token_end); public void seek (Vala.SourceLocation location); public Vala.SourceFile source_file { get; private set; } } [CCode (cheader_filename = "vala.h")] public class Scope { public Scope (Vala.Symbol? owner = null); public void add (string? name, Vala.Symbol sym); public Vala.Map get_symbol_table (); public bool is_subscope_of (Vala.Scope? scope); public Vala.Symbol? lookup (string name); public void remove (string name); public Vala.Symbol owner { get; set; } public Vala.Scope parent_scope { get; set; } } [CCode (cheader_filename = "vala.h")] public class SemanticAnalyzer : Vala.CodeVisitor { public Vala.DataType bool_type; public Vala.DataType double_type; public Vala.DataType error_type; public Vala.DataType garray_type; public Vala.Class gerror_type; public Vala.DataType glist_type; public Vala.DataType gslist_type; public Vala.Class gsource_type; public Vala.StructValueType gvalue_type; public Vala.DataType gvaluearray_type; public Vala.ObjectType gvariant_type; public Vala.Block insert_block; public Vala.DataType int8_type; public Vala.DataType int_type; public Vala.DataType list_type; public Vala.DataType long_type; public Vala.Class object_type; public Vala.DataType regex_type; public Vala.DataType short_type; public Vala.DataType size_t_type; public Vala.DataType ssize_t_type; public Vala.DataType string_type; public Vala.DataType tuple_type; public Vala.DataType type_type; public Vala.DataType uchar_type; public Vala.DataType uint_type; public Vala.DataType ulong_type; public Vala.DataType unichar_type; public Vala.DataType ushort_type; public Vala.DataType va_list_type; public Vala.DataType void_type; public SemanticAnalyzer (); public void add_replaced_node (Vala.CodeNode node); public void analyze (Vala.CodeContext context); public bool check_arguments (Vala.Expression expr, Vala.DataType mtype, Vala.List @params, Vala.List args); public bool check_print_format (string format, Vala.Iterator arg_it, Vala.SourceReference source_reference); public bool check_variadic_arguments (Vala.Iterator? arg_it, int i, Vala.SourceReference source_reference); public static Vala.Expression create_temp_access (Vala.LocalVariable local, Vala.DataType? target_type); public Vala.Method? find_current_method (); public Vala.Method? find_parent_method (Vala.Symbol sym); public Vala.Symbol? find_parent_method_or_property_accessor (Vala.Symbol sym); public static Vala.DataType get_actual_type (Vala.DataType? derived_instance_type, Vala.List? method_type_arguments, Vala.GenericType generic_type, Vala.CodeNode node_reference); public Vala.DataType? get_arithmetic_result_type (Vala.DataType left_type, Vala.DataType right_type); public static Vala.DataType get_data_type_for_symbol (Vala.Symbol sym); public static Vala.Symbol? get_symbol_for_data_type (Vala.DataType type); public Vala.DataType? get_value_type_for_symbol (Vala.Symbol sym, bool lvalue); public bool is_in_constructor (); public bool is_in_destructor (); public bool is_in_instance_method (); public bool is_type_accessible (Vala.Symbol sym, Vala.DataType type); public static Vala.Symbol? symbol_lookup_inherited (Vala.Symbol sym, string name); public void visit_member_initializer (Vala.MemberInitializer init, Vala.DataType type); public override void visit_source_file (Vala.SourceFile file); public Vala.Method? current_async_method { get; } public Vala.Class? current_class { get; } public Vala.Method? current_method { get; } public Vala.Symbol? current_method_or_property_accessor { get; } public Vala.PropertyAccessor? current_property_accessor { get; } public Vala.DataType? current_return_type { get; } public Vala.SourceFile current_source_file { get; set; } public Vala.Struct? current_struct { get; } public Vala.Symbol current_symbol { get; set; } public Vala.TypeSymbol? current_type_symbol { get; } } [CCode (cheader_filename = "vala.h")] public class Signal : Vala.Symbol, Vala.Lockable, Vala.Callable { public Signal (string name, Vala.DataType return_type, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public Vala.Delegate get_delegate (Vala.DataType sender_type, Vala.CodeNode node_reference); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.Block body { get; set; } public Vala.Method default_handler { get; private set; } public Vala.Method emitter { get; private set; } public bool is_virtual { get; set; } } [CCode (cheader_filename = "vala.h")] public class SignalType : Vala.CallableType { public SignalType (Vala.Signal signal_symbol); public override bool compatible (Vala.DataType target_type); public override Vala.DataType copy (); public Vala.DelegateType get_handler_type (); public override Vala.Symbol? get_member (string member_name); public override Vala.List? get_parameters (); public override Vala.DataType? get_return_type (); public override bool is_accessible (Vala.Symbol sym); public override bool is_invokable (); public override string to_qualified_string (Vala.Scope? scope); public Vala.Signal signal_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public class SizeofExpression : Vala.Expression { public SizeofExpression (Vala.DataType type, Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_constant (); public override bool is_pure (); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.DataType type_reference { get; set; } } [CCode (cheader_filename = "vala.h")] public class SliceExpression : Vala.Expression { public SliceExpression (Vala.Expression container, Vala.Expression start, Vala.Expression stop, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression container { get; set; } public Vala.Expression start { get; private set; } public Vala.Expression stop { get; private set; } } [CCode (cheader_filename = "vala.h")] public class SourceFile { public SourceFile (Vala.CodeContext context, Vala.SourceFileType type, string filename, string? content = null, bool cmdline = false); public void accept (Vala.CodeVisitor visitor); public void accept_children (Vala.CodeVisitor visitor); public void add_comment (Vala.Comment comment); public void add_node (Vala.CodeNode node); public void add_using_directive (Vala.UsingDirective ns); public bool check (Vala.CodeContext context); public string get_cinclude_filename (); public Vala.List get_comments (); public string get_csource_filename (); public char* get_mapped_contents (); public size_t get_mapped_length (); public Vala.List get_nodes (); public string get_relative_filename (); public string? get_source_line (int lineno); public void remove_node (Vala.CodeNode node); public string? content { get; set; } public Vala.CodeContext context { get; set; } public Vala.List current_using_directives { get; set; } public bool explicit { get; set; } public Vala.SourceFileType file_type { get; set; } public string filename { get; set; } public bool from_commandline { get; set; } public string gir_namespace { get; set; } public string gir_version { get; set; } public string? installed_version { get; set; } public string? package_name { get; set; } public string? relative_filename { set; } public bool used { get; set; } } [CCode (cheader_filename = "vala.h")] public class SourceReference { public SourceReference (Vala.SourceFile _file, Vala.SourceLocation begin, Vala.SourceLocation end); public string to_string (); public Vala.SourceLocation begin { get; set; } public Vala.SourceLocation end { get; set; } public Vala.SourceFile file { get; set; } public Vala.List using_directives { get; private set; } } [CCode (cheader_filename = "vala.h")] public class StatementList : Vala.CodeNode, Vala.Statement { public StatementList (Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public void add (Vala.Statement stmt); public override void emit (Vala.CodeGenerator codegen); public Vala.Statement @get (int index); public void insert (int index, Vala.Statement stmt); public void @set (int index, Vala.Statement stmt); public int length { get; } } [CCode (cheader_filename = "vala.h")] public class StringLiteral : Vala.Literal { public StringLiteral (string value, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public string? eval (); public static Vala.StringLiteral? get_format_literal (Vala.Expression expr); public override bool is_non_null (); public override bool is_pure (); public override string to_string (); public bool translate { get; set; } public string value { get; set; } } [CCode (cheader_filename = "vala.h")] public class Struct : Vala.TypeSymbol { public Struct (string name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override void add_constant (Vala.Constant c); public override void add_field (Vala.Field f); public override void add_method (Vala.Method m); public override void add_property (Vala.Property prop); public void add_type_parameter (Vala.TypeParameter p); public override bool check (Vala.CodeContext context); public Vala.List get_constants (); public Vala.List get_fields (); public Vala.List get_methods (); public Vala.List get_properties (); public int get_rank (); public override int get_type_parameter_index (string name); public Vala.List get_type_parameters (); public bool is_boolean_type (); public bool is_decimal_floating_type (); public bool is_disposable (); public bool is_floating_type (); public bool is_integer_type (); public bool is_simple_type (); public override bool is_subtype_of (Vala.TypeSymbol t); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public void set_rank (int rank); public void set_simple_type (bool simple_type); public Vala.Struct? base_struct { get; } public Vala.DataType? base_type { get; set; } public Vala.Method default_construction_method { get; set; } public bool is_immutable { get; set; } public bool signed { get; set; } public int width { get; set; } } [CCode (cheader_filename = "vala.h")] public class StructValueType : Vala.ValueType { public StructValueType (Vala.Struct type_symbol); public override Vala.DataType copy (); public override Vala.List? get_parameters (); public override Vala.DataType? get_return_type (); public override bool is_invokable (); } [CCode (cheader_filename = "vala.h")] public abstract class Subroutine : Vala.Symbol { protected Subroutine (string? name, Vala.SourceReference? source_reference, Vala.Comment? comment = null); public Vala.Block body { get; set; } public Vala.BasicBlock entry_block { get; set; } public Vala.BasicBlock exit_block { get; set; } public abstract bool has_result { get; } public Vala.LocalVariable result_var { get; set; } public Vala.BasicBlock return_block { get; set; } } [CCode (cheader_filename = "vala.h")] public class SwitchLabel : Vala.CodeNode { public SwitchLabel (Vala.Expression expr, Vala.SourceReference? source = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public SwitchLabel.with_default (Vala.SourceReference? source = null); public Vala.Expression expression { get; set; } public Vala.SwitchSection section { get; set; } } [CCode (cheader_filename = "vala.h")] public class SwitchSection : Vala.Block { public SwitchSection (Vala.SourceReference? source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_label (Vala.SwitchLabel label); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_labels (); public bool has_default_label (); } [CCode (cheader_filename = "vala.h")] public class SwitchStatement : Vala.CodeNode, Vala.Statement { public SwitchStatement (Vala.Expression expression, Vala.SourceReference? source_reference); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_section (Vala.SwitchSection section); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_sections (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression expression { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class Symbol : Vala.CodeNode { public Symbol (string? name, Vala.SourceReference? source_reference, Vala.Comment? comment = null); public virtual void add_class (Vala.Class cl); public virtual void add_constant (Vala.Constant constant); public virtual void add_constructor (Vala.Constructor c); public virtual void add_delegate (Vala.Delegate d); public virtual void add_destructor (Vala.Destructor d); public virtual void add_enum (Vala.Enum en); public virtual void add_error_domain (Vala.ErrorDomain edomain); public virtual void add_field (Vala.Field f); public virtual void add_interface (Vala.Interface iface); public virtual void add_method (Vala.Method m); public virtual void add_namespace (Vala.Namespace ns); public virtual void add_property (Vala.Property prop); public virtual void add_signal (Vala.Signal sig); public virtual void add_struct (Vala.Struct st); public static string camel_case_to_lower_case (string camel_case); public string get_full_name (); public Vala.Symbol? get_hidden_member (); public Vala.Scope? get_top_accessible_scope (bool is_internal = false); public bool is_accessible (Vala.Symbol sym); public virtual bool is_class_member (); public virtual bool is_instance_member (); public bool is_internal_symbol (); public bool is_private_symbol (); public static string lower_case_to_camel_case (string lower_case); public Vala.SymbolAccessibility access { get; set; } public bool active { get; set; } public Vala.Comment? comment { get; set; } public bool external { get; set; } public bool external_package { get; } public bool from_commandline { get; } public bool hides { get; set; } public string? name { get; set; } public Vala.Scope owner { get; set; } public Vala.Symbol? parent_symbol { get; } public Vala.Scope scope { get; } public Vala.SourceFileType source_type { get; } public bool used { get; set; } public Vala.VersionAttribute version { get; } } [CCode (cheader_filename = "vala.h")] public class SymbolResolver : Vala.CodeVisitor { public SymbolResolver (); public void resolve (Vala.CodeContext context); public override void visit_addressof_expression (Vala.AddressofExpression expr); public override void visit_array_creation_expression (Vala.ArrayCreationExpression e); public override void visit_assignment (Vala.Assignment a); public override void visit_binary_expression (Vala.BinaryExpression expr); public override void visit_block (Vala.Block b); public override void visit_cast_expression (Vala.CastExpression expr); public override void visit_catch_clause (Vala.CatchClause clause); public override void visit_class (Vala.Class cl); public override void visit_conditional_expression (Vala.ConditionalExpression expr); public override void visit_constant (Vala.Constant c); public override void visit_constructor (Vala.Constructor c); public override void visit_creation_method (Vala.CreationMethod m); public override void visit_data_type (Vala.DataType data_type); public override void visit_declaration_statement (Vala.DeclarationStatement stmt); public override void visit_delegate (Vala.Delegate cb); public override void visit_delete_statement (Vala.DeleteStatement stmt); public override void visit_destructor (Vala.Destructor d); public override void visit_do_statement (Vala.DoStatement stmt); public override void visit_element_access (Vala.ElementAccess expr); public override void visit_enum (Vala.Enum en); public override void visit_error_domain (Vala.ErrorDomain ed); public override void visit_expression_statement (Vala.ExpressionStatement stmt); public override void visit_field (Vala.Field f); public override void visit_for_statement (Vala.ForStatement stmt); public override void visit_foreach_statement (Vala.ForeachStatement stmt); public override void visit_formal_parameter (Vala.Parameter p); public override void visit_if_statement (Vala.IfStatement stmt); public override void visit_initializer_list (Vala.InitializerList list); public override void visit_interface (Vala.Interface iface); public override void visit_lambda_expression (Vala.LambdaExpression l); public override void visit_local_variable (Vala.LocalVariable local); public override void visit_loop (Vala.Loop stmt); public override void visit_member_access (Vala.MemberAccess expr); public override void visit_method (Vala.Method m); public override void visit_method_call (Vala.MethodCall expr); public override void visit_named_argument (Vala.NamedArgument expr); public override void visit_namespace (Vala.Namespace ns); public override void visit_object_creation_expression (Vala.ObjectCreationExpression expr); public override void visit_postfix_expression (Vala.PostfixExpression expr); public override void visit_property (Vala.Property prop); public override void visit_property_accessor (Vala.PropertyAccessor acc); public override void visit_reference_transfer_expression (Vala.ReferenceTransferExpression expr); public override void visit_return_statement (Vala.ReturnStatement stmt); public override void visit_signal (Vala.Signal sig); public override void visit_sizeof_expression (Vala.SizeofExpression expr); public override void visit_slice_expression (Vala.SliceExpression expr); public override void visit_struct (Vala.Struct st); public override void visit_switch_label (Vala.SwitchLabel label); public override void visit_switch_section (Vala.SwitchSection section); public override void visit_switch_statement (Vala.SwitchStatement stmt); public override void visit_template (Vala.Template tmpl); public override void visit_throw_statement (Vala.ThrowStatement stmt); public override void visit_try_statement (Vala.TryStatement stmt); public override void visit_tuple (Vala.Tuple tuple); public override void visit_type_check (Vala.TypeCheck expr); public override void visit_typeof_expression (Vala.TypeofExpression expr); public override void visit_unary_expression (Vala.UnaryExpression expr); public override void visit_using_directive (Vala.UsingDirective ns); public override void visit_while_statement (Vala.WhileStatement stmt); public override void visit_yield_statement (Vala.YieldStatement stmt); } [CCode (cheader_filename = "vala.h")] public abstract class TargetValue { protected TargetValue (Vala.DataType? value_type); public Vala.DataType? actual_value_type { get; set; } public Vala.DataType? value_type { get; set; } } [CCode (cheader_filename = "vala.h")] public class Template : Vala.Expression { public Template (Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_expression (Vala.Expression expr); public override bool check (Vala.CodeContext context); public Vala.List get_expressions (); public override bool is_pure (); } [CCode (cheader_filename = "vala.h")] public class ThrowStatement : Vala.CodeNode, Vala.Statement { public ThrowStatement (Vala.Expression error_expression, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression error_expression { get; set; } } [CCode (cheader_filename = "vala.h")] public class TryStatement : Vala.CodeNode, Vala.Statement { public TryStatement (Vala.Block body, Vala.Block? finally_body, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_catch_clause (Vala.CatchClause clause); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_catch_clauses (); public bool after_try_block_reachable { get; set; } public Vala.Block body { get; set; } public Vala.Block? finally_body { get; set; } } [CCode (cheader_filename = "vala.h")] public class Tuple : Vala.Expression { public Tuple (Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public void add_expression (Vala.Expression expr); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.List get_expressions (); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); } [CCode (cheader_filename = "vala.h")] public class TypeCheck : Vala.Expression { public TypeCheck (Vala.Expression expr, Vala.DataType type, Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.Expression expression { get; set; } public Vala.DataType type_reference { get; set; } } [CCode (cheader_filename = "vala.h")] public class TypeParameter : Vala.Symbol { public TypeParameter (string name, Vala.SourceReference source_reference); public override void accept (Vala.CodeVisitor visitor); public bool equals (Vala.TypeParameter param2); } [CCode (cheader_filename = "vala.h")] public abstract class TypeSymbol : Vala.Symbol { public TypeSymbol (string? name, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public virtual int get_type_parameter_index (string name); public virtual bool is_reference_type (); public virtual bool is_subtype_of (Vala.TypeSymbol t); } [CCode (cheader_filename = "vala.h")] public class TypeofExpression : Vala.Expression { public TypeofExpression (Vala.DataType type, Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override bool is_pure (); public override void replace_type (Vala.DataType old_type, Vala.DataType new_type); public Vala.DataType type_reference { get; set; } } [CCode (cheader_filename = "vala.h")] public class UnaryExpression : Vala.Expression { public UnaryExpression (Vala.UnaryOperator op, Vala.Expression _inner, Vala.SourceReference source); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void get_defined_variables (Vala.Collection collection); public override void get_used_variables (Vala.Collection collection); public override bool is_accessible (Vala.Symbol sym); public override bool is_constant (); public override bool is_pure (); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public override string to_string (); public Vala.Expression inner { get; set; } public Vala.UnaryOperator operator { get; set; } } [CCode (cheader_filename = "vala.h")] public class UnlockStatement : Vala.CodeNode, Vala.Statement { public UnlockStatement (Vala.Expression resource, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public Vala.Expression resource { get; set; } } [CCode (cheader_filename = "vala.h")] public class UnresolvedSymbol : Vala.Symbol { public UnresolvedSymbol (Vala.UnresolvedSymbol? inner, string name, Vala.SourceReference? source_reference = null); public Vala.UnresolvedSymbol copy (); public static Vala.UnresolvedSymbol? new_from_expression (Vala.Expression expr); public override string to_string (); public Vala.UnresolvedSymbol? inner { get; set; } public bool qualified { get; set; } } [CCode (cheader_filename = "vala.h")] public class UnresolvedType : Vala.DataType { public UnresolvedType (); public override Vala.DataType copy (); public UnresolvedType.from_symbol (Vala.UnresolvedSymbol symbol, Vala.SourceReference? source = null); public override bool is_disposable (); public static Vala.UnresolvedType? new_from_expression (Vala.Expression expr); public override string to_qualified_string (Vala.Scope? scope); public Vala.UnresolvedSymbol unresolved_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public class UsedAttr : Vala.CodeVisitor { public Vala.Map> marked; public UsedAttr (); public void check_unused (Vala.CodeContext context); public void mark (string attribute, string? argument); public override void visit_class (Vala.Class cl); public override void visit_constant (Vala.Constant c); public override void visit_creation_method (Vala.CreationMethod m); public override void visit_delegate (Vala.Delegate cb); public override void visit_enum (Vala.Enum en); public override void visit_error_domain (Vala.ErrorDomain ed); public override void visit_field (Vala.Field f); public override void visit_formal_parameter (Vala.Parameter p); public override void visit_interface (Vala.Interface iface); public override void visit_method (Vala.Method m); public override void visit_namespace (Vala.Namespace ns); public override void visit_property (Vala.Property prop); public override void visit_signal (Vala.Signal sig); public override void visit_struct (Vala.Struct st); } [CCode (cheader_filename = "vala.h")] public class UsingDirective : Vala.CodeNode { public UsingDirective (Vala.Symbol namespace_symbol, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public Vala.Symbol namespace_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public abstract class ValueType : Vala.DataType { public ValueType (Vala.TypeSymbol type_symbol); public override bool check (Vala.CodeContext context); public override bool is_disposable (); public Vala.TypeSymbol type_symbol { get; set; } } [CCode (cheader_filename = "vala.h")] public class Variable : Vala.Symbol { public Variable (Vala.DataType? variable_type, string? name, Vala.Expression? initializer = null, Vala.SourceReference? source_reference = null, Vala.Comment? comment = null); public Vala.Expression? initializer { get; set; } public bool single_assignment { get; set; } public Vala.DataType? variable_type { get; set; } } [CCode (cheader_filename = "vala.h")] public class VersionAttribute { public VersionAttribute (Vala.Symbol symbol); public bool check (Vala.SourceReference? source_ref = null); public static int cmp_versions (string v1str, string v2str); public bool deprecated { get; set; } public string? deprecated_since { owned get; set; } public bool experimental { get; set; } public string? experimental_until { owned get; set; } public string? replacement { owned get; set; } public string? since { owned get; set; } } [CCode (cheader_filename = "vala.h")] public class VoidType : Vala.DataType { public VoidType (Vala.SourceReference? source_reference = null); public override Vala.DataType copy (); public override bool stricter (Vala.DataType type2); public override string to_qualified_string (Vala.Scope? scope); } [CCode (cheader_filename = "vala.h")] public class WhileStatement : Vala.CodeNode, Vala.Statement { public WhileStatement (Vala.Expression condition, Vala.Block body, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public Vala.Block body { get; set; } public Vala.Expression condition { get; set; } } [CCode (cheader_filename = "vala.h")] public class YieldStatement : Vala.CodeNode, Vala.Statement { public YieldStatement (Vala.Expression? yield_expression, Vala.SourceReference? source_reference = null); public override void accept (Vala.CodeVisitor visitor); public override void accept_children (Vala.CodeVisitor visitor); public override bool check (Vala.CodeContext context); public override void emit (Vala.CodeGenerator codegen); public override void replace_expression (Vala.Expression old_node, Vala.Expression new_node); public Vala.Expression? yield_expression { get; set; } } [CCode (cheader_filename = "vala.h")] public interface Callable : Vala.CodeNode { public abstract void add_parameter (Vala.Parameter param); public abstract Vala.List get_parameters (); public abstract Vala.DataType return_type { get; set; } } [CCode (cheader_filename = "vala.h")] public interface Lockable { public abstract bool get_lock_used (); public abstract void set_lock_used (bool used); } [CCode (cheader_filename = "vala.h")] public interface Statement : Vala.CodeNode { } [CCode (cheader_filename = "vala.h")] public struct SourceLocation { public char* pos; public int line; public int column; public SourceLocation (char* _pos, int _line, int _column); } [CCode (cheader_filename = "vala.h")] public enum AssignmentOperator { NONE, SIMPLE, BITWISE_OR, BITWISE_AND, BITWISE_XOR, ADD, SUB, MUL, DIV, PERCENT, SHIFT_LEFT, SHIFT_RIGHT } [CCode (cheader_filename = "vala.h")] public enum BinaryOperator { NONE, PLUS, MINUS, MUL, DIV, MOD, SHIFT_LEFT, SHIFT_RIGHT, LESS_THAN, GREATER_THAN, LESS_THAN_OR_EQUAL, GREATER_THAN_OR_EQUAL, EQUALITY, INEQUALITY, BITWISE_AND, BITWISE_OR, BITWISE_XOR, AND, OR, IN, COALESCE } [CCode (cheader_filename = "vala.h")] public enum CodeWriterType { EXTERNAL, INTERNAL, FAST, DUMP } [CCode (cheader_filename = "vala.h")] public enum MarkupTokenType { NONE, START_ELEMENT, END_ELEMENT, TEXT, EOF; public unowned string to_string (); } [CCode (cheader_filename = "vala.h")] public enum MemberBinding { INSTANCE, CLASS, STATIC } [CCode (cheader_filename = "vala.h")] public enum ParameterDirection { IN, OUT, REF } [CCode (cheader_filename = "vala.h")] public enum Profile { GOBJECT } [CCode (cheader_filename = "vala.h")] public enum SourceFileType { NONE, SOURCE, PACKAGE, FAST } [CCode (cheader_filename = "vala.h")] public enum SymbolAccessibility { PRIVATE, INTERNAL, PROTECTED, PUBLIC } [CCode (cheader_filename = "vala.h")] public enum TokenType { NONE, ABSTRACT, AS, ASSIGN, ASSIGN_ADD, ASSIGN_BITWISE_AND, ASSIGN_BITWISE_OR, ASSIGN_BITWISE_XOR, ASSIGN_DIV, ASSIGN_MUL, ASSIGN_PERCENT, ASSIGN_SHIFT_LEFT, ASSIGN_SUB, ASYNC, BASE, BITWISE_AND, BITWISE_OR, BREAK, CARRET, CASE, CATCH, CHARACTER_LITERAL, CLASS, CLOSE_BRACE, CLOSE_BRACKET, CLOSE_PARENS, CLOSE_REGEX_LITERAL, CLOSE_TEMPLATE, COLON, COMMA, CONST, CONSTRUCT, CONTINUE, DEFAULT, DELEGATE, DELETE, DIV, DO, DOUBLE_COLON, DOT, DYNAMIC, ELLIPSIS, ELSE, ENUM, ENSURES, ERRORDOMAIN, EOF, EXTERN, FALSE, FINALLY, FOR, FOREACH, GET, HASH, IDENTIFIER, IF, IN, INLINE, INTEGER_LITERAL, INTERFACE, INTERNAL, INTERR, IS, LAMBDA, LOCK, MINUS, NAMESPACE, NEW, NULL, OUT, OP_AND, OP_COALESCING, OP_DEC, OP_EQ, OP_GE, OP_GT, OP_INC, OP_LE, OP_LT, OP_NE, OP_NEG, OP_OR, OP_PTR, OP_SHIFT_LEFT, OPEN_BRACE, OPEN_BRACKET, OPEN_PARENS, OPEN_REGEX_LITERAL, OPEN_TEMPLATE, OVERRIDE, OWNED, PARAMS, PERCENT, PLUS, PRIVATE, PROTECTED, PUBLIC, REAL_LITERAL, REF, REGEX_LITERAL, REQUIRES, RETURN, SEALED, SEMICOLON, SET, SIGNAL, SIZEOF, STAR, STATIC, STRING_LITERAL, STRUCT, SWITCH, TEMPLATE_STRING_LITERAL, THIS, THROW, THROWS, TILDE, TRUE, TRY, TYPEOF, UNOWNED, USING, VAR, VERBATIM_STRING_LITERAL, VIRTUAL, VOID, VOLATILE, WEAK, WHILE, YIELD; public unowned string to_string (); } [CCode (cheader_filename = "vala.h")] public enum UnaryOperator { NONE, PLUS, MINUS, LOGICAL_NEGATION, BITWISE_COMPLEMENT, INCREMENT, DECREMENT, REF, OUT } [CCode (cheader_filename = "vala.h")] public errordomain ParseError { FAILED, SYNTAX } } valabind-1.5.0/private/valaccode.h000066400000000000000000003026571323123274000170530ustar00rootroot00000000000000/* valaccode.h generated by valac, the Vala compiler, do not modify */ #ifndef __VALACCODE_H__ #define __VALACCODE_H__ #include #include #include #include #include G_BEGIN_DECLS #define VALA_TYPE_CCODE_NODE (vala_ccode_node_get_type ()) #define VALA_CCODE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_NODE, ValaCCodeNode)) #define VALA_CCODE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_NODE, ValaCCodeNodeClass)) #define VALA_IS_CCODE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_NODE)) #define VALA_IS_CCODE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_NODE)) #define VALA_CCODE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_NODE, ValaCCodeNodeClass)) typedef struct _ValaCCodeNode ValaCCodeNode; typedef struct _ValaCCodeNodeClass ValaCCodeNodeClass; typedef struct _ValaCCodeNodePrivate ValaCCodeNodePrivate; #define VALA_TYPE_CCODE_WRITER (vala_ccode_writer_get_type ()) #define VALA_CCODE_WRITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_WRITER, ValaCCodeWriter)) #define VALA_CCODE_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_WRITER, ValaCCodeWriterClass)) #define VALA_IS_CCODE_WRITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_WRITER)) #define VALA_IS_CCODE_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_WRITER)) #define VALA_CCODE_WRITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_WRITER, ValaCCodeWriterClass)) typedef struct _ValaCCodeWriter ValaCCodeWriter; typedef struct _ValaCCodeWriterClass ValaCCodeWriterClass; #define VALA_TYPE_CCODE_EXPRESSION (vala_ccode_expression_get_type ()) #define VALA_CCODE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression)) #define VALA_CCODE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpressionClass)) #define VALA_IS_CCODE_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_EXPRESSION)) #define VALA_IS_CCODE_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_EXPRESSION)) #define VALA_CCODE_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpressionClass)) typedef struct _ValaCCodeExpression ValaCCodeExpression; typedef struct _ValaCCodeExpressionClass ValaCCodeExpressionClass; typedef struct _ValaCCodeExpressionPrivate ValaCCodeExpressionPrivate; #define VALA_TYPE_CCODE_ASSIGNMENT (vala_ccode_assignment_get_type ()) #define VALA_CCODE_ASSIGNMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ASSIGNMENT, ValaCCodeAssignment)) #define VALA_CCODE_ASSIGNMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ASSIGNMENT, ValaCCodeAssignmentClass)) #define VALA_IS_CCODE_ASSIGNMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ASSIGNMENT)) #define VALA_IS_CCODE_ASSIGNMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ASSIGNMENT)) #define VALA_CCODE_ASSIGNMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ASSIGNMENT, ValaCCodeAssignmentClass)) typedef struct _ValaCCodeAssignment ValaCCodeAssignment; typedef struct _ValaCCodeAssignmentClass ValaCCodeAssignmentClass; typedef struct _ValaCCodeAssignmentPrivate ValaCCodeAssignmentPrivate; #define VALA_TYPE_CCODE_ASSIGNMENT_OPERATOR (vala_ccode_assignment_operator_get_type ()) #define VALA_TYPE_CCODE_BINARY_EXPRESSION (vala_ccode_binary_expression_get_type ()) #define VALA_CCODE_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_BINARY_EXPRESSION, ValaCCodeBinaryExpression)) #define VALA_CCODE_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_BINARY_EXPRESSION, ValaCCodeBinaryExpressionClass)) #define VALA_IS_CCODE_BINARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_BINARY_EXPRESSION)) #define VALA_IS_CCODE_BINARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_BINARY_EXPRESSION)) #define VALA_CCODE_BINARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_BINARY_EXPRESSION, ValaCCodeBinaryExpressionClass)) typedef struct _ValaCCodeBinaryExpression ValaCCodeBinaryExpression; typedef struct _ValaCCodeBinaryExpressionClass ValaCCodeBinaryExpressionClass; typedef struct _ValaCCodeBinaryExpressionPrivate ValaCCodeBinaryExpressionPrivate; #define VALA_TYPE_CCODE_BINARY_OPERATOR (vala_ccode_binary_operator_get_type ()) #define VALA_TYPE_CCODE_STATEMENT (vala_ccode_statement_get_type ()) #define VALA_CCODE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_STATEMENT, ValaCCodeStatement)) #define VALA_CCODE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_STATEMENT, ValaCCodeStatementClass)) #define VALA_IS_CCODE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_STATEMENT)) #define VALA_IS_CCODE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_STATEMENT)) #define VALA_CCODE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_STATEMENT, ValaCCodeStatementClass)) typedef struct _ValaCCodeStatement ValaCCodeStatement; typedef struct _ValaCCodeStatementClass ValaCCodeStatementClass; typedef struct _ValaCCodeStatementPrivate ValaCCodeStatementPrivate; #define VALA_TYPE_CCODE_BLOCK (vala_ccode_block_get_type ()) #define VALA_CCODE_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_BLOCK, ValaCCodeBlock)) #define VALA_CCODE_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_BLOCK, ValaCCodeBlockClass)) #define VALA_IS_CCODE_BLOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_BLOCK)) #define VALA_IS_CCODE_BLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_BLOCK)) #define VALA_CCODE_BLOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_BLOCK, ValaCCodeBlockClass)) typedef struct _ValaCCodeBlock ValaCCodeBlock; typedef struct _ValaCCodeBlockClass ValaCCodeBlockClass; typedef struct _ValaCCodeBlockPrivate ValaCCodeBlockPrivate; #define VALA_TYPE_CCODE_BREAK_STATEMENT (vala_ccode_break_statement_get_type ()) #define VALA_CCODE_BREAK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_BREAK_STATEMENT, ValaCCodeBreakStatement)) #define VALA_CCODE_BREAK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_BREAK_STATEMENT, ValaCCodeBreakStatementClass)) #define VALA_IS_CCODE_BREAK_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_BREAK_STATEMENT)) #define VALA_IS_CCODE_BREAK_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_BREAK_STATEMENT)) #define VALA_CCODE_BREAK_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_BREAK_STATEMENT, ValaCCodeBreakStatementClass)) typedef struct _ValaCCodeBreakStatement ValaCCodeBreakStatement; typedef struct _ValaCCodeBreakStatementClass ValaCCodeBreakStatementClass; typedef struct _ValaCCodeBreakStatementPrivate ValaCCodeBreakStatementPrivate; #define VALA_TYPE_CCODE_CASE_STATEMENT (vala_ccode_case_statement_get_type ()) #define VALA_CCODE_CASE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CASE_STATEMENT, ValaCCodeCaseStatement)) #define VALA_CCODE_CASE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CASE_STATEMENT, ValaCCodeCaseStatementClass)) #define VALA_IS_CCODE_CASE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CASE_STATEMENT)) #define VALA_IS_CCODE_CASE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CASE_STATEMENT)) #define VALA_CCODE_CASE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CASE_STATEMENT, ValaCCodeCaseStatementClass)) typedef struct _ValaCCodeCaseStatement ValaCCodeCaseStatement; typedef struct _ValaCCodeCaseStatementClass ValaCCodeCaseStatementClass; typedef struct _ValaCCodeCaseStatementPrivate ValaCCodeCaseStatementPrivate; #define VALA_TYPE_CCODE_CAST_EXPRESSION (vala_ccode_cast_expression_get_type ()) #define VALA_CCODE_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CAST_EXPRESSION, ValaCCodeCastExpression)) #define VALA_CCODE_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CAST_EXPRESSION, ValaCCodeCastExpressionClass)) #define VALA_IS_CCODE_CAST_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CAST_EXPRESSION)) #define VALA_IS_CCODE_CAST_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CAST_EXPRESSION)) #define VALA_CCODE_CAST_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CAST_EXPRESSION, ValaCCodeCastExpressionClass)) typedef struct _ValaCCodeCastExpression ValaCCodeCastExpression; typedef struct _ValaCCodeCastExpressionClass ValaCCodeCastExpressionClass; typedef struct _ValaCCodeCastExpressionPrivate ValaCCodeCastExpressionPrivate; #define VALA_TYPE_CCODE_COMMA_EXPRESSION (vala_ccode_comma_expression_get_type ()) #define VALA_CCODE_COMMA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_COMMA_EXPRESSION, ValaCCodeCommaExpression)) #define VALA_CCODE_COMMA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_COMMA_EXPRESSION, ValaCCodeCommaExpressionClass)) #define VALA_IS_CCODE_COMMA_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_COMMA_EXPRESSION)) #define VALA_IS_CCODE_COMMA_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_COMMA_EXPRESSION)) #define VALA_CCODE_COMMA_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_COMMA_EXPRESSION, ValaCCodeCommaExpressionClass)) typedef struct _ValaCCodeCommaExpression ValaCCodeCommaExpression; typedef struct _ValaCCodeCommaExpressionClass ValaCCodeCommaExpressionClass; typedef struct _ValaCCodeCommaExpressionPrivate ValaCCodeCommaExpressionPrivate; #define VALA_TYPE_CCODE_COMMENT (vala_ccode_comment_get_type ()) #define VALA_CCODE_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_COMMENT, ValaCCodeComment)) #define VALA_CCODE_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_COMMENT, ValaCCodeCommentClass)) #define VALA_IS_CCODE_COMMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_COMMENT)) #define VALA_IS_CCODE_COMMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_COMMENT)) #define VALA_CCODE_COMMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_COMMENT, ValaCCodeCommentClass)) typedef struct _ValaCCodeComment ValaCCodeComment; typedef struct _ValaCCodeCommentClass ValaCCodeCommentClass; typedef struct _ValaCCodeCommentPrivate ValaCCodeCommentPrivate; #define VALA_TYPE_CCODE_CONDITIONAL_EXPRESSION (vala_ccode_conditional_expression_get_type ()) #define VALA_CCODE_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONDITIONAL_EXPRESSION, ValaCCodeConditionalExpression)) #define VALA_CCODE_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONDITIONAL_EXPRESSION, ValaCCodeConditionalExpressionClass)) #define VALA_IS_CCODE_CONDITIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONDITIONAL_EXPRESSION)) #define VALA_IS_CCODE_CONDITIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONDITIONAL_EXPRESSION)) #define VALA_CCODE_CONDITIONAL_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONDITIONAL_EXPRESSION, ValaCCodeConditionalExpressionClass)) typedef struct _ValaCCodeConditionalExpression ValaCCodeConditionalExpression; typedef struct _ValaCCodeConditionalExpressionClass ValaCCodeConditionalExpressionClass; typedef struct _ValaCCodeConditionalExpressionPrivate ValaCCodeConditionalExpressionPrivate; #define VALA_TYPE_CCODE_CONSTANT (vala_ccode_constant_get_type ()) #define VALA_CCODE_CONSTANT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONSTANT, ValaCCodeConstant)) #define VALA_CCODE_CONSTANT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONSTANT, ValaCCodeConstantClass)) #define VALA_IS_CCODE_CONSTANT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONSTANT)) #define VALA_IS_CCODE_CONSTANT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONSTANT)) #define VALA_CCODE_CONSTANT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONSTANT, ValaCCodeConstantClass)) typedef struct _ValaCCodeConstant ValaCCodeConstant; typedef struct _ValaCCodeConstantClass ValaCCodeConstantClass; typedef struct _ValaCCodeConstantPrivate ValaCCodeConstantPrivate; #define VALA_TYPE_CCODE_CONTINUE_STATEMENT (vala_ccode_continue_statement_get_type ()) #define VALA_CCODE_CONTINUE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONTINUE_STATEMENT, ValaCCodeContinueStatement)) #define VALA_CCODE_CONTINUE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONTINUE_STATEMENT, ValaCCodeContinueStatementClass)) #define VALA_IS_CCODE_CONTINUE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONTINUE_STATEMENT)) #define VALA_IS_CCODE_CONTINUE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONTINUE_STATEMENT)) #define VALA_CCODE_CONTINUE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONTINUE_STATEMENT, ValaCCodeContinueStatementClass)) typedef struct _ValaCCodeContinueStatement ValaCCodeContinueStatement; typedef struct _ValaCCodeContinueStatementClass ValaCCodeContinueStatementClass; typedef struct _ValaCCodeContinueStatementPrivate ValaCCodeContinueStatementPrivate; #define VALA_TYPE_CCODE_DECLARATION (vala_ccode_declaration_get_type ()) #define VALA_CCODE_DECLARATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DECLARATION, ValaCCodeDeclaration)) #define VALA_CCODE_DECLARATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DECLARATION, ValaCCodeDeclarationClass)) #define VALA_IS_CCODE_DECLARATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DECLARATION)) #define VALA_IS_CCODE_DECLARATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DECLARATION)) #define VALA_CCODE_DECLARATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DECLARATION, ValaCCodeDeclarationClass)) typedef struct _ValaCCodeDeclaration ValaCCodeDeclaration; typedef struct _ValaCCodeDeclarationClass ValaCCodeDeclarationClass; typedef struct _ValaCCodeDeclarationPrivate ValaCCodeDeclarationPrivate; #define VALA_TYPE_CCODE_DECLARATOR (vala_ccode_declarator_get_type ()) #define VALA_CCODE_DECLARATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DECLARATOR, ValaCCodeDeclarator)) #define VALA_CCODE_DECLARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DECLARATOR, ValaCCodeDeclaratorClass)) #define VALA_IS_CCODE_DECLARATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DECLARATOR)) #define VALA_IS_CCODE_DECLARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DECLARATOR)) #define VALA_CCODE_DECLARATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DECLARATOR, ValaCCodeDeclaratorClass)) typedef struct _ValaCCodeDeclarator ValaCCodeDeclarator; typedef struct _ValaCCodeDeclaratorClass ValaCCodeDeclaratorClass; typedef struct _ValaCCodeDeclaratorPrivate ValaCCodeDeclaratorPrivate; #define VALA_TYPE_CCODE_DO_STATEMENT (vala_ccode_do_statement_get_type ()) #define VALA_CCODE_DO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DO_STATEMENT, ValaCCodeDoStatement)) #define VALA_CCODE_DO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DO_STATEMENT, ValaCCodeDoStatementClass)) #define VALA_IS_CCODE_DO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DO_STATEMENT)) #define VALA_IS_CCODE_DO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DO_STATEMENT)) #define VALA_CCODE_DO_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DO_STATEMENT, ValaCCodeDoStatementClass)) typedef struct _ValaCCodeDoStatement ValaCCodeDoStatement; typedef struct _ValaCCodeDoStatementClass ValaCCodeDoStatementClass; typedef struct _ValaCCodeDoStatementPrivate ValaCCodeDoStatementPrivate; #define VALA_TYPE_CCODE_EMPTY_STATEMENT (vala_ccode_empty_statement_get_type ()) #define VALA_CCODE_EMPTY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_EMPTY_STATEMENT, ValaCCodeEmptyStatement)) #define VALA_CCODE_EMPTY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_EMPTY_STATEMENT, ValaCCodeEmptyStatementClass)) #define VALA_IS_CCODE_EMPTY_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_EMPTY_STATEMENT)) #define VALA_IS_CCODE_EMPTY_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_EMPTY_STATEMENT)) #define VALA_CCODE_EMPTY_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_EMPTY_STATEMENT, ValaCCodeEmptyStatementClass)) typedef struct _ValaCCodeEmptyStatement ValaCCodeEmptyStatement; typedef struct _ValaCCodeEmptyStatementClass ValaCCodeEmptyStatementClass; typedef struct _ValaCCodeEmptyStatementPrivate ValaCCodeEmptyStatementPrivate; #define VALA_TYPE_CCODE_ENUM (vala_ccode_enum_get_type ()) #define VALA_CCODE_ENUM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ENUM, ValaCCodeEnum)) #define VALA_CCODE_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ENUM, ValaCCodeEnumClass)) #define VALA_IS_CCODE_ENUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ENUM)) #define VALA_IS_CCODE_ENUM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ENUM)) #define VALA_CCODE_ENUM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ENUM, ValaCCodeEnumClass)) typedef struct _ValaCCodeEnum ValaCCodeEnum; typedef struct _ValaCCodeEnumClass ValaCCodeEnumClass; typedef struct _ValaCCodeEnumPrivate ValaCCodeEnumPrivate; #define VALA_TYPE_CCODE_ENUM_VALUE (vala_ccode_enum_value_get_type ()) #define VALA_CCODE_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ENUM_VALUE, ValaCCodeEnumValue)) #define VALA_CCODE_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ENUM_VALUE, ValaCCodeEnumValueClass)) #define VALA_IS_CCODE_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ENUM_VALUE)) #define VALA_IS_CCODE_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ENUM_VALUE)) #define VALA_CCODE_ENUM_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ENUM_VALUE, ValaCCodeEnumValueClass)) typedef struct _ValaCCodeEnumValue ValaCCodeEnumValue; typedef struct _ValaCCodeEnumValueClass ValaCCodeEnumValueClass; typedef struct _ValaCCodeEnumValuePrivate ValaCCodeEnumValuePrivate; #define VALA_TYPE_CCODE_EXPRESSION_STATEMENT (vala_ccode_expression_statement_get_type ()) #define VALA_CCODE_EXPRESSION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_EXPRESSION_STATEMENT, ValaCCodeExpressionStatement)) #define VALA_CCODE_EXPRESSION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_EXPRESSION_STATEMENT, ValaCCodeExpressionStatementClass)) #define VALA_IS_CCODE_EXPRESSION_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_EXPRESSION_STATEMENT)) #define VALA_IS_CCODE_EXPRESSION_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_EXPRESSION_STATEMENT)) #define VALA_CCODE_EXPRESSION_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_EXPRESSION_STATEMENT, ValaCCodeExpressionStatementClass)) typedef struct _ValaCCodeExpressionStatement ValaCCodeExpressionStatement; typedef struct _ValaCCodeExpressionStatementClass ValaCCodeExpressionStatementClass; typedef struct _ValaCCodeExpressionStatementPrivate ValaCCodeExpressionStatementPrivate; #define VALA_TYPE_CCODE_FILE (vala_ccode_file_get_type ()) #define VALA_CCODE_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_FILE, ValaCCodeFile)) #define VALA_CCODE_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_FILE, ValaCCodeFileClass)) #define VALA_IS_CCODE_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_FILE)) #define VALA_IS_CCODE_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_FILE)) #define VALA_CCODE_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_FILE, ValaCCodeFileClass)) typedef struct _ValaCCodeFile ValaCCodeFile; typedef struct _ValaCCodeFileClass ValaCCodeFileClass; typedef struct _ValaCCodeFilePrivate ValaCCodeFilePrivate; #define VALA_TYPE_CCODE_FUNCTION (vala_ccode_function_get_type ()) #define VALA_CCODE_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_FUNCTION, ValaCCodeFunction)) #define VALA_CCODE_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_FUNCTION, ValaCCodeFunctionClass)) #define VALA_IS_CCODE_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_FUNCTION)) #define VALA_IS_CCODE_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_FUNCTION)) #define VALA_CCODE_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_FUNCTION, ValaCCodeFunctionClass)) typedef struct _ValaCCodeFunction ValaCCodeFunction; typedef struct _ValaCCodeFunctionClass ValaCCodeFunctionClass; #define VALA_TYPE_CCODE_FOR_STATEMENT (vala_ccode_for_statement_get_type ()) #define VALA_CCODE_FOR_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_FOR_STATEMENT, ValaCCodeForStatement)) #define VALA_CCODE_FOR_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_FOR_STATEMENT, ValaCCodeForStatementClass)) #define VALA_IS_CCODE_FOR_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_FOR_STATEMENT)) #define VALA_IS_CCODE_FOR_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_FOR_STATEMENT)) #define VALA_CCODE_FOR_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_FOR_STATEMENT, ValaCCodeForStatementClass)) typedef struct _ValaCCodeForStatement ValaCCodeForStatement; typedef struct _ValaCCodeForStatementClass ValaCCodeForStatementClass; typedef struct _ValaCCodeForStatementPrivate ValaCCodeForStatementPrivate; #define VALA_TYPE_CCODE_FRAGMENT (vala_ccode_fragment_get_type ()) #define VALA_CCODE_FRAGMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_FRAGMENT, ValaCCodeFragment)) #define VALA_CCODE_FRAGMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_FRAGMENT, ValaCCodeFragmentClass)) #define VALA_IS_CCODE_FRAGMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_FRAGMENT)) #define VALA_IS_CCODE_FRAGMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_FRAGMENT)) #define VALA_CCODE_FRAGMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_FRAGMENT, ValaCCodeFragmentClass)) typedef struct _ValaCCodeFragment ValaCCodeFragment; typedef struct _ValaCCodeFragmentClass ValaCCodeFragmentClass; typedef struct _ValaCCodeFragmentPrivate ValaCCodeFragmentPrivate; typedef struct _ValaCCodeFunctionPrivate ValaCCodeFunctionPrivate; #define VALA_TYPE_CCODE_PARAMETER (vala_ccode_parameter_get_type ()) #define VALA_CCODE_PARAMETER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_PARAMETER, ValaCCodeParameter)) #define VALA_CCODE_PARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_PARAMETER, ValaCCodeParameterClass)) #define VALA_IS_CCODE_PARAMETER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_PARAMETER)) #define VALA_IS_CCODE_PARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_PARAMETER)) #define VALA_CCODE_PARAMETER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_PARAMETER, ValaCCodeParameterClass)) typedef struct _ValaCCodeParameter ValaCCodeParameter; typedef struct _ValaCCodeParameterClass ValaCCodeParameterClass; #define VALA_TYPE_CCODE_MODIFIERS (vala_ccode_modifiers_get_type ()) #define VALA_TYPE_CCODE_LINE_DIRECTIVE (vala_ccode_line_directive_get_type ()) #define VALA_CCODE_LINE_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_LINE_DIRECTIVE, ValaCCodeLineDirective)) #define VALA_CCODE_LINE_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_LINE_DIRECTIVE, ValaCCodeLineDirectiveClass)) #define VALA_IS_CCODE_LINE_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_LINE_DIRECTIVE)) #define VALA_IS_CCODE_LINE_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_LINE_DIRECTIVE)) #define VALA_CCODE_LINE_DIRECTIVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_LINE_DIRECTIVE, ValaCCodeLineDirectiveClass)) typedef struct _ValaCCodeLineDirective ValaCCodeLineDirective; typedef struct _ValaCCodeLineDirectiveClass ValaCCodeLineDirectiveClass; #define VALA_TYPE_CCODE_FUNCTION_CALL (vala_ccode_function_call_get_type ()) #define VALA_CCODE_FUNCTION_CALL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCall)) #define VALA_CCODE_FUNCTION_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCallClass)) #define VALA_IS_CCODE_FUNCTION_CALL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_FUNCTION_CALL)) #define VALA_IS_CCODE_FUNCTION_CALL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_FUNCTION_CALL)) #define VALA_CCODE_FUNCTION_CALL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCallClass)) typedef struct _ValaCCodeFunctionCall ValaCCodeFunctionCall; typedef struct _ValaCCodeFunctionCallClass ValaCCodeFunctionCallClass; typedef struct _ValaCCodeFunctionCallPrivate ValaCCodeFunctionCallPrivate; #define VALA_TYPE_CCODE_FUNCTION_DECLARATOR (vala_ccode_function_declarator_get_type ()) #define VALA_CCODE_FUNCTION_DECLARATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_FUNCTION_DECLARATOR, ValaCCodeFunctionDeclarator)) #define VALA_CCODE_FUNCTION_DECLARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_FUNCTION_DECLARATOR, ValaCCodeFunctionDeclaratorClass)) #define VALA_IS_CCODE_FUNCTION_DECLARATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_FUNCTION_DECLARATOR)) #define VALA_IS_CCODE_FUNCTION_DECLARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_FUNCTION_DECLARATOR)) #define VALA_CCODE_FUNCTION_DECLARATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_FUNCTION_DECLARATOR, ValaCCodeFunctionDeclaratorClass)) typedef struct _ValaCCodeFunctionDeclarator ValaCCodeFunctionDeclarator; typedef struct _ValaCCodeFunctionDeclaratorClass ValaCCodeFunctionDeclaratorClass; typedef struct _ValaCCodeFunctionDeclaratorPrivate ValaCCodeFunctionDeclaratorPrivate; #define VALA_TYPE_CCODE_GGNUC_SECTION (vala_ccode_ggnuc_section_get_type ()) #define VALA_CCODE_GGNUC_SECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_GGNUC_SECTION, ValaCCodeGGnucSection)) #define VALA_CCODE_GGNUC_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_GGNUC_SECTION, ValaCCodeGGnucSectionClass)) #define VALA_IS_CCODE_GGNUC_SECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_GGNUC_SECTION)) #define VALA_IS_CCODE_GGNUC_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_GGNUC_SECTION)) #define VALA_CCODE_GGNUC_SECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_GGNUC_SECTION, ValaCCodeGGnucSectionClass)) typedef struct _ValaCCodeGGnucSection ValaCCodeGGnucSection; typedef struct _ValaCCodeGGnucSectionClass ValaCCodeGGnucSectionClass; typedef struct _ValaCCodeGGnucSectionPrivate ValaCCodeGGnucSectionPrivate; #define VALA_TYPE_GGNUC_SECTION_TYPE (vala_ggnuc_section_type_get_type ()) #define VALA_TYPE_CCODE_GOTO_STATEMENT (vala_ccode_goto_statement_get_type ()) #define VALA_CCODE_GOTO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_GOTO_STATEMENT, ValaCCodeGotoStatement)) #define VALA_CCODE_GOTO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_GOTO_STATEMENT, ValaCCodeGotoStatementClass)) #define VALA_IS_CCODE_GOTO_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_GOTO_STATEMENT)) #define VALA_IS_CCODE_GOTO_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_GOTO_STATEMENT)) #define VALA_CCODE_GOTO_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_GOTO_STATEMENT, ValaCCodeGotoStatementClass)) typedef struct _ValaCCodeGotoStatement ValaCCodeGotoStatement; typedef struct _ValaCCodeGotoStatementClass ValaCCodeGotoStatementClass; typedef struct _ValaCCodeGotoStatementPrivate ValaCCodeGotoStatementPrivate; #define VALA_TYPE_CCODE_IDENTIFIER (vala_ccode_identifier_get_type ()) #define VALA_CCODE_IDENTIFIER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifier)) #define VALA_CCODE_IDENTIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifierClass)) #define VALA_IS_CCODE_IDENTIFIER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_IDENTIFIER)) #define VALA_IS_CCODE_IDENTIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_IDENTIFIER)) #define VALA_CCODE_IDENTIFIER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_IDENTIFIER, ValaCCodeIdentifierClass)) typedef struct _ValaCCodeIdentifier ValaCCodeIdentifier; typedef struct _ValaCCodeIdentifierClass ValaCCodeIdentifierClass; typedef struct _ValaCCodeIdentifierPrivate ValaCCodeIdentifierPrivate; #define VALA_TYPE_CCODE_IF_STATEMENT (vala_ccode_if_statement_get_type ()) #define VALA_CCODE_IF_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_IF_STATEMENT, ValaCCodeIfStatement)) #define VALA_CCODE_IF_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_IF_STATEMENT, ValaCCodeIfStatementClass)) #define VALA_IS_CCODE_IF_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_IF_STATEMENT)) #define VALA_IS_CCODE_IF_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_IF_STATEMENT)) #define VALA_CCODE_IF_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_IF_STATEMENT, ValaCCodeIfStatementClass)) typedef struct _ValaCCodeIfStatement ValaCCodeIfStatement; typedef struct _ValaCCodeIfStatementClass ValaCCodeIfStatementClass; typedef struct _ValaCCodeIfStatementPrivate ValaCCodeIfStatementPrivate; #define VALA_TYPE_CCODE_INCLUDE_DIRECTIVE (vala_ccode_include_directive_get_type ()) #define VALA_CCODE_INCLUDE_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_INCLUDE_DIRECTIVE, ValaCCodeIncludeDirective)) #define VALA_CCODE_INCLUDE_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_INCLUDE_DIRECTIVE, ValaCCodeIncludeDirectiveClass)) #define VALA_IS_CCODE_INCLUDE_DIRECTIVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_INCLUDE_DIRECTIVE)) #define VALA_IS_CCODE_INCLUDE_DIRECTIVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_INCLUDE_DIRECTIVE)) #define VALA_CCODE_INCLUDE_DIRECTIVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_INCLUDE_DIRECTIVE, ValaCCodeIncludeDirectiveClass)) typedef struct _ValaCCodeIncludeDirective ValaCCodeIncludeDirective; typedef struct _ValaCCodeIncludeDirectiveClass ValaCCodeIncludeDirectiveClass; typedef struct _ValaCCodeIncludeDirectivePrivate ValaCCodeIncludeDirectivePrivate; #define VALA_TYPE_CCODE_INITIALIZER_LIST (vala_ccode_initializer_list_get_type ()) #define VALA_CCODE_INITIALIZER_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_INITIALIZER_LIST, ValaCCodeInitializerList)) #define VALA_CCODE_INITIALIZER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_INITIALIZER_LIST, ValaCCodeInitializerListClass)) #define VALA_IS_CCODE_INITIALIZER_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_INITIALIZER_LIST)) #define VALA_IS_CCODE_INITIALIZER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_INITIALIZER_LIST)) #define VALA_CCODE_INITIALIZER_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_INITIALIZER_LIST, ValaCCodeInitializerListClass)) typedef struct _ValaCCodeInitializerList ValaCCodeInitializerList; typedef struct _ValaCCodeInitializerListClass ValaCCodeInitializerListClass; typedef struct _ValaCCodeInitializerListPrivate ValaCCodeInitializerListPrivate; #define VALA_TYPE_CCODE_INVALID_EXPRESSION (vala_ccode_invalid_expression_get_type ()) #define VALA_CCODE_INVALID_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_INVALID_EXPRESSION, ValaCCodeInvalidExpression)) #define VALA_CCODE_INVALID_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_INVALID_EXPRESSION, ValaCCodeInvalidExpressionClass)) #define VALA_IS_CCODE_INVALID_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_INVALID_EXPRESSION)) #define VALA_IS_CCODE_INVALID_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_INVALID_EXPRESSION)) #define VALA_CCODE_INVALID_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_INVALID_EXPRESSION, ValaCCodeInvalidExpressionClass)) typedef struct _ValaCCodeInvalidExpression ValaCCodeInvalidExpression; typedef struct _ValaCCodeInvalidExpressionClass ValaCCodeInvalidExpressionClass; typedef struct _ValaCCodeInvalidExpressionPrivate ValaCCodeInvalidExpressionPrivate; #define VALA_TYPE_CCODE_LABEL (vala_ccode_label_get_type ()) #define VALA_CCODE_LABEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_LABEL, ValaCCodeLabel)) #define VALA_CCODE_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_LABEL, ValaCCodeLabelClass)) #define VALA_IS_CCODE_LABEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_LABEL)) #define VALA_IS_CCODE_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_LABEL)) #define VALA_CCODE_LABEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_LABEL, ValaCCodeLabelClass)) typedef struct _ValaCCodeLabel ValaCCodeLabel; typedef struct _ValaCCodeLabelClass ValaCCodeLabelClass; typedef struct _ValaCCodeLabelPrivate ValaCCodeLabelPrivate; typedef struct _ValaCCodeLineDirectivePrivate ValaCCodeLineDirectivePrivate; #define VALA_TYPE_CCODE_IF_SECTION (vala_ccode_if_section_get_type ()) #define VALA_CCODE_IF_SECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_IF_SECTION, ValaCCodeIfSection)) #define VALA_CCODE_IF_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_IF_SECTION, ValaCCodeIfSectionClass)) #define VALA_IS_CCODE_IF_SECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_IF_SECTION)) #define VALA_IS_CCODE_IF_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_IF_SECTION)) #define VALA_CCODE_IF_SECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_IF_SECTION, ValaCCodeIfSectionClass)) typedef struct _ValaCCodeIfSection ValaCCodeIfSection; typedef struct _ValaCCodeIfSectionClass ValaCCodeIfSectionClass; typedef struct _ValaCCodeIfSectionPrivate ValaCCodeIfSectionPrivate; #define VALA_TYPE_CCODE_MACRO_REPLACEMENT (vala_ccode_macro_replacement_get_type ()) #define VALA_CCODE_MACRO_REPLACEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_MACRO_REPLACEMENT, ValaCCodeMacroReplacement)) #define VALA_CCODE_MACRO_REPLACEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_MACRO_REPLACEMENT, ValaCCodeMacroReplacementClass)) #define VALA_IS_CCODE_MACRO_REPLACEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_MACRO_REPLACEMENT)) #define VALA_IS_CCODE_MACRO_REPLACEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_MACRO_REPLACEMENT)) #define VALA_CCODE_MACRO_REPLACEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_MACRO_REPLACEMENT, ValaCCodeMacroReplacementClass)) typedef struct _ValaCCodeMacroReplacement ValaCCodeMacroReplacement; typedef struct _ValaCCodeMacroReplacementClass ValaCCodeMacroReplacementClass; typedef struct _ValaCCodeMacroReplacementPrivate ValaCCodeMacroReplacementPrivate; #define VALA_TYPE_CCODE_MEMBER_ACCESS (vala_ccode_member_access_get_type ()) #define VALA_CCODE_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS, ValaCCodeMemberAccess)) #define VALA_CCODE_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS, ValaCCodeMemberAccessClass)) #define VALA_IS_CCODE_MEMBER_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS)) #define VALA_IS_CCODE_MEMBER_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS)) #define VALA_CCODE_MEMBER_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS, ValaCCodeMemberAccessClass)) typedef struct _ValaCCodeMemberAccess ValaCCodeMemberAccess; typedef struct _ValaCCodeMemberAccessClass ValaCCodeMemberAccessClass; typedef struct _ValaCCodeMemberAccessPrivate ValaCCodeMemberAccessPrivate; #define VALA_TYPE_CCODE_NEWLINE (vala_ccode_newline_get_type ()) #define VALA_CCODE_NEWLINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_NEWLINE, ValaCCodeNewline)) #define VALA_CCODE_NEWLINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_NEWLINE, ValaCCodeNewlineClass)) #define VALA_IS_CCODE_NEWLINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_NEWLINE)) #define VALA_IS_CCODE_NEWLINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_NEWLINE)) #define VALA_CCODE_NEWLINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_NEWLINE, ValaCCodeNewlineClass)) typedef struct _ValaCCodeNewline ValaCCodeNewline; typedef struct _ValaCCodeNewlineClass ValaCCodeNewlineClass; typedef struct _ValaCCodeNewlinePrivate ValaCCodeNewlinePrivate; #define VALA_TYPE_CCODE_ONCE_SECTION (vala_ccode_once_section_get_type ()) #define VALA_CCODE_ONCE_SECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ONCE_SECTION, ValaCCodeOnceSection)) #define VALA_CCODE_ONCE_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ONCE_SECTION, ValaCCodeOnceSectionClass)) #define VALA_IS_CCODE_ONCE_SECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ONCE_SECTION)) #define VALA_IS_CCODE_ONCE_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ONCE_SECTION)) #define VALA_CCODE_ONCE_SECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ONCE_SECTION, ValaCCodeOnceSectionClass)) typedef struct _ValaCCodeOnceSection ValaCCodeOnceSection; typedef struct _ValaCCodeOnceSectionClass ValaCCodeOnceSectionClass; typedef struct _ValaCCodeOnceSectionPrivate ValaCCodeOnceSectionPrivate; typedef struct _ValaCCodeParameterPrivate ValaCCodeParameterPrivate; #define VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION (vala_ccode_parenthesized_expression_get_type ()) #define VALA_CCODE_PARENTHESIZED_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION, ValaCCodeParenthesizedExpression)) #define VALA_CCODE_PARENTHESIZED_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION, ValaCCodeParenthesizedExpressionClass)) #define VALA_IS_CCODE_PARENTHESIZED_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION)) #define VALA_IS_CCODE_PARENTHESIZED_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION)) #define VALA_CCODE_PARENTHESIZED_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_PARENTHESIZED_EXPRESSION, ValaCCodeParenthesizedExpressionClass)) typedef struct _ValaCCodeParenthesizedExpression ValaCCodeParenthesizedExpression; typedef struct _ValaCCodeParenthesizedExpressionClass ValaCCodeParenthesizedExpressionClass; typedef struct _ValaCCodeParenthesizedExpressionPrivate ValaCCodeParenthesizedExpressionPrivate; #define VALA_TYPE_CCODE_RETURN_STATEMENT (vala_ccode_return_statement_get_type ()) #define VALA_CCODE_RETURN_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_RETURN_STATEMENT, ValaCCodeReturnStatement)) #define VALA_CCODE_RETURN_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_RETURN_STATEMENT, ValaCCodeReturnStatementClass)) #define VALA_IS_CCODE_RETURN_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_RETURN_STATEMENT)) #define VALA_IS_CCODE_RETURN_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_RETURN_STATEMENT)) #define VALA_CCODE_RETURN_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_RETURN_STATEMENT, ValaCCodeReturnStatementClass)) typedef struct _ValaCCodeReturnStatement ValaCCodeReturnStatement; typedef struct _ValaCCodeReturnStatementClass ValaCCodeReturnStatementClass; typedef struct _ValaCCodeReturnStatementPrivate ValaCCodeReturnStatementPrivate; #define VALA_TYPE_CCODE_STRUCT (vala_ccode_struct_get_type ()) #define VALA_CCODE_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_STRUCT, ValaCCodeStruct)) #define VALA_CCODE_STRUCT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_STRUCT, ValaCCodeStructClass)) #define VALA_IS_CCODE_STRUCT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_STRUCT)) #define VALA_IS_CCODE_STRUCT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_STRUCT)) #define VALA_CCODE_STRUCT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_STRUCT, ValaCCodeStructClass)) typedef struct _ValaCCodeStruct ValaCCodeStruct; typedef struct _ValaCCodeStructClass ValaCCodeStructClass; typedef struct _ValaCCodeStructPrivate ValaCCodeStructPrivate; #define VALA_TYPE_CCODE_DECLARATOR_SUFFIX (vala_ccode_declarator_suffix_get_type ()) #define VALA_CCODE_DECLARATOR_SUFFIX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DECLARATOR_SUFFIX, ValaCCodeDeclaratorSuffix)) #define VALA_CCODE_DECLARATOR_SUFFIX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DECLARATOR_SUFFIX, ValaCCodeDeclaratorSuffixClass)) #define VALA_IS_CCODE_DECLARATOR_SUFFIX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DECLARATOR_SUFFIX)) #define VALA_IS_CCODE_DECLARATOR_SUFFIX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DECLARATOR_SUFFIX)) #define VALA_CCODE_DECLARATOR_SUFFIX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DECLARATOR_SUFFIX, ValaCCodeDeclaratorSuffixClass)) typedef struct _ValaCCodeDeclaratorSuffix ValaCCodeDeclaratorSuffix; typedef struct _ValaCCodeDeclaratorSuffixClass ValaCCodeDeclaratorSuffixClass; #define VALA_TYPE_CCODE_SWITCH_STATEMENT (vala_ccode_switch_statement_get_type ()) #define VALA_CCODE_SWITCH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_SWITCH_STATEMENT, ValaCCodeSwitchStatement)) #define VALA_CCODE_SWITCH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_SWITCH_STATEMENT, ValaCCodeSwitchStatementClass)) #define VALA_IS_CCODE_SWITCH_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_SWITCH_STATEMENT)) #define VALA_IS_CCODE_SWITCH_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_SWITCH_STATEMENT)) #define VALA_CCODE_SWITCH_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_SWITCH_STATEMENT, ValaCCodeSwitchStatementClass)) typedef struct _ValaCCodeSwitchStatement ValaCCodeSwitchStatement; typedef struct _ValaCCodeSwitchStatementClass ValaCCodeSwitchStatementClass; typedef struct _ValaCCodeSwitchStatementPrivate ValaCCodeSwitchStatementPrivate; #define VALA_TYPE_CCODE_TYPE_DEFINITION (vala_ccode_type_definition_get_type ()) #define VALA_CCODE_TYPE_DEFINITION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_TYPE_DEFINITION, ValaCCodeTypeDefinition)) #define VALA_CCODE_TYPE_DEFINITION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_TYPE_DEFINITION, ValaCCodeTypeDefinitionClass)) #define VALA_IS_CCODE_TYPE_DEFINITION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_TYPE_DEFINITION)) #define VALA_IS_CCODE_TYPE_DEFINITION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_TYPE_DEFINITION)) #define VALA_CCODE_TYPE_DEFINITION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_TYPE_DEFINITION, ValaCCodeTypeDefinitionClass)) typedef struct _ValaCCodeTypeDefinition ValaCCodeTypeDefinition; typedef struct _ValaCCodeTypeDefinitionClass ValaCCodeTypeDefinitionClass; typedef struct _ValaCCodeTypeDefinitionPrivate ValaCCodeTypeDefinitionPrivate; #define VALA_TYPE_CCODE_UNARY_EXPRESSION (vala_ccode_unary_expression_get_type ()) #define VALA_CCODE_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_UNARY_EXPRESSION, ValaCCodeUnaryExpression)) #define VALA_CCODE_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_UNARY_EXPRESSION, ValaCCodeUnaryExpressionClass)) #define VALA_IS_CCODE_UNARY_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_UNARY_EXPRESSION)) #define VALA_IS_CCODE_UNARY_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_UNARY_EXPRESSION)) #define VALA_CCODE_UNARY_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_UNARY_EXPRESSION, ValaCCodeUnaryExpressionClass)) typedef struct _ValaCCodeUnaryExpression ValaCCodeUnaryExpression; typedef struct _ValaCCodeUnaryExpressionClass ValaCCodeUnaryExpressionClass; typedef struct _ValaCCodeUnaryExpressionPrivate ValaCCodeUnaryExpressionPrivate; #define VALA_TYPE_CCODE_UNARY_OPERATOR (vala_ccode_unary_operator_get_type ()) #define VALA_TYPE_CCODE_VARIABLE_DECLARATOR (vala_ccode_variable_declarator_get_type ()) #define VALA_CCODE_VARIABLE_DECLARATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_VARIABLE_DECLARATOR, ValaCCodeVariableDeclarator)) #define VALA_CCODE_VARIABLE_DECLARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_VARIABLE_DECLARATOR, ValaCCodeVariableDeclaratorClass)) #define VALA_IS_CCODE_VARIABLE_DECLARATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_VARIABLE_DECLARATOR)) #define VALA_IS_CCODE_VARIABLE_DECLARATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_VARIABLE_DECLARATOR)) #define VALA_CCODE_VARIABLE_DECLARATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_VARIABLE_DECLARATOR, ValaCCodeVariableDeclaratorClass)) typedef struct _ValaCCodeVariableDeclarator ValaCCodeVariableDeclarator; typedef struct _ValaCCodeVariableDeclaratorClass ValaCCodeVariableDeclaratorClass; typedef struct _ValaCCodeVariableDeclaratorPrivate ValaCCodeVariableDeclaratorPrivate; typedef struct _ValaCCodeDeclaratorSuffixPrivate ValaCCodeDeclaratorSuffixPrivate; #define VALA_TYPE_CCODE_WHILE_STATEMENT (vala_ccode_while_statement_get_type ()) #define VALA_CCODE_WHILE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_WHILE_STATEMENT, ValaCCodeWhileStatement)) #define VALA_CCODE_WHILE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_WHILE_STATEMENT, ValaCCodeWhileStatementClass)) #define VALA_IS_CCODE_WHILE_STATEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_WHILE_STATEMENT)) #define VALA_IS_CCODE_WHILE_STATEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_WHILE_STATEMENT)) #define VALA_CCODE_WHILE_STATEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_WHILE_STATEMENT, ValaCCodeWhileStatementClass)) typedef struct _ValaCCodeWhileStatement ValaCCodeWhileStatement; typedef struct _ValaCCodeWhileStatementClass ValaCCodeWhileStatementClass; typedef struct _ValaCCodeWhileStatementPrivate ValaCCodeWhileStatementPrivate; typedef struct _ValaCCodeWriterPrivate ValaCCodeWriterPrivate; #define VALA_TYPE_CCODE_ELEMENT_ACCESS (vala_ccode_element_access_get_type ()) #define VALA_CCODE_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ELEMENT_ACCESS, ValaCCodeElementAccess)) #define VALA_CCODE_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ELEMENT_ACCESS, ValaCCodeElementAccessClass)) #define VALA_IS_CCODE_ELEMENT_ACCESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ELEMENT_ACCESS)) #define VALA_IS_CCODE_ELEMENT_ACCESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ELEMENT_ACCESS)) #define VALA_CCODE_ELEMENT_ACCESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ELEMENT_ACCESS, ValaCCodeElementAccessClass)) typedef struct _ValaCCodeElementAccess ValaCCodeElementAccess; typedef struct _ValaCCodeElementAccessClass ValaCCodeElementAccessClass; typedef struct _ValaCCodeElementAccessPrivate ValaCCodeElementAccessPrivate; struct _ValaCCodeNode { GTypeInstance parent_instance; volatile int ref_count; ValaCCodeNodePrivate * priv; }; struct _ValaCCodeNodeClass { GTypeClass parent_class; void (*finalize) (ValaCCodeNode *self); void (*write) (ValaCCodeNode* self, ValaCCodeWriter* writer); void (*write_declaration) (ValaCCodeNode* self, ValaCCodeWriter* writer); void (*write_combined) (ValaCCodeNode* self, ValaCCodeWriter* writer); }; struct _ValaCCodeExpression { ValaCCodeNode parent_instance; ValaCCodeExpressionPrivate * priv; }; struct _ValaCCodeExpressionClass { ValaCCodeNodeClass parent_class; void (*write_inner) (ValaCCodeExpression* self, ValaCCodeWriter* writer); }; struct _ValaCCodeAssignment { ValaCCodeExpression parent_instance; ValaCCodeAssignmentPrivate * priv; }; struct _ValaCCodeAssignmentClass { ValaCCodeExpressionClass parent_class; }; typedef enum { VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE, VALA_CCODE_ASSIGNMENT_OPERATOR_BITWISE_OR, VALA_CCODE_ASSIGNMENT_OPERATOR_BITWISE_AND, VALA_CCODE_ASSIGNMENT_OPERATOR_BITWISE_XOR, VALA_CCODE_ASSIGNMENT_OPERATOR_ADD, VALA_CCODE_ASSIGNMENT_OPERATOR_SUB, VALA_CCODE_ASSIGNMENT_OPERATOR_MUL, VALA_CCODE_ASSIGNMENT_OPERATOR_DIV, VALA_CCODE_ASSIGNMENT_OPERATOR_PERCENT, VALA_CCODE_ASSIGNMENT_OPERATOR_SHIFT_LEFT, VALA_CCODE_ASSIGNMENT_OPERATOR_SHIFT_RIGHT } ValaCCodeAssignmentOperator; struct _ValaCCodeBinaryExpression { ValaCCodeExpression parent_instance; ValaCCodeBinaryExpressionPrivate * priv; }; struct _ValaCCodeBinaryExpressionClass { ValaCCodeExpressionClass parent_class; }; typedef enum { VALA_CCODE_BINARY_OPERATOR_PLUS, VALA_CCODE_BINARY_OPERATOR_MINUS, VALA_CCODE_BINARY_OPERATOR_MUL, VALA_CCODE_BINARY_OPERATOR_DIV, VALA_CCODE_BINARY_OPERATOR_MOD, VALA_CCODE_BINARY_OPERATOR_SHIFT_LEFT, VALA_CCODE_BINARY_OPERATOR_SHIFT_RIGHT, VALA_CCODE_BINARY_OPERATOR_LESS_THAN, VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, VALA_CCODE_BINARY_OPERATOR_LESS_THAN_OR_EQUAL, VALA_CCODE_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL, VALA_CCODE_BINARY_OPERATOR_EQUALITY, VALA_CCODE_BINARY_OPERATOR_INEQUALITY, VALA_CCODE_BINARY_OPERATOR_BITWISE_AND, VALA_CCODE_BINARY_OPERATOR_BITWISE_OR, VALA_CCODE_BINARY_OPERATOR_BITWISE_XOR, VALA_CCODE_BINARY_OPERATOR_AND, VALA_CCODE_BINARY_OPERATOR_OR } ValaCCodeBinaryOperator; struct _ValaCCodeStatement { ValaCCodeNode parent_instance; ValaCCodeStatementPrivate * priv; }; struct _ValaCCodeStatementClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeBlock { ValaCCodeStatement parent_instance; ValaCCodeBlockPrivate * priv; }; struct _ValaCCodeBlockClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeBreakStatement { ValaCCodeStatement parent_instance; ValaCCodeBreakStatementPrivate * priv; }; struct _ValaCCodeBreakStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeCaseStatement { ValaCCodeStatement parent_instance; ValaCCodeCaseStatementPrivate * priv; }; struct _ValaCCodeCaseStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeCastExpression { ValaCCodeExpression parent_instance; ValaCCodeCastExpressionPrivate * priv; }; struct _ValaCCodeCastExpressionClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeCommaExpression { ValaCCodeExpression parent_instance; ValaCCodeCommaExpressionPrivate * priv; }; struct _ValaCCodeCommaExpressionClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeComment { ValaCCodeNode parent_instance; ValaCCodeCommentPrivate * priv; }; struct _ValaCCodeCommentClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeConditionalExpression { ValaCCodeExpression parent_instance; ValaCCodeConditionalExpressionPrivate * priv; }; struct _ValaCCodeConditionalExpressionClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeConstant { ValaCCodeExpression parent_instance; ValaCCodeConstantPrivate * priv; }; struct _ValaCCodeConstantClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeContinueStatement { ValaCCodeStatement parent_instance; ValaCCodeContinueStatementPrivate * priv; }; struct _ValaCCodeContinueStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeDeclaration { ValaCCodeStatement parent_instance; ValaCCodeDeclarationPrivate * priv; }; struct _ValaCCodeDeclarationClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeDeclarator { ValaCCodeNode parent_instance; ValaCCodeDeclaratorPrivate * priv; }; struct _ValaCCodeDeclaratorClass { ValaCCodeNodeClass parent_class; void (*write_initialization) (ValaCCodeDeclarator* self, ValaCCodeWriter* writer); }; struct _ValaCCodeDoStatement { ValaCCodeStatement parent_instance; ValaCCodeDoStatementPrivate * priv; }; struct _ValaCCodeDoStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeEmptyStatement { ValaCCodeStatement parent_instance; ValaCCodeEmptyStatementPrivate * priv; }; struct _ValaCCodeEmptyStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeEnum { ValaCCodeNode parent_instance; ValaCCodeEnumPrivate * priv; }; struct _ValaCCodeEnumClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeEnumValue { ValaCCodeNode parent_instance; ValaCCodeEnumValuePrivate * priv; }; struct _ValaCCodeEnumValueClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeExpressionStatement { ValaCCodeStatement parent_instance; ValaCCodeExpressionStatementPrivate * priv; }; struct _ValaCCodeExpressionStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeFile { GTypeInstance parent_instance; volatile int ref_count; ValaCCodeFilePrivate * priv; }; struct _ValaCCodeFileClass { GTypeClass parent_class; void (*finalize) (ValaCCodeFile *self); }; struct _ValaCCodeForStatement { ValaCCodeStatement parent_instance; ValaCCodeForStatementPrivate * priv; }; struct _ValaCCodeForStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeFragment { ValaCCodeNode parent_instance; ValaCCodeFragmentPrivate * priv; }; struct _ValaCCodeFragmentClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeFunction { ValaCCodeNode parent_instance; ValaCCodeFunctionPrivate * priv; }; struct _ValaCCodeFunctionClass { ValaCCodeNodeClass parent_class; }; typedef enum { VALA_CCODE_MODIFIERS_NONE = 0, VALA_CCODE_MODIFIERS_STATIC = 1 << 0, VALA_CCODE_MODIFIERS_REGISTER = 1 << 1, VALA_CCODE_MODIFIERS_EXTERN = 1 << 2, VALA_CCODE_MODIFIERS_INLINE = 1 << 3, VALA_CCODE_MODIFIERS_VOLATILE = 1 << 4, VALA_CCODE_MODIFIERS_DEPRECATED = 1 << 5, VALA_CCODE_MODIFIERS_THREAD_LOCAL = 1 << 6, VALA_CCODE_MODIFIERS_INTERNAL = 1 << 7, VALA_CCODE_MODIFIERS_CONST = 1 << 8, VALA_CCODE_MODIFIERS_UNUSED = 1 << 9, VALA_CCODE_MODIFIERS_CONSTRUCTOR = 1 << 10, VALA_CCODE_MODIFIERS_DESTRUCTOR = 1 << 11, VALA_CCODE_MODIFIERS_FORMAT_ARG = 1 << 12, VALA_CCODE_MODIFIERS_PRINTF = 1 << 13, VALA_CCODE_MODIFIERS_SCANF = 1 << 14 } ValaCCodeModifiers; struct _ValaCCodeFunctionCall { ValaCCodeExpression parent_instance; ValaCCodeFunctionCallPrivate * priv; }; struct _ValaCCodeFunctionCallClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeFunctionDeclarator { ValaCCodeDeclarator parent_instance; ValaCCodeFunctionDeclaratorPrivate * priv; }; struct _ValaCCodeFunctionDeclaratorClass { ValaCCodeDeclaratorClass parent_class; }; struct _ValaCCodeGGnucSection { ValaCCodeFragment parent_instance; ValaCCodeGGnucSectionPrivate * priv; }; struct _ValaCCodeGGnucSectionClass { ValaCCodeFragmentClass parent_class; }; typedef enum { VALA_GGNUC_SECTION_TYPE_IGNORE_DEPRECATIONS } ValaGGnucSectionType; struct _ValaCCodeGotoStatement { ValaCCodeStatement parent_instance; ValaCCodeGotoStatementPrivate * priv; }; struct _ValaCCodeGotoStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeIdentifier { ValaCCodeExpression parent_instance; ValaCCodeIdentifierPrivate * priv; }; struct _ValaCCodeIdentifierClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeIfStatement { ValaCCodeStatement parent_instance; ValaCCodeIfStatementPrivate * priv; }; struct _ValaCCodeIfStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeIncludeDirective { ValaCCodeNode parent_instance; ValaCCodeIncludeDirectivePrivate * priv; }; struct _ValaCCodeIncludeDirectiveClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeInitializerList { ValaCCodeExpression parent_instance; ValaCCodeInitializerListPrivate * priv; }; struct _ValaCCodeInitializerListClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeInvalidExpression { ValaCCodeExpression parent_instance; ValaCCodeInvalidExpressionPrivate * priv; }; struct _ValaCCodeInvalidExpressionClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeLabel { ValaCCodeStatement parent_instance; ValaCCodeLabelPrivate * priv; }; struct _ValaCCodeLabelClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeLineDirective { ValaCCodeNode parent_instance; ValaCCodeLineDirectivePrivate * priv; }; struct _ValaCCodeLineDirectiveClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeIfSection { ValaCCodeFragment parent_instance; ValaCCodeIfSectionPrivate * priv; }; struct _ValaCCodeIfSectionClass { ValaCCodeFragmentClass parent_class; }; struct _ValaCCodeMacroReplacement { ValaCCodeNode parent_instance; ValaCCodeMacroReplacementPrivate * priv; }; struct _ValaCCodeMacroReplacementClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeMemberAccess { ValaCCodeExpression parent_instance; ValaCCodeMemberAccessPrivate * priv; }; struct _ValaCCodeMemberAccessClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeNewline { ValaCCodeNode parent_instance; ValaCCodeNewlinePrivate * priv; }; struct _ValaCCodeNewlineClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeOnceSection { ValaCCodeFragment parent_instance; ValaCCodeOnceSectionPrivate * priv; }; struct _ValaCCodeOnceSectionClass { ValaCCodeFragmentClass parent_class; }; struct _ValaCCodeParameter { ValaCCodeNode parent_instance; ValaCCodeParameterPrivate * priv; }; struct _ValaCCodeParameterClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeParenthesizedExpression { ValaCCodeExpression parent_instance; ValaCCodeParenthesizedExpressionPrivate * priv; }; struct _ValaCCodeParenthesizedExpressionClass { ValaCCodeExpressionClass parent_class; }; struct _ValaCCodeReturnStatement { ValaCCodeStatement parent_instance; ValaCCodeReturnStatementPrivate * priv; }; struct _ValaCCodeReturnStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeStruct { ValaCCodeNode parent_instance; ValaCCodeStructPrivate * priv; }; struct _ValaCCodeStructClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeSwitchStatement { ValaCCodeBlock parent_instance; ValaCCodeSwitchStatementPrivate * priv; }; struct _ValaCCodeSwitchStatementClass { ValaCCodeBlockClass parent_class; }; struct _ValaCCodeTypeDefinition { ValaCCodeNode parent_instance; ValaCCodeTypeDefinitionPrivate * priv; }; struct _ValaCCodeTypeDefinitionClass { ValaCCodeNodeClass parent_class; }; struct _ValaCCodeUnaryExpression { ValaCCodeExpression parent_instance; ValaCCodeUnaryExpressionPrivate * priv; }; struct _ValaCCodeUnaryExpressionClass { ValaCCodeExpressionClass parent_class; }; typedef enum { VALA_CCODE_UNARY_OPERATOR_PLUS, VALA_CCODE_UNARY_OPERATOR_MINUS, VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, VALA_CCODE_UNARY_OPERATOR_BITWISE_COMPLEMENT, VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, VALA_CCODE_UNARY_OPERATOR_PREFIX_INCREMENT, VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, VALA_CCODE_UNARY_OPERATOR_POSTFIX_DECREMENT } ValaCCodeUnaryOperator; struct _ValaCCodeVariableDeclarator { ValaCCodeDeclarator parent_instance; ValaCCodeVariableDeclaratorPrivate * priv; }; struct _ValaCCodeVariableDeclaratorClass { ValaCCodeDeclaratorClass parent_class; }; struct _ValaCCodeDeclaratorSuffix { GTypeInstance parent_instance; volatile int ref_count; ValaCCodeDeclaratorSuffixPrivate * priv; }; struct _ValaCCodeDeclaratorSuffixClass { GTypeClass parent_class; void (*finalize) (ValaCCodeDeclaratorSuffix *self); }; struct _ValaCCodeWhileStatement { ValaCCodeStatement parent_instance; ValaCCodeWhileStatementPrivate * priv; }; struct _ValaCCodeWhileStatementClass { ValaCCodeStatementClass parent_class; }; struct _ValaCCodeWriter { GTypeInstance parent_instance; volatile int ref_count; ValaCCodeWriterPrivate * priv; }; struct _ValaCCodeWriterClass { GTypeClass parent_class; void (*finalize) (ValaCCodeWriter *self); }; struct _ValaCCodeElementAccess { ValaCCodeExpression parent_instance; ValaCCodeElementAccessPrivate * priv; }; struct _ValaCCodeElementAccessClass { ValaCCodeExpressionClass parent_class; }; gpointer vala_ccode_node_ref (gpointer instance); void vala_ccode_node_unref (gpointer instance); GParamSpec* vala_param_spec_ccode_node (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_ccode_node (GValue* value, gpointer v_object); void vala_value_take_ccode_node (GValue* value, gpointer v_object); gpointer vala_value_get_ccode_node (const GValue* value); GType vala_ccode_node_get_type (void) G_GNUC_CONST; gpointer vala_ccode_writer_ref (gpointer instance); void vala_ccode_writer_unref (gpointer instance); GParamSpec* vala_param_spec_ccode_writer (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_ccode_writer (GValue* value, gpointer v_object); void vala_value_take_ccode_writer (GValue* value, gpointer v_object); gpointer vala_value_get_ccode_writer (const GValue* value); GType vala_ccode_writer_get_type (void) G_GNUC_CONST; GType vala_ccode_expression_get_type (void) G_GNUC_CONST; GType vala_ccode_assignment_get_type (void) G_GNUC_CONST; GType vala_ccode_assignment_operator_get_type (void) G_GNUC_CONST; ValaCCodeAssignment* vala_ccode_assignment_new (ValaCCodeExpression* l, ValaCCodeExpression* r, ValaCCodeAssignmentOperator op); ValaCCodeAssignment* vala_ccode_assignment_construct (GType object_type, ValaCCodeExpression* l, ValaCCodeExpression* r, ValaCCodeAssignmentOperator op); ValaCCodeExpression* vala_ccode_assignment_get_left (ValaCCodeAssignment* self); void vala_ccode_assignment_set_left (ValaCCodeAssignment* self, ValaCCodeExpression* value); ValaCCodeAssignmentOperator vala_ccode_assignment_get_operator (ValaCCodeAssignment* self); void vala_ccode_assignment_set_operator (ValaCCodeAssignment* self, ValaCCodeAssignmentOperator value); ValaCCodeExpression* vala_ccode_assignment_get_right (ValaCCodeAssignment* self); void vala_ccode_assignment_set_right (ValaCCodeAssignment* self, ValaCCodeExpression* value); GType vala_ccode_binary_expression_get_type (void) G_GNUC_CONST; GType vala_ccode_binary_operator_get_type (void) G_GNUC_CONST; ValaCCodeBinaryExpression* vala_ccode_binary_expression_new (ValaCCodeBinaryOperator op, ValaCCodeExpression* l, ValaCCodeExpression* r); ValaCCodeBinaryExpression* vala_ccode_binary_expression_construct (GType object_type, ValaCCodeBinaryOperator op, ValaCCodeExpression* l, ValaCCodeExpression* r); ValaCCodeBinaryOperator vala_ccode_binary_expression_get_operator (ValaCCodeBinaryExpression* self); void vala_ccode_binary_expression_set_operator (ValaCCodeBinaryExpression* self, ValaCCodeBinaryOperator value); ValaCCodeExpression* vala_ccode_binary_expression_get_left (ValaCCodeBinaryExpression* self); void vala_ccode_binary_expression_set_left (ValaCCodeBinaryExpression* self, ValaCCodeExpression* value); ValaCCodeExpression* vala_ccode_binary_expression_get_right (ValaCCodeBinaryExpression* self); void vala_ccode_binary_expression_set_right (ValaCCodeBinaryExpression* self, ValaCCodeExpression* value); GType vala_ccode_statement_get_type (void) G_GNUC_CONST; GType vala_ccode_block_get_type (void) G_GNUC_CONST; void vala_ccode_block_prepend_statement (ValaCCodeBlock* self, ValaCCodeNode* statement); void vala_ccode_block_add_statement (ValaCCodeBlock* self, ValaCCodeNode* statement); ValaCCodeBlock* vala_ccode_block_new (void); ValaCCodeBlock* vala_ccode_block_construct (GType object_type); gboolean vala_ccode_block_get_suppress_newline (ValaCCodeBlock* self); void vala_ccode_block_set_suppress_newline (ValaCCodeBlock* self, gboolean value); GType vala_ccode_break_statement_get_type (void) G_GNUC_CONST; ValaCCodeBreakStatement* vala_ccode_break_statement_new (void); ValaCCodeBreakStatement* vala_ccode_break_statement_construct (GType object_type); GType vala_ccode_case_statement_get_type (void) G_GNUC_CONST; ValaCCodeCaseStatement* vala_ccode_case_statement_new (ValaCCodeExpression* expression); ValaCCodeCaseStatement* vala_ccode_case_statement_construct (GType object_type, ValaCCodeExpression* expression); ValaCCodeExpression* vala_ccode_case_statement_get_expression (ValaCCodeCaseStatement* self); void vala_ccode_case_statement_set_expression (ValaCCodeCaseStatement* self, ValaCCodeExpression* value); GType vala_ccode_cast_expression_get_type (void) G_GNUC_CONST; ValaCCodeCastExpression* vala_ccode_cast_expression_new (ValaCCodeExpression* expr, const gchar* type); ValaCCodeCastExpression* vala_ccode_cast_expression_construct (GType object_type, ValaCCodeExpression* expr, const gchar* type); ValaCCodeExpression* vala_ccode_cast_expression_get_inner (ValaCCodeCastExpression* self); void vala_ccode_cast_expression_set_inner (ValaCCodeCastExpression* self, ValaCCodeExpression* value); const gchar* vala_ccode_cast_expression_get_type_name (ValaCCodeCastExpression* self); void vala_ccode_cast_expression_set_type_name (ValaCCodeCastExpression* self, const gchar* value); GType vala_ccode_comma_expression_get_type (void) G_GNUC_CONST; void vala_ccode_comma_expression_append_expression (ValaCCodeCommaExpression* self, ValaCCodeExpression* expr); void vala_ccode_comma_expression_set_expression (ValaCCodeCommaExpression* self, gint index, ValaCCodeExpression* expr); ValaList* vala_ccode_comma_expression_get_inner (ValaCCodeCommaExpression* self); ValaCCodeCommaExpression* vala_ccode_comma_expression_new (void); ValaCCodeCommaExpression* vala_ccode_comma_expression_construct (GType object_type); GType vala_ccode_comment_get_type (void) G_GNUC_CONST; ValaCCodeComment* vala_ccode_comment_new (const gchar* _text); ValaCCodeComment* vala_ccode_comment_construct (GType object_type, const gchar* _text); const gchar* vala_ccode_comment_get_text (ValaCCodeComment* self); void vala_ccode_comment_set_text (ValaCCodeComment* self, const gchar* value); GType vala_ccode_conditional_expression_get_type (void) G_GNUC_CONST; ValaCCodeConditionalExpression* vala_ccode_conditional_expression_new (ValaCCodeExpression* cond, ValaCCodeExpression* true_expr, ValaCCodeExpression* false_expr); ValaCCodeConditionalExpression* vala_ccode_conditional_expression_construct (GType object_type, ValaCCodeExpression* cond, ValaCCodeExpression* true_expr, ValaCCodeExpression* false_expr); ValaCCodeExpression* vala_ccode_conditional_expression_get_condition (ValaCCodeConditionalExpression* self); void vala_ccode_conditional_expression_set_condition (ValaCCodeConditionalExpression* self, ValaCCodeExpression* value); ValaCCodeExpression* vala_ccode_conditional_expression_get_true_expression (ValaCCodeConditionalExpression* self); void vala_ccode_conditional_expression_set_true_expression (ValaCCodeConditionalExpression* self, ValaCCodeExpression* value); ValaCCodeExpression* vala_ccode_conditional_expression_get_false_expression (ValaCCodeConditionalExpression* self); void vala_ccode_conditional_expression_set_false_expression (ValaCCodeConditionalExpression* self, ValaCCodeExpression* value); GType vala_ccode_constant_get_type (void) G_GNUC_CONST; ValaCCodeConstant* vala_ccode_constant_new (const gchar* _name); ValaCCodeConstant* vala_ccode_constant_construct (GType object_type, const gchar* _name); ValaCCodeConstant* vala_ccode_constant_new_string (const gchar* _name); ValaCCodeConstant* vala_ccode_constant_construct_string (GType object_type, const gchar* _name); const gchar* vala_ccode_constant_get_name (ValaCCodeConstant* self); void vala_ccode_constant_set_name (ValaCCodeConstant* self, const gchar* value); GType vala_ccode_continue_statement_get_type (void) G_GNUC_CONST; ValaCCodeContinueStatement* vala_ccode_continue_statement_new (void); ValaCCodeContinueStatement* vala_ccode_continue_statement_construct (GType object_type); GType vala_ccode_declaration_get_type (void) G_GNUC_CONST; ValaCCodeDeclaration* vala_ccode_declaration_new (const gchar* type_name); ValaCCodeDeclaration* vala_ccode_declaration_construct (GType object_type, const gchar* type_name); GType vala_ccode_declarator_get_type (void) G_GNUC_CONST; void vala_ccode_declaration_add_declarator (ValaCCodeDeclaration* self, ValaCCodeDeclarator* decl); const gchar* vala_ccode_declaration_get_type_name (ValaCCodeDeclaration* self); void vala_ccode_declaration_set_type_name (ValaCCodeDeclaration* self, const gchar* value); void vala_ccode_declarator_write_initialization (ValaCCodeDeclarator* self, ValaCCodeWriter* writer); ValaCCodeDeclarator* vala_ccode_declarator_construct (GType object_type); GType vala_ccode_do_statement_get_type (void) G_GNUC_CONST; ValaCCodeDoStatement* vala_ccode_do_statement_new (ValaCCodeStatement* stmt, ValaCCodeExpression* cond); ValaCCodeDoStatement* vala_ccode_do_statement_construct (GType object_type, ValaCCodeStatement* stmt, ValaCCodeExpression* cond); ValaCCodeStatement* vala_ccode_do_statement_get_body (ValaCCodeDoStatement* self); void vala_ccode_do_statement_set_body (ValaCCodeDoStatement* self, ValaCCodeStatement* value); ValaCCodeExpression* vala_ccode_do_statement_get_condition (ValaCCodeDoStatement* self); void vala_ccode_do_statement_set_condition (ValaCCodeDoStatement* self, ValaCCodeExpression* value); GType vala_ccode_empty_statement_get_type (void) G_GNUC_CONST; ValaCCodeEmptyStatement* vala_ccode_empty_statement_new (void); ValaCCodeEmptyStatement* vala_ccode_empty_statement_construct (GType object_type); GType vala_ccode_enum_get_type (void) G_GNUC_CONST; ValaCCodeEnum* vala_ccode_enum_new (const gchar* name); ValaCCodeEnum* vala_ccode_enum_construct (GType object_type, const gchar* name); GType vala_ccode_enum_value_get_type (void) G_GNUC_CONST; void vala_ccode_enum_add_value (ValaCCodeEnum* self, ValaCCodeEnumValue* value); const gchar* vala_ccode_enum_get_name (ValaCCodeEnum* self); void vala_ccode_enum_set_name (ValaCCodeEnum* self, const gchar* value); ValaCCodeEnumValue* vala_ccode_enum_value_new (const gchar* name, ValaCCodeExpression* value); ValaCCodeEnumValue* vala_ccode_enum_value_construct (GType object_type, const gchar* name, ValaCCodeExpression* value); const gchar* vala_ccode_enum_value_get_name (ValaCCodeEnumValue* self); void vala_ccode_enum_value_set_name (ValaCCodeEnumValue* self, const gchar* value); ValaCCodeExpression* vala_ccode_enum_value_get_value (ValaCCodeEnumValue* self); void vala_ccode_enum_value_set_value (ValaCCodeEnumValue* self, ValaCCodeExpression* value); void vala_ccode_expression_write_inner (ValaCCodeExpression* self, ValaCCodeWriter* writer); ValaCCodeExpression* vala_ccode_expression_construct (GType object_type); GType vala_ccode_expression_statement_get_type (void) G_GNUC_CONST; ValaCCodeExpressionStatement* vala_ccode_expression_statement_new (ValaCCodeExpression* expr); ValaCCodeExpressionStatement* vala_ccode_expression_statement_construct (GType object_type, ValaCCodeExpression* expr); ValaCCodeExpression* vala_ccode_expression_statement_get_expression (ValaCCodeExpressionStatement* self); void vala_ccode_expression_statement_set_expression (ValaCCodeExpressionStatement* self, ValaCCodeExpression* value); gpointer vala_ccode_file_ref (gpointer instance); void vala_ccode_file_unref (gpointer instance); GParamSpec* vala_param_spec_ccode_file (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_ccode_file (GValue* value, gpointer v_object); void vala_value_take_ccode_file (GValue* value, gpointer v_object); gpointer vala_value_get_ccode_file (const GValue* value); GType vala_ccode_file_get_type (void) G_GNUC_CONST; gboolean vala_ccode_file_add_declaration (ValaCCodeFile* self, const gchar* name); void vala_ccode_file_add_comment (ValaCCodeFile* self, ValaCCodeComment* comment); void vala_ccode_file_add_include (ValaCCodeFile* self, const gchar* filename, gboolean local); void vala_ccode_file_add_type_declaration (ValaCCodeFile* self, ValaCCodeNode* node); void vala_ccode_file_add_type_definition (ValaCCodeFile* self, ValaCCodeNode* node); void vala_ccode_file_add_type_member_declaration (ValaCCodeFile* self, ValaCCodeNode* node); void vala_ccode_file_add_constant_declaration (ValaCCodeFile* self, ValaCCodeNode* node); void vala_ccode_file_add_type_member_definition (ValaCCodeFile* self, ValaCCodeNode* node); GType vala_ccode_function_get_type (void) G_GNUC_CONST; void vala_ccode_file_add_function_declaration (ValaCCodeFile* self, ValaCCodeFunction* func); void vala_ccode_file_add_function (ValaCCodeFile* self, ValaCCodeFunction* func); ValaList* vala_ccode_file_get_symbols (ValaCCodeFile* self); gboolean vala_ccode_file_store (ValaCCodeFile* self, const gchar* filename, const gchar* source_filename, gboolean write_version, gboolean line_directives, const gchar* begin_decls, const gchar* end_decls); ValaCCodeFile* vala_ccode_file_new (void); ValaCCodeFile* vala_ccode_file_construct (GType object_type); gboolean vala_ccode_file_get_is_header (ValaCCodeFile* self); void vala_ccode_file_set_is_header (ValaCCodeFile* self, gboolean value); GType vala_ccode_for_statement_get_type (void) G_GNUC_CONST; ValaCCodeForStatement* vala_ccode_for_statement_new (ValaCCodeExpression* condition, ValaCCodeStatement* body); ValaCCodeForStatement* vala_ccode_for_statement_construct (GType object_type, ValaCCodeExpression* condition, ValaCCodeStatement* body); void vala_ccode_for_statement_add_initializer (ValaCCodeForStatement* self, ValaCCodeExpression* expr); void vala_ccode_for_statement_add_iterator (ValaCCodeForStatement* self, ValaCCodeExpression* expr); ValaCCodeExpression* vala_ccode_for_statement_get_condition (ValaCCodeForStatement* self); void vala_ccode_for_statement_set_condition (ValaCCodeForStatement* self, ValaCCodeExpression* value); ValaCCodeStatement* vala_ccode_for_statement_get_body (ValaCCodeForStatement* self); void vala_ccode_for_statement_set_body (ValaCCodeForStatement* self, ValaCCodeStatement* value); GType vala_ccode_fragment_get_type (void) G_GNUC_CONST; void vala_ccode_fragment_append (ValaCCodeFragment* self, ValaCCodeNode* node); ValaList* vala_ccode_fragment_get_children (ValaCCodeFragment* self); ValaCCodeFragment* vala_ccode_fragment_new (void); ValaCCodeFragment* vala_ccode_fragment_construct (GType object_type); ValaCCodeFunction* vala_ccode_function_new (const gchar* name, const gchar* return_type); ValaCCodeFunction* vala_ccode_function_construct (GType object_type, const gchar* name, const gchar* return_type); GType vala_ccode_parameter_get_type (void) G_GNUC_CONST; void vala_ccode_function_add_parameter (ValaCCodeFunction* self, ValaCCodeParameter* param); void vala_ccode_function_insert_parameter (ValaCCodeFunction* self, gint position, ValaCCodeParameter* param); gint vala_ccode_function_get_parameter_count (ValaCCodeFunction* self); ValaCCodeParameter* vala_ccode_function_get_parameter (ValaCCodeFunction* self, gint position); ValaCCodeFunction* vala_ccode_function_copy (ValaCCodeFunction* self); void vala_ccode_function_add_statement (ValaCCodeFunction* self, ValaCCodeNode* stmt); void vala_ccode_function_open_block (ValaCCodeFunction* self); void vala_ccode_function_open_if (ValaCCodeFunction* self, ValaCCodeExpression* condition); void vala_ccode_function_add_else (ValaCCodeFunction* self); void vala_ccode_function_else_if (ValaCCodeFunction* self, ValaCCodeExpression* condition); void vala_ccode_function_open_while (ValaCCodeFunction* self, ValaCCodeExpression* condition); void vala_ccode_function_open_for (ValaCCodeFunction* self, ValaCCodeExpression* initializer, ValaCCodeExpression* condition, ValaCCodeExpression* iterator); void vala_ccode_function_open_switch (ValaCCodeFunction* self, ValaCCodeExpression* expression); void vala_ccode_function_add_label (ValaCCodeFunction* self, const gchar* label); void vala_ccode_function_add_case (ValaCCodeFunction* self, ValaCCodeExpression* expression); void vala_ccode_function_add_default (ValaCCodeFunction* self); void vala_ccode_function_add_goto (ValaCCodeFunction* self, const gchar* target); void vala_ccode_function_add_expression (ValaCCodeFunction* self, ValaCCodeExpression* expression); void vala_ccode_function_add_assignment (ValaCCodeFunction* self, ValaCCodeExpression* left, ValaCCodeExpression* right); void vala_ccode_function_add_return (ValaCCodeFunction* self, ValaCCodeExpression* expression); void vala_ccode_function_add_break (ValaCCodeFunction* self); void vala_ccode_function_add_continue (ValaCCodeFunction* self); GType vala_ccode_modifiers_get_type (void) G_GNUC_CONST; void vala_ccode_function_add_declaration (ValaCCodeFunction* self, const gchar* type_name, ValaCCodeDeclarator* declarator, ValaCCodeModifiers modifiers); void vala_ccode_function_close (ValaCCodeFunction* self); const gchar* vala_ccode_function_get_name (ValaCCodeFunction* self); void vala_ccode_function_set_name (ValaCCodeFunction* self, const gchar* value); const gchar* vala_ccode_function_get_return_type (ValaCCodeFunction* self); void vala_ccode_function_set_return_type (ValaCCodeFunction* self, const gchar* value); gboolean vala_ccode_function_get_is_declaration (ValaCCodeFunction* self); void vala_ccode_function_set_is_declaration (ValaCCodeFunction* self, gboolean value); ValaCCodeBlock* vala_ccode_function_get_block (ValaCCodeFunction* self); void vala_ccode_function_set_block (ValaCCodeFunction* self, ValaCCodeBlock* value); GType vala_ccode_line_directive_get_type (void) G_GNUC_CONST; ValaCCodeLineDirective* vala_ccode_function_get_current_line (ValaCCodeFunction* self); void vala_ccode_function_set_current_line (ValaCCodeFunction* self, ValaCCodeLineDirective* value); ValaCCodeBlock* vala_ccode_function_get_current_block (ValaCCodeFunction* self); void vala_ccode_function_set_current_block (ValaCCodeFunction* self, ValaCCodeBlock* value); GType vala_ccode_function_call_get_type (void) G_GNUC_CONST; ValaCCodeFunctionCall* vala_ccode_function_call_new (ValaCCodeExpression* call); ValaCCodeFunctionCall* vala_ccode_function_call_construct (GType object_type, ValaCCodeExpression* call); void vala_ccode_function_call_add_argument (ValaCCodeFunctionCall* self, ValaCCodeExpression* expr); void vala_ccode_function_call_insert_argument (ValaCCodeFunctionCall* self, gint index, ValaCCodeExpression* expr); ValaList* vala_ccode_function_call_get_arguments (ValaCCodeFunctionCall* self); ValaCCodeExpression* vala_ccode_function_call_get_call (ValaCCodeFunctionCall* self); void vala_ccode_function_call_set_call (ValaCCodeFunctionCall* self, ValaCCodeExpression* value); GType vala_ccode_function_declarator_get_type (void) G_GNUC_CONST; ValaCCodeFunctionDeclarator* vala_ccode_function_declarator_new (const gchar* name); ValaCCodeFunctionDeclarator* vala_ccode_function_declarator_construct (GType object_type, const gchar* name); void vala_ccode_function_declarator_add_parameter (ValaCCodeFunctionDeclarator* self, ValaCCodeParameter* param); const gchar* vala_ccode_function_declarator_get_name (ValaCCodeFunctionDeclarator* self); void vala_ccode_function_declarator_set_name (ValaCCodeFunctionDeclarator* self, const gchar* value); GType vala_ccode_ggnuc_section_get_type (void) G_GNUC_CONST; GType vala_ggnuc_section_type_get_type (void) G_GNUC_CONST; ValaCCodeGGnucSection* vala_ccode_ggnuc_section_new (ValaGGnucSectionType t); ValaCCodeGGnucSection* vala_ccode_ggnuc_section_construct (GType object_type, ValaGGnucSectionType t); ValaGGnucSectionType vala_ccode_ggnuc_section_get_section_type (ValaCCodeGGnucSection* self); void vala_ccode_ggnuc_section_set_section_type (ValaCCodeGGnucSection* self, ValaGGnucSectionType value); const gchar* vala_ggnuc_section_type_to_string (ValaGGnucSectionType self); GType vala_ccode_goto_statement_get_type (void) G_GNUC_CONST; ValaCCodeGotoStatement* vala_ccode_goto_statement_new (const gchar* name); ValaCCodeGotoStatement* vala_ccode_goto_statement_construct (GType object_type, const gchar* name); const gchar* vala_ccode_goto_statement_get_name (ValaCCodeGotoStatement* self); void vala_ccode_goto_statement_set_name (ValaCCodeGotoStatement* self, const gchar* value); GType vala_ccode_identifier_get_type (void) G_GNUC_CONST; ValaCCodeIdentifier* vala_ccode_identifier_new (const gchar* _name); ValaCCodeIdentifier* vala_ccode_identifier_construct (GType object_type, const gchar* _name); const gchar* vala_ccode_identifier_get_name (ValaCCodeIdentifier* self); void vala_ccode_identifier_set_name (ValaCCodeIdentifier* self, const gchar* value); GType vala_ccode_if_statement_get_type (void) G_GNUC_CONST; ValaCCodeIfStatement* vala_ccode_if_statement_new (ValaCCodeExpression* cond, ValaCCodeStatement* true_stmt, ValaCCodeStatement* false_stmt); ValaCCodeIfStatement* vala_ccode_if_statement_construct (GType object_type, ValaCCodeExpression* cond, ValaCCodeStatement* true_stmt, ValaCCodeStatement* false_stmt); ValaCCodeExpression* vala_ccode_if_statement_get_condition (ValaCCodeIfStatement* self); void vala_ccode_if_statement_set_condition (ValaCCodeIfStatement* self, ValaCCodeExpression* value); ValaCCodeStatement* vala_ccode_if_statement_get_true_statement (ValaCCodeIfStatement* self); void vala_ccode_if_statement_set_true_statement (ValaCCodeIfStatement* self, ValaCCodeStatement* value); ValaCCodeStatement* vala_ccode_if_statement_get_false_statement (ValaCCodeIfStatement* self); void vala_ccode_if_statement_set_false_statement (ValaCCodeIfStatement* self, ValaCCodeStatement* value); gboolean vala_ccode_if_statement_get_else_if (ValaCCodeIfStatement* self); void vala_ccode_if_statement_set_else_if (ValaCCodeIfStatement* self, gboolean value); GType vala_ccode_include_directive_get_type (void) G_GNUC_CONST; ValaCCodeIncludeDirective* vala_ccode_include_directive_new (const gchar* _filename, gboolean _local); ValaCCodeIncludeDirective* vala_ccode_include_directive_construct (GType object_type, const gchar* _filename, gboolean _local); const gchar* vala_ccode_include_directive_get_filename (ValaCCodeIncludeDirective* self); void vala_ccode_include_directive_set_filename (ValaCCodeIncludeDirective* self, const gchar* value); gboolean vala_ccode_include_directive_get_local (ValaCCodeIncludeDirective* self); void vala_ccode_include_directive_set_local (ValaCCodeIncludeDirective* self, gboolean value); GType vala_ccode_initializer_list_get_type (void) G_GNUC_CONST; void vala_ccode_initializer_list_append (ValaCCodeInitializerList* self, ValaCCodeExpression* expr); ValaCCodeInitializerList* vala_ccode_initializer_list_new (void); ValaCCodeInitializerList* vala_ccode_initializer_list_construct (GType object_type); GType vala_ccode_invalid_expression_get_type (void) G_GNUC_CONST; ValaCCodeInvalidExpression* vala_ccode_invalid_expression_new (void); ValaCCodeInvalidExpression* vala_ccode_invalid_expression_construct (GType object_type); GType vala_ccode_label_get_type (void) G_GNUC_CONST; ValaCCodeLabel* vala_ccode_label_new (const gchar* name); ValaCCodeLabel* vala_ccode_label_construct (GType object_type, const gchar* name); const gchar* vala_ccode_label_get_name (ValaCCodeLabel* self); void vala_ccode_label_set_name (ValaCCodeLabel* self, const gchar* value); ValaCCodeLineDirective* vala_ccode_line_directive_new (const gchar* _filename, gint _line); ValaCCodeLineDirective* vala_ccode_line_directive_construct (GType object_type, const gchar* _filename, gint _line); const gchar* vala_ccode_line_directive_get_filename (ValaCCodeLineDirective* self); void vala_ccode_line_directive_set_filename (ValaCCodeLineDirective* self, const gchar* value); gint vala_ccode_line_directive_get_line_number (ValaCCodeLineDirective* self); void vala_ccode_line_directive_set_line_number (ValaCCodeLineDirective* self, gint value); GType vala_ccode_if_section_get_type (void) G_GNUC_CONST; ValaCCodeIfSection* vala_ccode_if_section_new (const gchar* expr); ValaCCodeIfSection* vala_ccode_if_section_construct (GType object_type, const gchar* expr); const gchar* vala_ccode_if_section_get_expression (ValaCCodeIfSection* self); void vala_ccode_if_section_set_expression (ValaCCodeIfSection* self, const gchar* value); GType vala_ccode_macro_replacement_get_type (void) G_GNUC_CONST; ValaCCodeMacroReplacement* vala_ccode_macro_replacement_new (const gchar* name, const gchar* replacement); ValaCCodeMacroReplacement* vala_ccode_macro_replacement_construct (GType object_type, const gchar* name, const gchar* replacement); ValaCCodeMacroReplacement* vala_ccode_macro_replacement_new_with_expression (const gchar* name, ValaCCodeExpression* replacement_expression); ValaCCodeMacroReplacement* vala_ccode_macro_replacement_construct_with_expression (GType object_type, const gchar* name, ValaCCodeExpression* replacement_expression); const gchar* vala_ccode_macro_replacement_get_name (ValaCCodeMacroReplacement* self); void vala_ccode_macro_replacement_set_name (ValaCCodeMacroReplacement* self, const gchar* value); const gchar* vala_ccode_macro_replacement_get_replacement (ValaCCodeMacroReplacement* self); void vala_ccode_macro_replacement_set_replacement (ValaCCodeMacroReplacement* self, const gchar* value); ValaCCodeExpression* vala_ccode_macro_replacement_get_replacement_expression (ValaCCodeMacroReplacement* self); void vala_ccode_macro_replacement_set_replacement_expression (ValaCCodeMacroReplacement* self, ValaCCodeExpression* value); GType vala_ccode_member_access_get_type (void) G_GNUC_CONST; ValaCCodeMemberAccess* vala_ccode_member_access_new (ValaCCodeExpression* container, const gchar* member, gboolean pointer); ValaCCodeMemberAccess* vala_ccode_member_access_construct (GType object_type, ValaCCodeExpression* container, const gchar* member, gboolean pointer); ValaCCodeMemberAccess* vala_ccode_member_access_new_pointer (ValaCCodeExpression* container, const gchar* member); ValaCCodeMemberAccess* vala_ccode_member_access_construct_pointer (GType object_type, ValaCCodeExpression* container, const gchar* member); ValaCCodeExpression* vala_ccode_member_access_get_inner (ValaCCodeMemberAccess* self); void vala_ccode_member_access_set_inner (ValaCCodeMemberAccess* self, ValaCCodeExpression* value); const gchar* vala_ccode_member_access_get_member_name (ValaCCodeMemberAccess* self); void vala_ccode_member_access_set_member_name (ValaCCodeMemberAccess* self, const gchar* value); gboolean vala_ccode_member_access_get_is_pointer (ValaCCodeMemberAccess* self); void vala_ccode_member_access_set_is_pointer (ValaCCodeMemberAccess* self, gboolean value); GType vala_ccode_newline_get_type (void) G_GNUC_CONST; ValaCCodeNewline* vala_ccode_newline_new (void); ValaCCodeNewline* vala_ccode_newline_construct (GType object_type); void vala_ccode_node_write (ValaCCodeNode* self, ValaCCodeWriter* writer); void vala_ccode_node_write_declaration (ValaCCodeNode* self, ValaCCodeWriter* writer); void vala_ccode_node_write_combined (ValaCCodeNode* self, ValaCCodeWriter* writer); ValaCCodeNode* vala_ccode_node_construct (GType object_type); ValaCCodeLineDirective* vala_ccode_node_get_line (ValaCCodeNode* self); void vala_ccode_node_set_line (ValaCCodeNode* self, ValaCCodeLineDirective* value); ValaCCodeModifiers vala_ccode_node_get_modifiers (ValaCCodeNode* self); void vala_ccode_node_set_modifiers (ValaCCodeNode* self, ValaCCodeModifiers value); GType vala_ccode_once_section_get_type (void) G_GNUC_CONST; ValaCCodeOnceSection* vala_ccode_once_section_new (const gchar* def); ValaCCodeOnceSection* vala_ccode_once_section_construct (GType object_type, const gchar* def); const gchar* vala_ccode_once_section_get_define (ValaCCodeOnceSection* self); void vala_ccode_once_section_set_define (ValaCCodeOnceSection* self, const gchar* value); ValaCCodeParameter* vala_ccode_parameter_new (const gchar* n, const gchar* type); ValaCCodeParameter* vala_ccode_parameter_construct (GType object_type, const gchar* n, const gchar* type); ValaCCodeParameter* vala_ccode_parameter_new_with_ellipsis (void); ValaCCodeParameter* vala_ccode_parameter_construct_with_ellipsis (GType object_type); const gchar* vala_ccode_parameter_get_name (ValaCCodeParameter* self); void vala_ccode_parameter_set_name (ValaCCodeParameter* self, const gchar* value); const gchar* vala_ccode_parameter_get_type_name (ValaCCodeParameter* self); void vala_ccode_parameter_set_type_name (ValaCCodeParameter* self, const gchar* value); gboolean vala_ccode_parameter_get_ellipsis (ValaCCodeParameter* self); void vala_ccode_parameter_set_ellipsis (ValaCCodeParameter* self, gboolean value); GType vala_ccode_parenthesized_expression_get_type (void) G_GNUC_CONST; ValaCCodeParenthesizedExpression* vala_ccode_parenthesized_expression_new (ValaCCodeExpression* expr); ValaCCodeParenthesizedExpression* vala_ccode_parenthesized_expression_construct (GType object_type, ValaCCodeExpression* expr); ValaCCodeExpression* vala_ccode_parenthesized_expression_get_inner (ValaCCodeParenthesizedExpression* self); void vala_ccode_parenthesized_expression_set_inner (ValaCCodeParenthesizedExpression* self, ValaCCodeExpression* value); GType vala_ccode_return_statement_get_type (void) G_GNUC_CONST; ValaCCodeReturnStatement* vala_ccode_return_statement_new (ValaCCodeExpression* expr); ValaCCodeReturnStatement* vala_ccode_return_statement_construct (GType object_type, ValaCCodeExpression* expr); ValaCCodeExpression* vala_ccode_return_statement_get_return_expression (ValaCCodeReturnStatement* self); void vala_ccode_return_statement_set_return_expression (ValaCCodeReturnStatement* self, ValaCCodeExpression* value); ValaCCodeStatement* vala_ccode_statement_construct (GType object_type); GType vala_ccode_struct_get_type (void) G_GNUC_CONST; ValaCCodeStruct* vala_ccode_struct_new (const gchar* name); ValaCCodeStruct* vala_ccode_struct_construct (GType object_type, const gchar* name); void vala_ccode_struct_add_declaration (ValaCCodeStruct* self, ValaCCodeDeclaration* decl); gpointer vala_ccode_declarator_suffix_ref (gpointer instance); void vala_ccode_declarator_suffix_unref (gpointer instance); GParamSpec* vala_param_spec_ccode_declarator_suffix (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_ccode_declarator_suffix (GValue* value, gpointer v_object); void vala_value_take_ccode_declarator_suffix (GValue* value, gpointer v_object); gpointer vala_value_get_ccode_declarator_suffix (const GValue* value); GType vala_ccode_declarator_suffix_get_type (void) G_GNUC_CONST; void vala_ccode_struct_add_field (ValaCCodeStruct* self, const gchar* type_name, const gchar* name, ValaCCodeModifiers modifiers, ValaCCodeDeclaratorSuffix* declarator_suffix); const gchar* vala_ccode_struct_get_name (ValaCCodeStruct* self); void vala_ccode_struct_set_name (ValaCCodeStruct* self, const gchar* value); gboolean vala_ccode_struct_get_is_empty (ValaCCodeStruct* self); GType vala_ccode_switch_statement_get_type (void) G_GNUC_CONST; ValaCCodeSwitchStatement* vala_ccode_switch_statement_new (ValaCCodeExpression* expression); ValaCCodeSwitchStatement* vala_ccode_switch_statement_construct (GType object_type, ValaCCodeExpression* expression); ValaCCodeExpression* vala_ccode_switch_statement_get_expression (ValaCCodeSwitchStatement* self); void vala_ccode_switch_statement_set_expression (ValaCCodeSwitchStatement* self, ValaCCodeExpression* value); GType vala_ccode_type_definition_get_type (void) G_GNUC_CONST; ValaCCodeTypeDefinition* vala_ccode_type_definition_new (const gchar* type, ValaCCodeDeclarator* decl); ValaCCodeTypeDefinition* vala_ccode_type_definition_construct (GType object_type, const gchar* type, ValaCCodeDeclarator* decl); const gchar* vala_ccode_type_definition_get_type_name (ValaCCodeTypeDefinition* self); void vala_ccode_type_definition_set_type_name (ValaCCodeTypeDefinition* self, const gchar* value); ValaCCodeDeclarator* vala_ccode_type_definition_get_declarator (ValaCCodeTypeDefinition* self); void vala_ccode_type_definition_set_declarator (ValaCCodeTypeDefinition* self, ValaCCodeDeclarator* value); GType vala_ccode_unary_expression_get_type (void) G_GNUC_CONST; GType vala_ccode_unary_operator_get_type (void) G_GNUC_CONST; ValaCCodeUnaryExpression* vala_ccode_unary_expression_new (ValaCCodeUnaryOperator op, ValaCCodeExpression* expr); ValaCCodeUnaryExpression* vala_ccode_unary_expression_construct (GType object_type, ValaCCodeUnaryOperator op, ValaCCodeExpression* expr); ValaCCodeUnaryOperator vala_ccode_unary_expression_get_operator (ValaCCodeUnaryExpression* self); void vala_ccode_unary_expression_set_operator (ValaCCodeUnaryExpression* self, ValaCCodeUnaryOperator value); ValaCCodeExpression* vala_ccode_unary_expression_get_inner (ValaCCodeUnaryExpression* self); void vala_ccode_unary_expression_set_inner (ValaCCodeUnaryExpression* self, ValaCCodeExpression* value); GType vala_ccode_variable_declarator_get_type (void) G_GNUC_CONST; ValaCCodeVariableDeclarator* vala_ccode_variable_declarator_new (const gchar* name, ValaCCodeExpression* initializer, ValaCCodeDeclaratorSuffix* declarator_suffix); ValaCCodeVariableDeclarator* vala_ccode_variable_declarator_construct (GType object_type, const gchar* name, ValaCCodeExpression* initializer, ValaCCodeDeclaratorSuffix* declarator_suffix); ValaCCodeVariableDeclarator* vala_ccode_variable_declarator_new_zero (const gchar* name, ValaCCodeExpression* initializer, ValaCCodeDeclaratorSuffix* declarator_suffix); ValaCCodeVariableDeclarator* vala_ccode_variable_declarator_construct_zero (GType object_type, const gchar* name, ValaCCodeExpression* initializer, ValaCCodeDeclaratorSuffix* declarator_suffix); const gchar* vala_ccode_variable_declarator_get_name (ValaCCodeVariableDeclarator* self); void vala_ccode_variable_declarator_set_name (ValaCCodeVariableDeclarator* self, const gchar* value); ValaCCodeExpression* vala_ccode_variable_declarator_get_initializer (ValaCCodeVariableDeclarator* self); void vala_ccode_variable_declarator_set_initializer (ValaCCodeVariableDeclarator* self, ValaCCodeExpression* value); ValaCCodeDeclaratorSuffix* vala_ccode_variable_declarator_get_declarator_suffix (ValaCCodeVariableDeclarator* self); void vala_ccode_variable_declarator_set_declarator_suffix (ValaCCodeVariableDeclarator* self, ValaCCodeDeclaratorSuffix* value); gboolean vala_ccode_variable_declarator_get_init0 (ValaCCodeVariableDeclarator* self); void vala_ccode_variable_declarator_set_init0 (ValaCCodeVariableDeclarator* self, gboolean value); ValaCCodeDeclaratorSuffix* vala_ccode_declarator_suffix_new_with_array (ValaCCodeExpression* array_length); ValaCCodeDeclaratorSuffix* vala_ccode_declarator_suffix_construct_with_array (GType object_type, ValaCCodeExpression* array_length); void vala_ccode_declarator_suffix_write (ValaCCodeDeclaratorSuffix* self, ValaCCodeWriter* writer); ValaCCodeDeclaratorSuffix* vala_ccode_declarator_suffix_new (void); ValaCCodeDeclaratorSuffix* vala_ccode_declarator_suffix_construct (GType object_type); GType vala_ccode_while_statement_get_type (void) G_GNUC_CONST; ValaCCodeWhileStatement* vala_ccode_while_statement_new (ValaCCodeExpression* cond, ValaCCodeStatement* stmt); ValaCCodeWhileStatement* vala_ccode_while_statement_construct (GType object_type, ValaCCodeExpression* cond, ValaCCodeStatement* stmt); ValaCCodeExpression* vala_ccode_while_statement_get_condition (ValaCCodeWhileStatement* self); void vala_ccode_while_statement_set_condition (ValaCCodeWhileStatement* self, ValaCCodeExpression* value); ValaCCodeStatement* vala_ccode_while_statement_get_body (ValaCCodeWhileStatement* self); void vala_ccode_while_statement_set_body (ValaCCodeWhileStatement* self, ValaCCodeStatement* value); ValaCCodeWriter* vala_ccode_writer_new (const gchar* filename, const gchar* source_filename); ValaCCodeWriter* vala_ccode_writer_construct (GType object_type, const gchar* filename, const gchar* source_filename); gboolean vala_ccode_writer_open (ValaCCodeWriter* self, gboolean write_version); void vala_ccode_writer_close (ValaCCodeWriter* self); void vala_ccode_writer_write_indent (ValaCCodeWriter* self, ValaCCodeLineDirective* line); void vala_ccode_writer_write_nspaces (ValaCCodeWriter* self, guint n); void vala_ccode_writer_write_string (ValaCCodeWriter* self, const gchar* s); void vala_ccode_writer_write_newline (ValaCCodeWriter* self); void vala_ccode_writer_write_begin_block (ValaCCodeWriter* self); void vala_ccode_writer_write_end_block (ValaCCodeWriter* self); void vala_ccode_writer_write_comment (ValaCCodeWriter* self, const gchar* text); const gchar* vala_ccode_writer_get_filename (ValaCCodeWriter* self); void vala_ccode_writer_set_filename (ValaCCodeWriter* self, const gchar* value); gboolean vala_ccode_writer_get_line_directives (ValaCCodeWriter* self); void vala_ccode_writer_set_line_directives (ValaCCodeWriter* self, gboolean value); gboolean vala_ccode_writer_get_bol (ValaCCodeWriter* self); GType vala_ccode_element_access_get_type (void) G_GNUC_CONST; ValaCCodeElementAccess* vala_ccode_element_access_new (ValaCCodeExpression* cont, ValaCCodeExpression* i); ValaCCodeElementAccess* vala_ccode_element_access_construct (GType object_type, ValaCCodeExpression* cont, ValaCCodeExpression* i); ValaCCodeExpression* vala_ccode_element_access_get_container (ValaCCodeElementAccess* self); void vala_ccode_element_access_set_container (ValaCCodeElementAccess* self, ValaCCodeExpression* value); ValaCCodeExpression* vala_ccode_element_access_get_index (ValaCCodeElementAccess* self); void vala_ccode_element_access_set_index (ValaCCodeElementAccess* self, ValaCCodeExpression* value); G_END_DECLS #endif valabind-1.5.0/private/valacodegen.h000066400000000000000000002526121323123274000173750ustar00rootroot00000000000000/* valacodegen.h generated by valac, the Vala compiler, do not modify */ #ifndef __VALACODEGEN_H__ #define __VALACODEGEN_H__ #include #include #include #include #include #include #include #include #include G_BEGIN_DECLS #define VALA_TYPE_CCODE_BASE_MODULE (vala_ccode_base_module_get_type ()) #define VALA_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModule)) #define VALA_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass)) #define VALA_IS_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_BASE_MODULE)) #define VALA_IS_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_BASE_MODULE)) #define VALA_CCODE_BASE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass)) typedef struct _ValaCCodeBaseModule ValaCCodeBaseModule; typedef struct _ValaCCodeBaseModuleClass ValaCCodeBaseModuleClass; typedef struct _ValaCCodeBaseModulePrivate ValaCCodeBaseModulePrivate; #define VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT (vala_ccode_base_module_emit_context_get_type ()) #define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContext)) #define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass)) #define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT)) #define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT)) #define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass)) typedef struct _ValaCCodeBaseModuleEmitContext ValaCCodeBaseModuleEmitContext; typedef struct _ValaCCodeBaseModuleEmitContextClass ValaCCodeBaseModuleEmitContextClass; #define VALA_TYPE_CCODE_STRUCT_MODULE (vala_ccode_struct_module_get_type ()) #define VALA_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModule)) #define VALA_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass)) #define VALA_IS_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_STRUCT_MODULE)) #define VALA_IS_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_STRUCT_MODULE)) #define VALA_CCODE_STRUCT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass)) typedef struct _ValaCCodeStructModule ValaCCodeStructModule; typedef struct _ValaCCodeStructModuleClass ValaCCodeStructModuleClass; typedef struct _ValaCCodeStructModulePrivate ValaCCodeStructModulePrivate; #define VALA_TYPE_CCODE_METHOD_MODULE (vala_ccode_method_module_get_type ()) #define VALA_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModule)) #define VALA_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass)) #define VALA_IS_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_MODULE)) #define VALA_IS_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_MODULE)) #define VALA_CCODE_METHOD_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass)) typedef struct _ValaCCodeMethodModule ValaCCodeMethodModule; typedef struct _ValaCCodeMethodModuleClass ValaCCodeMethodModuleClass; typedef struct _ValaCCodeMethodModulePrivate ValaCCodeMethodModulePrivate; #define VALA_TYPE_CCODE_CONTROL_FLOW_MODULE (vala_ccode_control_flow_module_get_type ()) #define VALA_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModule)) #define VALA_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass)) #define VALA_IS_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE)) #define VALA_IS_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE)) #define VALA_CCODE_CONTROL_FLOW_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass)) typedef struct _ValaCCodeControlFlowModule ValaCCodeControlFlowModule; typedef struct _ValaCCodeControlFlowModuleClass ValaCCodeControlFlowModuleClass; typedef struct _ValaCCodeControlFlowModulePrivate ValaCCodeControlFlowModulePrivate; #define VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE (vala_ccode_member_access_module_get_type ()) #define VALA_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModule)) #define VALA_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass)) #define VALA_IS_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE)) #define VALA_IS_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE)) #define VALA_CCODE_MEMBER_ACCESS_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass)) typedef struct _ValaCCodeMemberAccessModule ValaCCodeMemberAccessModule; typedef struct _ValaCCodeMemberAccessModuleClass ValaCCodeMemberAccessModuleClass; typedef struct _ValaCCodeMemberAccessModulePrivate ValaCCodeMemberAccessModulePrivate; #define VALA_TYPE_CCODE_ASSIGNMENT_MODULE (vala_ccode_assignment_module_get_type ()) #define VALA_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModule)) #define VALA_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass)) #define VALA_IS_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE)) #define VALA_IS_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE)) #define VALA_CCODE_ASSIGNMENT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass)) typedef struct _ValaCCodeAssignmentModule ValaCCodeAssignmentModule; typedef struct _ValaCCodeAssignmentModuleClass ValaCCodeAssignmentModuleClass; typedef struct _ValaCCodeAssignmentModulePrivate ValaCCodeAssignmentModulePrivate; #define VALA_TYPE_CCODE_METHOD_CALL_MODULE (vala_ccode_method_call_module_get_type ()) #define VALA_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModule)) #define VALA_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass)) #define VALA_IS_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE)) #define VALA_IS_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE)) #define VALA_CCODE_METHOD_CALL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass)) typedef struct _ValaCCodeMethodCallModule ValaCCodeMethodCallModule; typedef struct _ValaCCodeMethodCallModuleClass ValaCCodeMethodCallModuleClass; typedef struct _ValaCCodeMethodCallModulePrivate ValaCCodeMethodCallModulePrivate; #define VALA_TYPE_CCODE_ARRAY_MODULE (vala_ccode_array_module_get_type ()) #define VALA_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModule)) #define VALA_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass)) #define VALA_IS_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ARRAY_MODULE)) #define VALA_IS_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ARRAY_MODULE)) #define VALA_CCODE_ARRAY_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass)) typedef struct _ValaCCodeArrayModule ValaCCodeArrayModule; typedef struct _ValaCCodeArrayModuleClass ValaCCodeArrayModuleClass; typedef struct _ValaCCodeArrayModulePrivate ValaCCodeArrayModulePrivate; #define VALA_TYPE_CCODE_ATTRIBUTE (vala_ccode_attribute_get_type ()) #define VALA_CCODE_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttribute)) #define VALA_CCODE_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttributeClass)) #define VALA_IS_CCODE_ATTRIBUTE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ATTRIBUTE)) #define VALA_IS_CCODE_ATTRIBUTE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ATTRIBUTE)) #define VALA_CCODE_ATTRIBUTE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttributeClass)) typedef struct _ValaCCodeAttribute ValaCCodeAttribute; typedef struct _ValaCCodeAttributeClass ValaCCodeAttributeClass; typedef struct _ValaCCodeAttributePrivate ValaCCodeAttributePrivate; typedef struct _ValaCCodeBaseModuleEmitContextPrivate ValaCCodeBaseModuleEmitContextPrivate; #define VALA_TYPE_CCODE_COMPILER (vala_ccode_compiler_get_type ()) #define VALA_CCODE_COMPILER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_COMPILER, ValaCCodeCompiler)) #define VALA_CCODE_COMPILER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_COMPILER, ValaCCodeCompilerClass)) #define VALA_IS_CCODE_COMPILER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_COMPILER)) #define VALA_IS_CCODE_COMPILER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_COMPILER)) #define VALA_CCODE_COMPILER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_COMPILER, ValaCCodeCompilerClass)) typedef struct _ValaCCodeCompiler ValaCCodeCompiler; typedef struct _ValaCCodeCompilerClass ValaCCodeCompilerClass; typedef struct _ValaCCodeCompilerPrivate ValaCCodeCompilerPrivate; #define VALA_TYPE_CCODE_DELEGATE_MODULE (vala_ccode_delegate_module_get_type ()) #define VALA_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModule)) #define VALA_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass)) #define VALA_IS_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE)) #define VALA_IS_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE)) #define VALA_CCODE_DELEGATE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass)) typedef struct _ValaCCodeDelegateModule ValaCCodeDelegateModule; typedef struct _ValaCCodeDelegateModuleClass ValaCCodeDelegateModuleClass; typedef struct _ValaCCodeDelegateModulePrivate ValaCCodeDelegateModulePrivate; #define VALA_TYPE_TYPEREGISTER_FUNCTION (vala_typeregister_function_get_type ()) #define VALA_TYPEREGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPEREGISTER_FUNCTION, ValaTypeRegisterFunction)) #define VALA_TYPEREGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPEREGISTER_FUNCTION, ValaTypeRegisterFunctionClass)) #define VALA_IS_TYPEREGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPEREGISTER_FUNCTION)) #define VALA_IS_TYPEREGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPEREGISTER_FUNCTION)) #define VALA_TYPEREGISTER_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPEREGISTER_FUNCTION, ValaTypeRegisterFunctionClass)) typedef struct _ValaTypeRegisterFunction ValaTypeRegisterFunction; typedef struct _ValaTypeRegisterFunctionClass ValaTypeRegisterFunctionClass; typedef struct _ValaTypeRegisterFunctionPrivate ValaTypeRegisterFunctionPrivate; #define VALA_TYPE_CLASS_REGISTER_FUNCTION (vala_class_register_function_get_type ()) #define VALA_CLASS_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CLASS_REGISTER_FUNCTION, ValaClassRegisterFunction)) #define VALA_CLASS_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CLASS_REGISTER_FUNCTION, ValaClassRegisterFunctionClass)) #define VALA_IS_CLASS_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CLASS_REGISTER_FUNCTION)) #define VALA_IS_CLASS_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CLASS_REGISTER_FUNCTION)) #define VALA_CLASS_REGISTER_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CLASS_REGISTER_FUNCTION, ValaClassRegisterFunctionClass)) typedef struct _ValaClassRegisterFunction ValaClassRegisterFunction; typedef struct _ValaClassRegisterFunctionClass ValaClassRegisterFunctionClass; typedef struct _ValaClassRegisterFunctionPrivate ValaClassRegisterFunctionPrivate; #define VALA_TYPE_CTYPE (vala_ctype_get_type ()) #define VALA_CTYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CTYPE, ValaCType)) #define VALA_CTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CTYPE, ValaCTypeClass)) #define VALA_IS_CTYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CTYPE)) #define VALA_IS_CTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CTYPE)) #define VALA_CTYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CTYPE, ValaCTypeClass)) typedef struct _ValaCType ValaCType; typedef struct _ValaCTypeClass ValaCTypeClass; typedef struct _ValaCTypePrivate ValaCTypePrivate; #define VALA_TYPE_ENUM_REGISTER_FUNCTION (vala_enum_register_function_get_type ()) #define VALA_ENUM_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM_REGISTER_FUNCTION, ValaEnumRegisterFunction)) #define VALA_ENUM_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM_REGISTER_FUNCTION, ValaEnumRegisterFunctionClass)) #define VALA_IS_ENUM_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM_REGISTER_FUNCTION)) #define VALA_IS_ENUM_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM_REGISTER_FUNCTION)) #define VALA_ENUM_REGISTER_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM_REGISTER_FUNCTION, ValaEnumRegisterFunctionClass)) typedef struct _ValaEnumRegisterFunction ValaEnumRegisterFunction; typedef struct _ValaEnumRegisterFunctionClass ValaEnumRegisterFunctionClass; typedef struct _ValaEnumRegisterFunctionPrivate ValaEnumRegisterFunctionPrivate; #define VALA_TYPE_GERROR_MODULE (vala_gerror_module_get_type ()) #define VALA_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModule)) #define VALA_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass)) #define VALA_IS_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GERROR_MODULE)) #define VALA_IS_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GERROR_MODULE)) #define VALA_GERROR_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass)) typedef struct _ValaGErrorModule ValaGErrorModule; typedef struct _ValaGErrorModuleClass ValaGErrorModuleClass; typedef struct _ValaGErrorModulePrivate ValaGErrorModulePrivate; #define VALA_TYPE_GTYPE_MODULE (vala_gtype_module_get_type ()) #define VALA_GTYPE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GTYPE_MODULE, ValaGTypeModule)) #define VALA_GTYPE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GTYPE_MODULE, ValaGTypeModuleClass)) #define VALA_IS_GTYPE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GTYPE_MODULE)) #define VALA_IS_GTYPE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GTYPE_MODULE)) #define VALA_GTYPE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GTYPE_MODULE, ValaGTypeModuleClass)) typedef struct _ValaGTypeModule ValaGTypeModule; typedef struct _ValaGTypeModuleClass ValaGTypeModuleClass; typedef struct _ValaGTypeModulePrivate ValaGTypeModulePrivate; #define VALA_TYPE_GOBJECT_MODULE (vala_gobject_module_get_type ()) #define VALA_GOBJECT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModule)) #define VALA_GOBJECT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModuleClass)) #define VALA_IS_GOBJECT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GOBJECT_MODULE)) #define VALA_IS_GOBJECT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GOBJECT_MODULE)) #define VALA_GOBJECT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModuleClass)) typedef struct _ValaGObjectModule ValaGObjectModule; typedef struct _ValaGObjectModuleClass ValaGObjectModuleClass; typedef struct _ValaGObjectModulePrivate ValaGObjectModulePrivate; #define VALA_TYPE_GSIGNAL_MODULE (vala_gsignal_module_get_type ()) #define VALA_GSIGNAL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModule)) #define VALA_GSIGNAL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModuleClass)) #define VALA_IS_GSIGNAL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GSIGNAL_MODULE)) #define VALA_IS_GSIGNAL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GSIGNAL_MODULE)) #define VALA_GSIGNAL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModuleClass)) typedef struct _ValaGSignalModule ValaGSignalModule; typedef struct _ValaGSignalModuleClass ValaGSignalModuleClass; typedef struct _ValaGSignalModulePrivate ValaGSignalModulePrivate; #define VALA_TYPE_GTK_MODULE (vala_gtk_module_get_type ()) #define VALA_GTK_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GTK_MODULE, ValaGtkModule)) #define VALA_GTK_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GTK_MODULE, ValaGtkModuleClass)) #define VALA_IS_GTK_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GTK_MODULE)) #define VALA_IS_GTK_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GTK_MODULE)) #define VALA_GTK_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GTK_MODULE, ValaGtkModuleClass)) typedef struct _ValaGtkModule ValaGtkModule; typedef struct _ValaGtkModuleClass ValaGtkModuleClass; typedef struct _ValaGtkModulePrivate ValaGtkModulePrivate; #define VALA_TYPE_GASYNC_MODULE (vala_gasync_module_get_type ()) #define VALA_GASYNC_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModule)) #define VALA_GASYNC_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModuleClass)) #define VALA_IS_GASYNC_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GASYNC_MODULE)) #define VALA_IS_GASYNC_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GASYNC_MODULE)) #define VALA_GASYNC_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModuleClass)) typedef struct _ValaGAsyncModule ValaGAsyncModule; typedef struct _ValaGAsyncModuleClass ValaGAsyncModuleClass; typedef struct _ValaGAsyncModulePrivate ValaGAsyncModulePrivate; #define VALA_TYPE_GVARIANT_MODULE (vala_gvariant_module_get_type ()) #define VALA_GVARIANT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GVARIANT_MODULE, ValaGVariantModule)) #define VALA_GVARIANT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GVARIANT_MODULE, ValaGVariantModuleClass)) #define VALA_IS_GVARIANT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GVARIANT_MODULE)) #define VALA_IS_GVARIANT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GVARIANT_MODULE)) #define VALA_GVARIANT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GVARIANT_MODULE, ValaGVariantModuleClass)) typedef struct _ValaGVariantModule ValaGVariantModule; typedef struct _ValaGVariantModuleClass ValaGVariantModuleClass; typedef struct _ValaGVariantModulePrivate ValaGVariantModulePrivate; #define VALA_TYPE_GD_BUS_MODULE (vala_gd_bus_module_get_type ()) #define VALA_GD_BUS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GD_BUS_MODULE, ValaGDBusModule)) #define VALA_GD_BUS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GD_BUS_MODULE, ValaGDBusModuleClass)) #define VALA_IS_GD_BUS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GD_BUS_MODULE)) #define VALA_IS_GD_BUS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GD_BUS_MODULE)) #define VALA_GD_BUS_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GD_BUS_MODULE, ValaGDBusModuleClass)) typedef struct _ValaGDBusModule ValaGDBusModule; typedef struct _ValaGDBusModuleClass ValaGDBusModuleClass; typedef struct _ValaGDBusModulePrivate ValaGDBusModulePrivate; #define VALA_TYPE_GD_BUS_CLIENT_MODULE (vala_gd_bus_client_module_get_type ()) #define VALA_GD_BUS_CLIENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule)) #define VALA_GD_BUS_CLIENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModuleClass)) #define VALA_IS_GD_BUS_CLIENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GD_BUS_CLIENT_MODULE)) #define VALA_IS_GD_BUS_CLIENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GD_BUS_CLIENT_MODULE)) #define VALA_GD_BUS_CLIENT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModuleClass)) typedef struct _ValaGDBusClientModule ValaGDBusClientModule; typedef struct _ValaGDBusClientModuleClass ValaGDBusClientModuleClass; typedef struct _ValaGDBusClientModulePrivate ValaGDBusClientModulePrivate; #define VALA_TYPE_GD_BUS_SERVER_MODULE (vala_gd_bus_server_module_get_type ()) #define VALA_GD_BUS_SERVER_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GD_BUS_SERVER_MODULE, ValaGDBusServerModule)) #define VALA_GD_BUS_SERVER_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GD_BUS_SERVER_MODULE, ValaGDBusServerModuleClass)) #define VALA_IS_GD_BUS_SERVER_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GD_BUS_SERVER_MODULE)) #define VALA_IS_GD_BUS_SERVER_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GD_BUS_SERVER_MODULE)) #define VALA_GD_BUS_SERVER_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GD_BUS_SERVER_MODULE, ValaGDBusServerModuleClass)) typedef struct _ValaGDBusServerModule ValaGDBusServerModule; typedef struct _ValaGDBusServerModuleClass ValaGDBusServerModuleClass; typedef struct _ValaGDBusServerModulePrivate ValaGDBusServerModulePrivate; #define VALA_TYPE_GIR_WRITER (vala_gir_writer_get_type ()) #define VALA_GIR_WRITER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GIR_WRITER, ValaGIRWriter)) #define VALA_GIR_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GIR_WRITER, ValaGIRWriterClass)) #define VALA_IS_GIR_WRITER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GIR_WRITER)) #define VALA_IS_GIR_WRITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GIR_WRITER)) #define VALA_GIR_WRITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GIR_WRITER, ValaGIRWriterClass)) typedef struct _ValaGIRWriter ValaGIRWriter; typedef struct _ValaGIRWriterClass ValaGIRWriterClass; typedef struct _ValaGIRWriterPrivate ValaGIRWriterPrivate; #define VALA_TYPE_INTERFACE_REGISTER_FUNCTION (vala_interface_register_function_get_type ()) #define VALA_INTERFACE_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_INTERFACE_REGISTER_FUNCTION, ValaInterfaceRegisterFunction)) #define VALA_INTERFACE_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_INTERFACE_REGISTER_FUNCTION, ValaInterfaceRegisterFunctionClass)) #define VALA_IS_INTERFACE_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_INTERFACE_REGISTER_FUNCTION)) #define VALA_IS_INTERFACE_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_INTERFACE_REGISTER_FUNCTION)) #define VALA_INTERFACE_REGISTER_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_INTERFACE_REGISTER_FUNCTION, ValaInterfaceRegisterFunctionClass)) typedef struct _ValaInterfaceRegisterFunction ValaInterfaceRegisterFunction; typedef struct _ValaInterfaceRegisterFunctionClass ValaInterfaceRegisterFunctionClass; typedef struct _ValaInterfaceRegisterFunctionPrivate ValaInterfaceRegisterFunctionPrivate; #define VALA_TYPE_STRUCT_REGISTER_FUNCTION (vala_struct_register_function_get_type ()) #define VALA_STRUCT_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_STRUCT_REGISTER_FUNCTION, ValaStructRegisterFunction)) #define VALA_STRUCT_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_STRUCT_REGISTER_FUNCTION, ValaStructRegisterFunctionClass)) #define VALA_IS_STRUCT_REGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_STRUCT_REGISTER_FUNCTION)) #define VALA_IS_STRUCT_REGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_STRUCT_REGISTER_FUNCTION)) #define VALA_STRUCT_REGISTER_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_STRUCT_REGISTER_FUNCTION, ValaStructRegisterFunctionClass)) typedef struct _ValaStructRegisterFunction ValaStructRegisterFunction; typedef struct _ValaStructRegisterFunctionClass ValaStructRegisterFunctionClass; typedef struct _ValaStructRegisterFunctionPrivate ValaStructRegisterFunctionPrivate; struct _ValaCCodeBaseModule { ValaCodeGenerator parent_instance; ValaCCodeBaseModulePrivate * priv; ValaSymbol* root_symbol; ValaCCodeBaseModuleEmitContext* emit_context; ValaCCodeLineDirective* current_line; ValaCCodeFile* header_file; ValaCCodeFile* internal_header_file; ValaCCodeFile* cfile; ValaCCodeBaseModuleEmitContext* class_init_context; ValaCCodeBaseModuleEmitContext* base_init_context; ValaCCodeBaseModuleEmitContext* class_finalize_context; ValaCCodeBaseModuleEmitContext* base_finalize_context; ValaCCodeBaseModuleEmitContext* instance_init_context; ValaCCodeBaseModuleEmitContext* instance_finalize_context; ValaCCodeStruct* param_spec_struct; ValaCCodeStruct* closure_struct; ValaCCodeEnum* prop_enum; ValaCCodeEnum* signal_enum; ValaSet* user_marshal_set; ValaSet* predefined_marshal_set; gint next_regex_id; ValaDataType* void_type; ValaDataType* bool_type; ValaDataType* char_type; ValaDataType* uchar_type; ValaDataType* unichar_type; ValaDataType* short_type; ValaDataType* ushort_type; ValaDataType* int_type; ValaDataType* uint_type; ValaDataType* long_type; ValaDataType* ulong_type; ValaDataType* int8_type; ValaDataType* uint8_type; ValaDataType* int16_type; ValaDataType* uint16_type; ValaDataType* int32_type; ValaDataType* uint32_type; ValaDataType* int64_type; ValaDataType* uint64_type; ValaDataType* string_type; ValaDataType* regex_type; ValaDataType* float_type; ValaDataType* double_type; ValaTypeSymbol* gtype_type; ValaTypeSymbol* gobject_type; ValaErrorType* gerror_type; ValaClass* glist_type; ValaClass* gslist_type; ValaClass* gnode_type; ValaClass* gqueue_type; ValaClass* gvaluearray_type; ValaTypeSymbol* gstringbuilder_type; ValaTypeSymbol* garray_type; ValaTypeSymbol* gbytearray_type; ValaTypeSymbol* gptrarray_type; ValaTypeSymbol* gthreadpool_type; ValaDataType* gdestroynotify_type; ValaDataType* gquark_type; ValaStruct* gvalue_type; ValaClass* gvariant_type; ValaStruct* mutex_type; ValaStruct* gmutex_type; ValaStruct* grecmutex_type; ValaStruct* grwlock_type; ValaStruct* gcond_type; ValaClass* gsource_type; ValaTypeSymbol* type_module_type; ValaTypeSymbol* dbus_proxy_type; ValaClass* gtk_widget_type; gboolean in_plugin; gchar* module_init_param_name; gboolean gvaluecollector_h_needed; gboolean requires_assert; gboolean requires_array_free; gboolean requires_array_move; gboolean requires_array_length; gboolean requires_clear_mutex; ValaSet* wrappers; }; struct _ValaCCodeBaseModuleClass { ValaCodeGeneratorClass parent_class; void (*append_vala_array_free) (ValaCCodeBaseModule* self); void (*append_vala_array_move) (ValaCCodeBaseModule* self); void (*append_vala_array_length) (ValaCCodeBaseModule* self); gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space); void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space); void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space); void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space); void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction); ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup); gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st); ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition); void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at); ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local); ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param); ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance); ValaTargetValue* (*load_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value); ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym); void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value, ValaSourceReference* source_reference); gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname); ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression* * delegate_target_destroy_notify); ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value); gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname); ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node); void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space); void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space); void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space); void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space); ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail); ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr); ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node); void (*create_type_check_statement) (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name); gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop); void (*generate_dynamic_method_wrapper) (ValaCCodeBaseModule* self, ValaDynamicMethod* method); gboolean (*method_has_wrapper) (ValaCCodeBaseModule* self, ValaMethod* method); ValaCCodeExpression* (*get_param_spec_cexpression) (ValaCCodeBaseModule* self, ValaProperty* prop); ValaCCodeExpression* (*get_param_spec) (ValaCCodeBaseModule* self, ValaProperty* prop); ValaCCodeExpression* (*get_signal_creation) (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type); void (*register_dbus_info) (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable); gchar* (*get_dynamic_property_getter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node); gchar* (*get_dynamic_property_setter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node); gchar* (*get_dynamic_signal_cname) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_dynamic_signal_connect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_dynamic_signal_connect_after_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_dynamic_signal_disconnect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_array_length_cname) (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim); gchar* (*get_parameter_array_length_cname) (ValaCCodeBaseModule* self, ValaParameter* param, gint dim); ValaCCodeExpression* (*get_array_length_cexpression) (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim); ValaCCodeExpression* (*get_array_length_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim); gchar* (*get_array_size_cname) (ValaCCodeBaseModule* self, const gchar* array_cname); void (*add_simple_check) (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails); gchar* (*generate_ready_function) (ValaCCodeBaseModule* self, ValaMethod* m); }; struct _ValaCCodeStructModule { ValaCCodeBaseModule parent_instance; ValaCCodeStructModulePrivate * priv; }; struct _ValaCCodeStructModuleClass { ValaCCodeBaseModuleClass parent_class; }; struct _ValaCCodeMethodModule { ValaCCodeStructModule parent_instance; ValaCCodeMethodModulePrivate * priv; }; struct _ValaCCodeMethodModuleClass { ValaCCodeStructModuleClass parent_class; void (*generate_method_result_declaration) (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map); ValaCCodeParameter* (*generate_parameter) (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map); }; struct _ValaCCodeControlFlowModule { ValaCCodeMethodModule parent_instance; ValaCCodeControlFlowModulePrivate * priv; }; struct _ValaCCodeControlFlowModuleClass { ValaCCodeMethodModuleClass parent_class; }; struct _ValaCCodeMemberAccessModule { ValaCCodeControlFlowModule parent_instance; ValaCCodeMemberAccessModulePrivate * priv; }; struct _ValaCCodeMemberAccessModuleClass { ValaCCodeControlFlowModuleClass parent_class; }; struct _ValaCCodeAssignmentModule { ValaCCodeMemberAccessModule parent_instance; ValaCCodeAssignmentModulePrivate * priv; }; struct _ValaCCodeAssignmentModuleClass { ValaCCodeMemberAccessModuleClass parent_class; }; struct _ValaCCodeMethodCallModule { ValaCCodeAssignmentModule parent_instance; ValaCCodeMethodCallModulePrivate * priv; }; struct _ValaCCodeMethodCallModuleClass { ValaCCodeAssignmentModuleClass parent_class; }; struct _ValaCCodeArrayModule { ValaCCodeMethodCallModule parent_instance; ValaCCodeArrayModulePrivate * priv; }; struct _ValaCCodeArrayModuleClass { ValaCCodeMethodCallModuleClass parent_class; }; struct _ValaCCodeAttribute { ValaAttributeCache parent_instance; ValaCCodeAttributePrivate * priv; }; struct _ValaCCodeAttributeClass { ValaAttributeCacheClass parent_class; }; struct _ValaCCodeBaseModuleEmitContext { GTypeInstance parent_instance; volatile int ref_count; ValaCCodeBaseModuleEmitContextPrivate * priv; ValaSymbol* current_symbol; ValaArrayList* symbol_stack; ValaTryStatement* current_try; ValaCatchClause* current_catch; ValaCCodeFunction* ccode; ValaArrayList* ccode_stack; ValaArrayList* temp_ref_values; gint next_temp_var_id; gboolean current_method_inner_error; gboolean current_method_return; gint next_coroutine_state; ValaMap* variable_name_map; ValaMap* closure_variable_count_map; ValaMap* closure_variable_clash_map; }; struct _ValaCCodeBaseModuleEmitContextClass { GTypeClass parent_class; void (*finalize) (ValaCCodeBaseModuleEmitContext *self); }; struct _ValaCCodeCompiler { GTypeInstance parent_instance; volatile int ref_count; ValaCCodeCompilerPrivate * priv; }; struct _ValaCCodeCompilerClass { GTypeClass parent_class; void (*finalize) (ValaCCodeCompiler *self); }; struct _ValaCCodeDelegateModule { ValaCCodeArrayModule parent_instance; ValaCCodeDelegateModulePrivate * priv; }; struct _ValaCCodeDelegateModuleClass { ValaCCodeArrayModuleClass parent_class; }; struct _ValaTypeRegisterFunction { GTypeInstance parent_instance; volatile int ref_count; ValaTypeRegisterFunctionPrivate * priv; }; struct _ValaTypeRegisterFunctionClass { GTypeClass parent_class; void (*finalize) (ValaTypeRegisterFunction *self); ValaTypeSymbol* (*get_type_declaration) (ValaTypeRegisterFunction* self); gchar* (*get_type_struct_name) (ValaTypeRegisterFunction* self); gchar* (*get_base_init_func_name) (ValaTypeRegisterFunction* self); gchar* (*get_class_finalize_func_name) (ValaTypeRegisterFunction* self); gchar* (*get_base_finalize_func_name) (ValaTypeRegisterFunction* self); gchar* (*get_class_init_func_name) (ValaTypeRegisterFunction* self); gchar* (*get_instance_struct_size) (ValaTypeRegisterFunction* self); gchar* (*get_instance_init_func_name) (ValaTypeRegisterFunction* self); gchar* (*get_parent_type_name) (ValaTypeRegisterFunction* self); gchar* (*get_gtype_value_table_init_function_name) (ValaTypeRegisterFunction* self); gchar* (*get_gtype_value_table_peek_pointer_function_name) (ValaTypeRegisterFunction* self); gchar* (*get_gtype_value_table_free_function_name) (ValaTypeRegisterFunction* self); gchar* (*get_gtype_value_table_copy_function_name) (ValaTypeRegisterFunction* self); gchar* (*get_gtype_value_table_lcopy_value_function_name) (ValaTypeRegisterFunction* self); gchar* (*get_gtype_value_table_collect_value_function_name) (ValaTypeRegisterFunction* self); gchar* (*get_type_flags) (ValaTypeRegisterFunction* self); ValaCCodeFragment* (*get_type_interface_init_declaration) (ValaTypeRegisterFunction* self); void (*get_type_interface_init_statements) (ValaTypeRegisterFunction* self, ValaCodeContext* context, ValaCCodeBlock* block, gboolean plugin); ValaSymbolAccessibility (*get_accessibility) (ValaTypeRegisterFunction* self); }; struct _ValaClassRegisterFunction { ValaTypeRegisterFunction parent_instance; ValaClassRegisterFunctionPrivate * priv; }; struct _ValaClassRegisterFunctionClass { ValaTypeRegisterFunctionClass parent_class; }; struct _ValaCType { ValaDataType parent_instance; ValaCTypePrivate * priv; }; struct _ValaCTypeClass { ValaDataTypeClass parent_class; }; struct _ValaEnumRegisterFunction { ValaTypeRegisterFunction parent_instance; ValaEnumRegisterFunctionPrivate * priv; }; struct _ValaEnumRegisterFunctionClass { ValaTypeRegisterFunctionClass parent_class; }; struct _ValaGErrorModule { ValaCCodeDelegateModule parent_instance; ValaGErrorModulePrivate * priv; }; struct _ValaGErrorModuleClass { ValaCCodeDelegateModuleClass parent_class; void (*return_with_exception) (ValaGErrorModule* self, ValaCCodeExpression* error_expr); }; struct _ValaGTypeModule { ValaGErrorModule parent_instance; ValaGTypeModulePrivate * priv; }; struct _ValaGTypeModuleClass { ValaGErrorModuleClass parent_class; void (*generate_virtual_method_declaration) (ValaGTypeModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeStruct* type_struct); void (*generate_class_init) (ValaGTypeModule* self, ValaClass* cl); void (*end_instance_init) (ValaGTypeModule* self, ValaClass* cl); }; struct _ValaGObjectModule { ValaGTypeModule parent_instance; ValaGObjectModulePrivate * priv; }; struct _ValaGObjectModuleClass { ValaGTypeModuleClass parent_class; }; struct _ValaGSignalModule { ValaGObjectModule parent_instance; ValaGSignalModulePrivate * priv; }; struct _ValaGSignalModuleClass { ValaGObjectModuleClass parent_class; }; struct _ValaGtkModule { ValaGSignalModule parent_instance; ValaGtkModulePrivate * priv; }; struct _ValaGtkModuleClass { ValaGSignalModuleClass parent_class; }; struct _ValaGAsyncModule { ValaGtkModule parent_instance; ValaGAsyncModulePrivate * priv; }; struct _ValaGAsyncModuleClass { ValaGtkModuleClass parent_class; }; struct _ValaGVariantModule { ValaGAsyncModule parent_instance; ValaGVariantModulePrivate * priv; }; struct _ValaGVariantModuleClass { ValaGAsyncModuleClass parent_class; }; struct _ValaGDBusModule { ValaGVariantModule parent_instance; ValaGDBusModulePrivate * priv; }; struct _ValaGDBusModuleClass { ValaGVariantModuleClass parent_class; }; struct _ValaGDBusClientModule { ValaGDBusModule parent_instance; ValaGDBusClientModulePrivate * priv; }; struct _ValaGDBusClientModuleClass { ValaGDBusModuleClass parent_class; }; struct _ValaGDBusServerModule { ValaGDBusClientModule parent_instance; ValaGDBusServerModulePrivate * priv; }; struct _ValaGDBusServerModuleClass { ValaGDBusClientModuleClass parent_class; }; struct _ValaGIRWriter { ValaCodeVisitor parent_instance; ValaGIRWriterPrivate * priv; }; struct _ValaGIRWriterClass { ValaCodeVisitorClass parent_class; gchar* (*get_interface_comment) (ValaGIRWriter* self, ValaInterface* iface); gchar* (*get_struct_comment) (ValaGIRWriter* self, ValaStruct* st); gchar* (*get_enum_comment) (ValaGIRWriter* self, ValaEnum* en); gchar* (*get_class_comment) (ValaGIRWriter* self, ValaClass* c); gchar* (*get_error_code_comment) (ValaGIRWriter* self, ValaErrorCode* ecode); gchar* (*get_enum_value_comment) (ValaGIRWriter* self, ValaEnumValue* ev); gchar* (*get_constant_comment) (ValaGIRWriter* self, ValaConstant* c); gchar* (*get_error_domain_comment) (ValaGIRWriter* self, ValaErrorDomain* edomain); gchar* (*get_field_comment) (ValaGIRWriter* self, ValaField* f); gchar* (*get_delegate_comment) (ValaGIRWriter* self, ValaDelegate* cb); gchar* (*get_method_comment) (ValaGIRWriter* self, ValaMethod* m); gchar* (*get_property_comment) (ValaGIRWriter* self, ValaProperty* prop); gchar* (*get_delegate_return_comment) (ValaGIRWriter* self, ValaDelegate* cb); gchar* (*get_signal_return_comment) (ValaGIRWriter* self, ValaSignal* sig); gchar* (*get_method_return_comment) (ValaGIRWriter* self, ValaMethod* m); gchar* (*get_signal_comment) (ValaGIRWriter* self, ValaSignal* sig); gchar* (*get_parameter_comment) (ValaGIRWriter* self, ValaParameter* param); }; struct _ValaInterfaceRegisterFunction { ValaTypeRegisterFunction parent_instance; ValaInterfaceRegisterFunctionPrivate * priv; }; struct _ValaInterfaceRegisterFunctionClass { ValaTypeRegisterFunctionClass parent_class; }; struct _ValaStructRegisterFunction { ValaTypeRegisterFunction parent_instance; ValaStructRegisterFunctionPrivate * priv; }; struct _ValaStructRegisterFunctionClass { ValaTypeRegisterFunctionClass parent_class; }; gchar* vala_get_ccode_name (ValaCodeNode* node); gchar* vala_get_ccode_const_name (ValaCodeNode* node); gchar* vala_get_ccode_type_name (ValaInterface* iface); gchar* vala_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix); gchar* vala_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix); gchar* vala_get_ccode_header_filenames (ValaSymbol* sym); gchar* vala_get_ccode_prefix (ValaSymbol* sym); gchar* vala_get_ccode_lower_case_prefix (ValaSymbol* sym); gchar* vala_get_ccode_lower_case_suffix (ValaSymbol* sym); gchar* vala_get_ccode_ref_function (ValaTypeSymbol* sym); gchar* vala_get_ccode_quark_name (ValaErrorDomain* edomain); gboolean vala_is_reference_counting (ValaTypeSymbol* sym); gboolean vala_get_ccode_ref_function_void (ValaClass* cl); gboolean vala_get_ccode_free_function_address_of (ValaClass* cl); gchar* vala_get_ccode_unref_function (ValaObjectTypeSymbol* sym); gchar* vala_get_ccode_ref_sink_function (ValaObjectTypeSymbol* sym); gchar* vala_get_ccode_copy_function (ValaTypeSymbol* sym); gchar* vala_get_ccode_destroy_function (ValaTypeSymbol* sym); gchar* vala_get_ccode_dup_function (ValaTypeSymbol* sym); gchar* vala_get_ccode_free_function (ValaTypeSymbol* sym); gboolean vala_get_ccode_is_gboxed (ValaTypeSymbol* sym); gboolean vala_get_ccode_finish_instance (ValaCodeNode* node); gchar* vala_get_ccode_type_id (ValaCodeNode* node); gchar* vala_get_ccode_marshaller_type_name (ValaCodeNode* node); gchar* vala_get_ccode_get_value_function (ValaCodeNode* sym); gchar* vala_get_ccode_set_value_function (ValaCodeNode* sym); gchar* vala_get_ccode_take_value_function (ValaCodeNode* sym); gchar* vala_get_ccode_param_spec_function (ValaCodeNode* sym); gchar* vala_get_ccode_type_check_function (ValaTypeSymbol* sym); gchar* vala_get_ccode_default_value (ValaTypeSymbol* sym); gboolean vala_get_ccode_has_copy_function (ValaStruct* st); gboolean vala_get_ccode_has_destroy_function (ValaStruct* st); gdouble vala_get_ccode_instance_pos (ValaCodeNode* node); gboolean vala_get_ccode_array_length (ValaCodeNode* node); gchar* vala_get_ccode_array_length_type (ValaCodeNode* node); gboolean vala_get_ccode_array_null_terminated (ValaCodeNode* node); gchar* vala_get_ccode_array_length_name (ValaCodeNode* node); gchar* vala_get_ccode_array_length_expr (ValaCodeNode* node); gdouble vala_get_ccode_array_length_pos (ValaCodeNode* node); gdouble vala_get_ccode_delegate_target_pos (ValaCodeNode* node); gdouble vala_get_ccode_destroy_notify_pos (ValaCodeNode* node); gboolean vala_get_ccode_delegate_target (ValaCodeNode* node); gchar* vala_get_ccode_delegate_target_name (ValaVariable* variable); gdouble vala_get_ccode_pos (ValaParameter* param); gchar* vala_get_ccode_type (ValaCodeNode* node); gboolean vala_get_ccode_simple_generics (ValaMethod* m); gchar* vala_get_ccode_real_name (ValaSymbol* sym); gchar* vala_get_ccode_constructv_name (ValaCreationMethod* m); gchar* vala_get_ccode_vfunc_name (ValaMethod* m); gchar* vala_get_ccode_finish_name (ValaMethod* m); gchar* vala_get_ccode_finish_vfunc_name (ValaMethod* m); gchar* vala_get_ccode_finish_real_name (ValaMethod* m); gboolean vala_get_ccode_no_accessor_method (ValaProperty* p); gboolean vala_get_ccode_concrete_accessor (ValaProperty* p); gboolean vala_get_ccode_has_type_id (ValaTypeSymbol* sym); gboolean vala_get_ccode_has_new_function (ValaMethod* m); gboolean vala_get_ccode_has_generic_type_parameter (ValaMethod* m); gdouble vala_get_ccode_generic_type_pos (ValaMethod* m); gchar* vala_get_ccode_sentinel (ValaMethod* m); GType vala_ccode_base_module_get_type (void) G_GNUC_CONST; gpointer vala_ccode_base_module_emit_context_ref (gpointer instance); void vala_ccode_base_module_emit_context_unref (gpointer instance); GParamSpec* vala_ccode_base_module_param_spec_emit_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object); void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object); gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value); GType vala_ccode_base_module_emit_context_get_type (void) G_GNUC_CONST; GType vala_ccode_struct_module_get_type (void) G_GNUC_CONST; GType vala_ccode_method_module_get_type (void) G_GNUC_CONST; GType vala_ccode_control_flow_module_get_type (void) G_GNUC_CONST; GType vala_ccode_member_access_module_get_type (void) G_GNUC_CONST; GType vala_ccode_assignment_module_get_type (void) G_GNUC_CONST; GType vala_ccode_method_call_module_get_type (void) G_GNUC_CONST; GType vala_ccode_array_module_get_type (void) G_GNUC_CONST; ValaCCodeArrayModule* vala_ccode_array_module_new (void); ValaCCodeArrayModule* vala_ccode_array_module_construct (GType object_type); ValaCCodeAssignmentModule* vala_ccode_assignment_module_new (void); ValaCCodeAssignmentModule* vala_ccode_assignment_module_construct (GType object_type); GType vala_ccode_attribute_get_type (void) G_GNUC_CONST; ValaCCodeAttribute* vala_ccode_attribute_new (ValaCodeNode* node); ValaCCodeAttribute* vala_ccode_attribute_construct (GType object_type, ValaCodeNode* node); const gchar* vala_ccode_attribute_get_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_const_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_type_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_header_filenames (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_prefix (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_lower_case_prefix (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_lower_case_suffix (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_ref_function (ValaCCodeAttribute* self); gboolean vala_ccode_attribute_get_ref_function_void (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_unref_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_ref_sink_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_copy_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_destroy_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_dup_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_free_function (ValaCCodeAttribute* self); gboolean vala_ccode_attribute_get_free_function_address_of (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_ctype (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_type_id (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_marshaller_type_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_get_value_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_set_value_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_take_value_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_param_spec_function (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_default_value (ValaCCodeAttribute* self); gdouble vala_ccode_attribute_get_pos (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_real_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_vfunc_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_finish_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_finish_vfunc_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_finish_real_name (ValaCCodeAttribute* self); gboolean vala_ccode_attribute_get_finish_instance (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_delegate_target_name (ValaCCodeAttribute* self); gboolean vala_ccode_attribute_get_array_length (ValaCCodeAttribute* self); gboolean vala_ccode_attribute_get_array_null_terminated (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_array_length_type (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_array_length_name (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_array_length_expr (ValaCCodeAttribute* self); gboolean vala_ccode_attribute_get_delegate_target (ValaCCodeAttribute* self); const gchar* vala_ccode_attribute_get_sentinel (ValaCCodeAttribute* self); extern gint vala_ccode_base_module_ccode_attribute_cache_index; gboolean vala_ccode_base_module_is_in_coroutine (ValaCCodeBaseModule* self); gboolean vala_ccode_base_module_is_in_constructor (ValaCCodeBaseModule* self); gboolean vala_ccode_base_module_is_in_destructor (ValaCCodeBaseModule* self); ValaBlock* vala_ccode_base_module_next_closure_block (ValaCCodeBaseModule* self, ValaSymbol* sym); ValaCCodeBaseModule* vala_ccode_base_module_construct (GType object_type); void vala_ccode_base_module_push_context (ValaCCodeBaseModule* self, ValaCCodeBaseModuleEmitContext* emit_context); void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self); void vala_ccode_base_module_push_line (ValaCCodeBaseModule* self, ValaSourceReference* source_reference); void vala_ccode_base_module_pop_line (ValaCCodeBaseModule* self); void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func); void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self); gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name); ValaCCodeIdentifier* vala_ccode_base_module_get_value_setter_function (ValaCCodeBaseModule* self, ValaDataType* type_reference); ValaCCodeIdentifier* vala_ccode_base_module_get_value_taker_function (ValaCCodeBaseModule* self, ValaDataType* type_reference); void vala_ccode_base_module_append_vala_array_free (ValaCCodeBaseModule* self); void vala_ccode_base_module_append_vala_array_move (ValaCCodeBaseModule* self); void vala_ccode_base_module_append_vala_array_length (ValaCCodeBaseModule* self); void vala_ccode_base_module_append_vala_clear_mutex (ValaCCodeBaseModule* self, const gchar* typename, const gchar* funcprefix); gboolean vala_ccode_base_module_generate_enum_declaration (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space); void vala_ccode_base_module_visit_member (ValaCCodeBaseModule* self, ValaSymbol* m); void vala_ccode_base_module_generate_constant_declaration (ValaCCodeBaseModule* self, ValaConstant* c, ValaCCodeFile* decl_space, gboolean definition); void vala_ccode_base_module_generate_field_declaration (ValaCCodeBaseModule* self, ValaField* f, ValaCCodeFile* decl_space); gboolean vala_ccode_base_module_is_constant_ccode_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr); gboolean vala_ccode_base_module_is_pure_ccode_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr); void vala_ccode_base_module_generate_type_declaration (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeFile* decl_space); void vala_ccode_base_module_generate_class_struct_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space); void vala_ccode_base_module_generate_struct_declaration (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space); void vala_ccode_base_module_generate_delegate_declaration (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space); void vala_ccode_base_module_generate_cparameters (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction); void vala_ccode_base_module_generate_property_accessor_declaration (ValaCCodeBaseModule* self, ValaPropertyAccessor* acc, ValaCCodeFile* decl_space); gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b); gboolean vala_ccode_base_module_no_implicit_copy (ValaCCodeBaseModule* self, ValaDataType* type); ValaCCodeExpression* vala_ccode_base_module_get_local_cexpression (ValaCCodeBaseModule* self, ValaLocalVariable* local); ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name); ValaCCodeExpression* vala_ccode_base_module_get_this_cexpression (ValaCCodeBaseModule* self); gchar* vala_ccode_base_module_get_local_cname (ValaCCodeBaseModule* self, ValaLocalVariable* local); gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name); ValaCCodeExpression* vala_ccode_base_module_get_result_cexpression (ValaCCodeBaseModule* self, const gchar* cname); gboolean vala_ccode_base_module_is_simple_struct_creation (ValaCCodeBaseModule* self, ValaVariable* variable, ValaExpression* expr); ValaTargetValue* vala_ccode_base_module_create_temp_value (ValaCCodeBaseModule* self, ValaDataType* type, gboolean init, ValaCodeNode* node_reference, gboolean* value_owned); ValaTargetValue* vala_ccode_base_module_load_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue); ValaTargetValue* vala_ccode_base_module_store_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* initializer, ValaCodeNode* node_reference, gboolean* value_owned); ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init); ValaCCodeExpression* vala_ccode_base_module_get_type_id_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup); ValaCCodeExpression* vala_ccode_base_module_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup); gchar* vala_ccode_base_module_generate_dup_func_wrapper (ValaCCodeBaseModule* self, ValaDataType* type); gchar* vala_ccode_base_module_generate_free_function_address_of_wrapper (ValaCCodeBaseModule* self, ValaDataType* type); gchar* vala_ccode_base_module_generate_free_func_wrapper (ValaCCodeBaseModule* self, ValaDataType* type); ValaCCodeExpression* vala_ccode_base_module_get_destroy0_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup); ValaCCodeExpression* vala_ccode_base_module_get_destroy_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup); gchar* vala_ccode_base_module_append_struct_array_free (ValaCCodeBaseModule* self, ValaStruct* st); ValaCCodeExpression* vala_ccode_base_module_destroy_local (ValaCCodeBaseModule* self, ValaLocalVariable* local); ValaCCodeExpression* vala_ccode_base_module_destroy_parameter (ValaCCodeBaseModule* self, ValaParameter* param); ValaCCodeExpression* vala_ccode_base_module_destroy_field (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance); ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition); void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local); void vala_ccode_base_module_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at); void vala_ccode_base_module_append_local_free (ValaCCodeBaseModule* self, ValaSymbol* sym, gboolean stop_at_loop, ValaCodeNode* stop_at); gboolean vala_ccode_base_module_variable_accessible_in_finally (ValaCCodeBaseModule* self, ValaLocalVariable* local); void vala_ccode_base_module_return_out_parameter (ValaCCodeBaseModule* self, ValaParameter* param); gchar* vala_ccode_base_module_get_symbol_lock_name (ValaCCodeBaseModule* self, const gchar* symname); ValaTargetValue* vala_ccode_base_module_get_local_cvalue (ValaCCodeBaseModule* self, ValaLocalVariable* local); ValaTargetValue* vala_ccode_base_module_get_parameter_cvalue (ValaCCodeBaseModule* self, ValaParameter* param); ValaTargetValue* vala_ccode_base_module_get_field_cvalue (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance); ValaTargetValue* vala_ccode_base_module_load_variable (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value); ValaTargetValue* vala_ccode_base_module_load_this_parameter (ValaCCodeBaseModule* self, ValaTypeSymbol* sym); void vala_ccode_base_module_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value, ValaSourceReference* source_reference); gchar* vala_ccode_base_module_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname); ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression* * delegate_target_destroy_notify); ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value); gchar* vala_ccode_base_module_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname); gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type); gboolean vala_ccode_base_module_requires_destroy (ValaCCodeBaseModule* self, ValaDataType* type); ValaTargetValue* vala_ccode_base_module_copy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node); void vala_ccode_base_module_check_type (ValaCCodeBaseModule* self, ValaDataType* type); void vala_ccode_base_module_check_type_arguments (ValaCCodeBaseModule* self, ValaMemberAccess* access); void vala_ccode_base_module_generate_class_declaration (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space); void vala_ccode_base_module_generate_interface_declaration (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space); void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space); void vala_ccode_base_module_generate_error_domain_declaration (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space); void vala_ccode_base_module_add_generic_type_arguments (ValaCCodeBaseModule* self, ValaMap* arg_map, ValaList* type_args, ValaCodeNode* expr, gboolean is_chainup, ValaList* type_parameters); ValaCCodeExpression* vala_ccode_base_module_handle_struct_argument (ValaCCodeBaseModule* self, ValaParameter* param, ValaExpression* arg, ValaCCodeExpression* cexpr); ValaCCodeExpression* vala_ccode_base_module_try_cast_value_to_type (ValaCCodeBaseModule* self, ValaCCodeExpression* ccodeexpr, ValaDataType* from, ValaDataType* to, ValaExpression* expr); ValaTargetValue* vala_ccode_base_module_try_cast_variant_to_type (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* to, ValaCodeNode* node); ValaCCodeExpression* vala_ccode_base_module_deserialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail); ValaCCodeExpression* vala_ccode_base_module_serialize_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr); ValaCCodeExpression* vala_ccode_base_module_convert_from_generic_pointer (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr, ValaDataType* actual_type); ValaCCodeExpression* vala_ccode_base_module_convert_to_generic_pointer (ValaCCodeBaseModule* self, ValaCCodeExpression* cexpr, ValaDataType* actual_type); ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node); ValaCCodeExpression* vala_ccode_base_module_get_implicit_cast_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node); void vala_ccode_base_module_store_property (ValaCCodeBaseModule* self, ValaProperty* prop, ValaExpression* instance, ValaTargetValue* value); gboolean vala_ccode_base_module_add_wrapper (ValaCCodeBaseModule* self, const gchar* wrapper_name); gboolean vala_ccode_base_module_add_generated_external_symbol (ValaCCodeBaseModule* self, ValaSymbol* external_symbol); ValaDataType* vala_ccode_base_module_get_data_type_for_symbol (ValaTypeSymbol* sym); ValaCCodeExpression* vala_ccode_base_module_default_value_for_type (ValaCCodeBaseModule* self, ValaDataType* type, gboolean initializer_expression); void vala_ccode_base_module_create_type_check_statement (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name); gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis); ValaCCodeExpression* vala_ccode_base_module_get_ccodenode (ValaCCodeBaseModule* self, ValaExpression* node); gboolean vala_ccode_base_module_is_lvalue_access_allowed (ValaCCodeBaseModule* self, ValaDataType* type); ValaCCodeDeclaratorSuffix* vala_ccode_base_module_get_ccode_declarator_suffix (ValaCCodeBaseModule* self, ValaDataType* type); ValaCCodeConstant* vala_ccode_base_module_get_signal_canonical_constant (ValaCCodeBaseModule* self, ValaSignal* sig, const gchar* detail); ValaCCodeConstant* vala_ccode_base_module_get_enum_value_canonical_cconstant (ValaEnumValue* ev); gboolean vala_ccode_base_module_get_signal_has_emitter (ValaCCodeBaseModule* self, ValaSignal* sig); ValaCCodeConstant* vala_ccode_base_module_get_property_canonical_cconstant (ValaCCodeBaseModule* self, ValaProperty* prop); void vala_ccode_base_module_create_postcondition_statement (ValaCCodeBaseModule* self, ValaExpression* postcondition); gboolean vala_ccode_base_module_is_gobject_property (ValaCCodeBaseModule* self, ValaProperty* prop); ValaDataType* vala_ccode_base_module_get_this_type (ValaCCodeBaseModule* self); ValaCCodeFunctionCall* vala_ccode_base_module_generate_instance_cast (ValaCCodeBaseModule* self, ValaCCodeExpression* expr, ValaTypeSymbol* type); void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type); void vala_ccode_base_module_generate_dynamic_method_wrapper (ValaCCodeBaseModule* self, ValaDynamicMethod* method); gboolean vala_ccode_base_module_method_has_wrapper (ValaCCodeBaseModule* self, ValaMethod* method); ValaCCodeExpression* vala_ccode_base_module_get_param_spec_cexpression (ValaCCodeBaseModule* self, ValaProperty* prop); ValaCCodeExpression* vala_ccode_base_module_get_param_spec (ValaCCodeBaseModule* self, ValaProperty* prop); ValaCCodeExpression* vala_ccode_base_module_get_signal_creation (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type); void vala_ccode_base_module_register_dbus_info (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable); gchar* vala_ccode_base_module_get_dynamic_property_getter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node); gchar* vala_ccode_base_module_get_dynamic_property_setter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node); gchar* vala_ccode_base_module_get_dynamic_signal_cname (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* vala_ccode_base_module_get_dynamic_signal_connect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* vala_ccode_base_module_get_dynamic_signal_connect_after_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* vala_ccode_base_module_get_dynamic_signal_disconnect_wrapper_name (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* vala_ccode_base_module_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim); gchar* vala_ccode_base_module_get_parameter_array_length_cname (ValaCCodeBaseModule* self, ValaParameter* param, gint dim); ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim); ValaCCodeExpression* vala_ccode_base_module_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim); gchar* vala_ccode_base_module_get_array_size_cname (ValaCCodeBaseModule* self, const gchar* array_cname); void vala_ccode_base_module_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails); gchar* vala_ccode_base_module_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m); ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr); ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value); void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue); ValaCCodeExpression* vala_ccode_base_module_get_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value); void vala_ccode_base_module_set_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCCodeExpression* cvalue); ValaCCodeExpression* vala_ccode_base_module_get_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr); void vala_ccode_base_module_set_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* delegate_target); ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr); void vala_ccode_base_module_set_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* destroy_notify); void vala_ccode_base_module_append_array_length (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* size); ValaList* vala_ccode_base_module_get_array_lengths (ValaCCodeBaseModule* self, ValaExpression* expr); gboolean vala_ccode_base_module_get_lvalue (ValaCCodeBaseModule* self, ValaTargetValue* value); gboolean vala_ccode_base_module_get_non_null (ValaCCodeBaseModule* self, ValaTargetValue* value); gchar* vala_ccode_base_module_get_ctype (ValaCCodeBaseModule* self, ValaTargetValue* value); gboolean vala_ccode_base_module_get_array_null_terminated (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpr (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaCodeContext* vala_ccode_base_module_get_context (ValaCCodeBaseModule* self); void vala_ccode_base_module_set_context (ValaCCodeBaseModule* self, ValaCodeContext* value); ValaSymbol* vala_ccode_base_module_get_current_symbol (ValaCCodeBaseModule* self); ValaTryStatement* vala_ccode_base_module_get_current_try (ValaCCodeBaseModule* self); void vala_ccode_base_module_set_current_try (ValaCCodeBaseModule* self, ValaTryStatement* value); ValaCatchClause* vala_ccode_base_module_get_current_catch (ValaCCodeBaseModule* self); void vala_ccode_base_module_set_current_catch (ValaCCodeBaseModule* self, ValaCatchClause* value); ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self); ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self); ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self); ValaPropertyAccessor* vala_ccode_base_module_get_current_property_accessor (ValaCCodeBaseModule* self); ValaConstructor* vala_ccode_base_module_get_current_constructor (ValaCCodeBaseModule* self); ValaDestructor* vala_ccode_base_module_get_current_destructor (ValaCCodeBaseModule* self); ValaDataType* vala_ccode_base_module_get_current_return_type (ValaCCodeBaseModule* self); ValaBlock* vala_ccode_base_module_get_current_closure_block (ValaCCodeBaseModule* self); ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self); ValaArrayList* vala_ccode_base_module_get_temp_ref_values (ValaCCodeBaseModule* self); gint vala_ccode_base_module_get_next_temp_var_id (ValaCCodeBaseModule* self); void vala_ccode_base_module_set_next_temp_var_id (ValaCCodeBaseModule* self, gint value); gboolean vala_ccode_base_module_get_in_creation_method (ValaCCodeBaseModule* self); gboolean vala_ccode_base_module_get_current_method_inner_error (ValaCCodeBaseModule* self); void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value); gboolean vala_ccode_base_module_get_current_method_return (ValaCCodeBaseModule* self); void vala_ccode_base_module_set_current_method_return (ValaCCodeBaseModule* self, gboolean value); ValaMap* vala_ccode_base_module_get_variable_name_map (ValaCCodeBaseModule* self); ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_new (ValaSymbol* symbol); ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_construct (GType object_type, ValaSymbol* symbol); void vala_ccode_base_module_emit_context_push_symbol (ValaCCodeBaseModuleEmitContext* self, ValaSymbol* symbol); void vala_ccode_base_module_emit_context_pop_symbol (ValaCCodeBaseModuleEmitContext* self); gpointer vala_ccode_compiler_ref (gpointer instance); void vala_ccode_compiler_unref (gpointer instance); GParamSpec* vala_param_spec_ccode_compiler (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_ccode_compiler (GValue* value, gpointer v_object); void vala_value_take_ccode_compiler (GValue* value, gpointer v_object); gpointer vala_value_get_ccode_compiler (const GValue* value); GType vala_ccode_compiler_get_type (void) G_GNUC_CONST; ValaCCodeCompiler* vala_ccode_compiler_new (void); ValaCCodeCompiler* vala_ccode_compiler_construct (GType object_type); void vala_ccode_compiler_compile (ValaCCodeCompiler* self, ValaCodeContext* context, const gchar* cc_command, gchar** cc_options, int cc_options_length1, const gchar* pkg_config_command); ValaCCodeControlFlowModule* vala_ccode_control_flow_module_construct (GType object_type); GType vala_ccode_delegate_module_get_type (void) G_GNUC_CONST; gchar* vala_ccode_delegate_module_generate_delegate_wrapper (ValaCCodeDelegateModule* self, ValaMethod* m, ValaDelegateType* dt, ValaCodeNode* node); ValaCCodeDelegateModule* vala_ccode_delegate_module_new (void); ValaCCodeDelegateModule* vala_ccode_delegate_module_construct (GType object_type); ValaCCodeMemberAccessModule* vala_ccode_member_access_module_construct (GType object_type); ValaCCodeMethodCallModule* vala_ccode_method_call_module_new (void); ValaCCodeMethodCallModule* vala_ccode_method_call_module_construct (GType object_type); void vala_ccode_method_module_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map); void vala_ccode_method_module_complete_async (ValaCCodeMethodModule* self); ValaCCodeParameter* vala_ccode_method_module_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map); void vala_ccode_method_module_generate_vfunc (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaMap* cparam_map, ValaMap* carg_map, const gchar* suffix, gint direction); ValaCCodeMethodModule* vala_ccode_method_module_construct (GType object_type); ValaCCodeStructModule* vala_ccode_struct_module_construct (GType object_type); gpointer vala_typeregister_function_ref (gpointer instance); void vala_typeregister_function_unref (gpointer instance); GParamSpec* vala_param_spec_typeregister_function (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_typeregister_function (GValue* value, gpointer v_object); void vala_value_take_typeregister_function (GValue* value, gpointer v_object); gpointer vala_value_get_typeregister_function (const GValue* value); GType vala_typeregister_function_get_type (void) G_GNUC_CONST; GType vala_class_register_function_get_type (void) G_GNUC_CONST; ValaClassRegisterFunction* vala_class_register_function_new (ValaClass* cl); ValaClassRegisterFunction* vala_class_register_function_construct (GType object_type, ValaClass* cl); ValaClass* vala_class_register_function_get_class_reference (ValaClassRegisterFunction* self); void vala_class_register_function_set_class_reference (ValaClassRegisterFunction* self, ValaClass* value); GType vala_ctype_get_type (void) G_GNUC_CONST; ValaCType* vala_ctype_new (const gchar* ctype_name); ValaCType* vala_ctype_construct (GType object_type, const gchar* ctype_name); const gchar* vala_ctype_get_ctype_name (ValaCType* self); void vala_ctype_set_ctype_name (ValaCType* self, const gchar* value); GType vala_enum_register_function_get_type (void) G_GNUC_CONST; ValaEnumRegisterFunction* vala_enum_register_function_new (ValaEnum* en); ValaEnumRegisterFunction* vala_enum_register_function_construct (GType object_type, ValaEnum* en); ValaEnum* vala_enum_register_function_get_enum_reference (ValaEnumRegisterFunction* self); void vala_enum_register_function_set_enum_reference (ValaEnumRegisterFunction* self, ValaEnum* value); GType vala_gerror_module_get_type (void) G_GNUC_CONST; GType vala_gtype_module_get_type (void) G_GNUC_CONST; GType vala_gobject_module_get_type (void) G_GNUC_CONST; GType vala_gsignal_module_get_type (void) G_GNUC_CONST; GType vala_gtk_module_get_type (void) G_GNUC_CONST; GType vala_gasync_module_get_type (void) G_GNUC_CONST; gchar* vala_gasync_module_generate_async_callback_wrapper (ValaGAsyncModule* self); ValaGAsyncModule* vala_gasync_module_new (void); ValaGAsyncModule* vala_gasync_module_construct (GType object_type); GType vala_gvariant_module_get_type (void) G_GNUC_CONST; GType vala_gd_bus_module_get_type (void) G_GNUC_CONST; GType vala_gd_bus_client_module_get_type (void) G_GNUC_CONST; ValaCCodeConstant* vala_gd_bus_client_module_get_dbus_timeout (ValaGDBusClientModule* self, ValaSymbol* symbol); ValaGDBusClientModule* vala_gd_bus_client_module_new (void); ValaGDBusClientModule* vala_gd_bus_client_module_construct (GType object_type); gchar* vala_gd_bus_module_get_dbus_name (ValaTypeSymbol* symbol); gchar* vala_gd_bus_module_get_dbus_name_for_member (ValaSymbol* symbol); gint vala_gd_bus_module_get_dbus_timeout_for_member (ValaSymbol* symbol); gboolean vala_gd_bus_module_is_dbus_visible (ValaCodeNode* node); gboolean vala_gd_bus_module_is_dbus_no_reply (ValaMethod* m); gchar* vala_gd_bus_module_dbus_result_name (ValaMethod* m); gboolean vala_gd_bus_module_dbus_method_uses_file_descriptor (ValaGDBusModule* self, ValaMethod* method); void vala_gd_bus_module_send_dbus_value (ValaGDBusModule* self, ValaDataType* type, ValaCCodeExpression* builder_expr, ValaCCodeExpression* expr, ValaSymbol* sym); void vala_gd_bus_module_receive_dbus_value (ValaGDBusModule* self, ValaDataType* type, ValaCCodeExpression* message_expr, ValaCCodeExpression* iter_expr, ValaCCodeExpression* target_expr, ValaSymbol* sym, ValaCCodeExpression* error_expr, gboolean* may_fail); ValaCCodeExpression* vala_gd_bus_module_get_interface_info (ValaGDBusModule* self, ValaObjectTypeSymbol* sym); ValaGDBusModule* vala_gd_bus_module_new (void); ValaGDBusModule* vala_gd_bus_module_construct (GType object_type); GType vala_gd_bus_server_module_get_type (void) G_GNUC_CONST; ValaGDBusServerModule* vala_gd_bus_server_module_new (void); ValaGDBusServerModule* vala_gd_bus_server_module_construct (GType object_type); void vala_gerror_module_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr); ValaGErrorModule* vala_gerror_module_new (void); ValaGErrorModule* vala_gerror_module_construct (GType object_type); GType vala_gir_writer_get_type (void) G_GNUC_CONST; gchar* vala_gir_writer_get_interface_comment (ValaGIRWriter* self, ValaInterface* iface); gchar* vala_gir_writer_get_struct_comment (ValaGIRWriter* self, ValaStruct* st); gchar* vala_gir_writer_get_enum_comment (ValaGIRWriter* self, ValaEnum* en); gchar* vala_gir_writer_get_class_comment (ValaGIRWriter* self, ValaClass* c); gchar* vala_gir_writer_get_error_code_comment (ValaGIRWriter* self, ValaErrorCode* ecode); gchar* vala_gir_writer_get_enum_value_comment (ValaGIRWriter* self, ValaEnumValue* ev); gchar* vala_gir_writer_get_constant_comment (ValaGIRWriter* self, ValaConstant* c); gchar* vala_gir_writer_get_error_domain_comment (ValaGIRWriter* self, ValaErrorDomain* edomain); gchar* vala_gir_writer_get_field_comment (ValaGIRWriter* self, ValaField* f); gchar* vala_gir_writer_get_delegate_comment (ValaGIRWriter* self, ValaDelegate* cb); gchar* vala_gir_writer_get_method_comment (ValaGIRWriter* self, ValaMethod* m); gchar* vala_gir_writer_get_property_comment (ValaGIRWriter* self, ValaProperty* prop); gchar* vala_gir_writer_get_delegate_return_comment (ValaGIRWriter* self, ValaDelegate* cb); gchar* vala_gir_writer_get_signal_return_comment (ValaGIRWriter* self, ValaSignal* sig); gchar* vala_gir_writer_get_method_return_comment (ValaGIRWriter* self, ValaMethod* m); gchar* vala_gir_writer_get_signal_comment (ValaGIRWriter* self, ValaSignal* sig); gchar* vala_gir_writer_get_parameter_comment (ValaGIRWriter* self, ValaParameter* param); void vala_gir_writer_write_includes (ValaGIRWriter* self); void vala_gir_writer_write_file (ValaGIRWriter* self, ValaCodeContext* context, const gchar* directory, const gchar* gir_filename, const gchar* gir_namespace, const gchar* gir_version, const gchar* package, const gchar* gir_shared_library); ValaGIRWriter* vala_gir_writer_new (void); ValaGIRWriter* vala_gir_writer_construct (GType object_type); ValaGObjectModule* vala_gobject_module_new (void); ValaGObjectModule* vala_gobject_module_construct (GType object_type); ValaGtkModule* vala_gtk_module_new (void); ValaGtkModule* vala_gtk_module_construct (GType object_type); ValaGSignalModule* vala_gsignal_module_new (void); ValaGSignalModule* vala_gsignal_module_construct (GType object_type); void vala_gtype_module_generate_virtual_method_declaration (ValaGTypeModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeStruct* type_struct); void vala_gtype_module_generate_class_init (ValaGTypeModule* self, ValaClass* cl); void vala_gtype_module_end_instance_init (ValaGTypeModule* self, ValaClass* cl); ValaGTypeModule* vala_gtype_module_new (void); ValaGTypeModule* vala_gtype_module_construct (GType object_type); gchar* vala_gvariant_module_get_dbus_signature (ValaSymbol* symbol); gchar* vala_gvariant_module_get_type_signature (ValaDataType* datatype, ValaSymbol* symbol); ValaCCodeFunction* vala_gvariant_module_generate_enum_from_string_function_declaration (ValaGVariantModule* self, ValaEnum* en); ValaCCodeFunction* vala_gvariant_module_generate_enum_from_string_function (ValaGVariantModule* self, ValaEnum* en); void vala_gvariant_module_read_expression (ValaGVariantModule* self, ValaDataType* type, ValaCCodeExpression* iter_expr, ValaCCodeExpression* target_expr, ValaSymbol* sym, ValaCCodeExpression* error_expr, gboolean* may_fail); ValaCCodeFunction* vala_gvariant_module_generate_enum_to_string_function_declaration (ValaGVariantModule* self, ValaEnum* en); ValaCCodeFunction* vala_gvariant_module_generate_enum_to_string_function (ValaGVariantModule* self, ValaEnum* en); void vala_gvariant_module_write_expression (ValaGVariantModule* self, ValaDataType* type, ValaCCodeExpression* builder_expr, ValaCCodeExpression* expr, ValaSymbol* sym); ValaGVariantModule* vala_gvariant_module_new (void); ValaGVariantModule* vala_gvariant_module_construct (GType object_type); GType vala_interface_register_function_get_type (void) G_GNUC_CONST; ValaInterfaceRegisterFunction* vala_interface_register_function_new (ValaInterface* iface); ValaInterfaceRegisterFunction* vala_interface_register_function_construct (GType object_type, ValaInterface* iface); ValaInterface* vala_interface_register_function_get_interface_reference (ValaInterfaceRegisterFunction* self); void vala_interface_register_function_set_interface_reference (ValaInterfaceRegisterFunction* self, ValaInterface* value); GType vala_struct_register_function_get_type (void) G_GNUC_CONST; ValaStructRegisterFunction* vala_struct_register_function_new (ValaStruct* st); ValaStructRegisterFunction* vala_struct_register_function_construct (GType object_type, ValaStruct* st); ValaStruct* vala_struct_register_function_get_struct_reference (ValaStructRegisterFunction* self); void vala_struct_register_function_set_struct_reference (ValaStructRegisterFunction* self, ValaStruct* value); void vala_typeregister_function_init_from_type (ValaTypeRegisterFunction* self, ValaCodeContext* context, gboolean plugin, gboolean declaration_only); ValaTypeSymbol* vala_typeregister_function_get_type_declaration (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_type_struct_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_base_init_func_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_class_finalize_func_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_base_finalize_func_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_class_init_func_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_instance_struct_size (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_instance_init_func_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_parent_type_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_gtype_value_table_init_function_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_gtype_value_table_peek_pointer_function_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_gtype_value_table_free_function_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_gtype_value_table_copy_function_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_gtype_value_table_lcopy_value_function_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_gtype_value_table_collect_value_function_name (ValaTypeRegisterFunction* self); gchar* vala_typeregister_function_get_type_flags (ValaTypeRegisterFunction* self); ValaCCodeFragment* vala_typeregister_function_get_type_interface_init_declaration (ValaTypeRegisterFunction* self); void vala_typeregister_function_get_type_interface_init_statements (ValaTypeRegisterFunction* self, ValaCodeContext* context, ValaCCodeBlock* block, gboolean plugin); ValaCCodeFragment* vala_typeregister_function_get_source_declaration (ValaTypeRegisterFunction* self); ValaCCodeFragment* vala_typeregister_function_get_declaration (ValaTypeRegisterFunction* self); ValaCCodeFragment* vala_typeregister_function_get_definition (ValaTypeRegisterFunction* self); ValaSymbolAccessibility vala_typeregister_function_get_accessibility (ValaTypeRegisterFunction* self); ValaTypeRegisterFunction* vala_typeregister_function_construct (GType object_type); G_END_DECLS #endif valabind-1.5.0/private/valagee.h000066400000000000000000000427301323123274000165270ustar00rootroot00000000000000/* valagee.h generated by valac, the Vala compiler, do not modify */ #ifndef __VALAGEE_H__ #define __VALAGEE_H__ #include #include G_BEGIN_DECLS #define VALA_TYPE_ITERABLE (vala_iterable_get_type ()) #define VALA_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ITERABLE, ValaIterable)) #define VALA_ITERABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ITERABLE, ValaIterableClass)) #define VALA_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ITERABLE)) #define VALA_IS_ITERABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ITERABLE)) #define VALA_ITERABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ITERABLE, ValaIterableClass)) typedef struct _ValaIterable ValaIterable; typedef struct _ValaIterableClass ValaIterableClass; typedef struct _ValaIterablePrivate ValaIterablePrivate; #define VALA_TYPE_ITERATOR (vala_iterator_get_type ()) #define VALA_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ITERATOR, ValaIterator)) #define VALA_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ITERATOR, ValaIteratorClass)) #define VALA_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ITERATOR)) #define VALA_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ITERATOR)) #define VALA_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ITERATOR, ValaIteratorClass)) typedef struct _ValaIterator ValaIterator; typedef struct _ValaIteratorClass ValaIteratorClass; #define VALA_TYPE_COLLECTION (vala_collection_get_type ()) #define VALA_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_COLLECTION, ValaCollection)) #define VALA_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_COLLECTION, ValaCollectionClass)) #define VALA_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_COLLECTION)) #define VALA_IS_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_COLLECTION)) #define VALA_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_COLLECTION, ValaCollectionClass)) typedef struct _ValaCollection ValaCollection; typedef struct _ValaCollectionClass ValaCollectionClass; typedef struct _ValaCollectionPrivate ValaCollectionPrivate; #define VALA_TYPE_LIST (vala_list_get_type ()) #define VALA_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_LIST, ValaList)) #define VALA_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_LIST, ValaListClass)) #define VALA_IS_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_LIST)) #define VALA_IS_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_LIST)) #define VALA_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_LIST, ValaListClass)) typedef struct _ValaList ValaList; typedef struct _ValaListClass ValaListClass; typedef struct _ValaListPrivate ValaListPrivate; #define VALA_TYPE_ARRAY_LIST (vala_array_list_get_type ()) #define VALA_ARRAY_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ARRAY_LIST, ValaArrayList)) #define VALA_ARRAY_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ARRAY_LIST, ValaArrayListClass)) #define VALA_IS_ARRAY_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ARRAY_LIST)) #define VALA_IS_ARRAY_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ARRAY_LIST)) #define VALA_ARRAY_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ARRAY_LIST, ValaArrayListClass)) typedef struct _ValaArrayList ValaArrayList; typedef struct _ValaArrayListClass ValaArrayListClass; typedef struct _ValaArrayListPrivate ValaArrayListPrivate; #define VALA_TYPE_MAP (vala_map_get_type ()) #define VALA_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MAP, ValaMap)) #define VALA_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MAP, ValaMapClass)) #define VALA_IS_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MAP)) #define VALA_IS_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MAP)) #define VALA_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MAP, ValaMapClass)) typedef struct _ValaMap ValaMap; typedef struct _ValaMapClass ValaMapClass; typedef struct _ValaMapPrivate ValaMapPrivate; #define VALA_TYPE_SET (vala_set_get_type ()) #define VALA_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_SET, ValaSet)) #define VALA_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_SET, ValaSetClass)) #define VALA_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_SET)) #define VALA_IS_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_SET)) #define VALA_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_SET, ValaSetClass)) typedef struct _ValaSet ValaSet; typedef struct _ValaSetClass ValaSetClass; #define VALA_TYPE_MAP_ITERATOR (vala_map_iterator_get_type ()) #define VALA_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_MAP_ITERATOR, ValaMapIterator)) #define VALA_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_MAP_ITERATOR, ValaMapIteratorClass)) #define VALA_IS_MAP_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_MAP_ITERATOR)) #define VALA_IS_MAP_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_MAP_ITERATOR)) #define VALA_MAP_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_MAP_ITERATOR, ValaMapIteratorClass)) typedef struct _ValaMapIterator ValaMapIterator; typedef struct _ValaMapIteratorClass ValaMapIteratorClass; #define VALA_TYPE_HASH_MAP (vala_hash_map_get_type ()) #define VALA_HASH_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_HASH_MAP, ValaHashMap)) #define VALA_HASH_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_HASH_MAP, ValaHashMapClass)) #define VALA_IS_HASH_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_HASH_MAP)) #define VALA_IS_HASH_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_HASH_MAP)) #define VALA_HASH_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_HASH_MAP, ValaHashMapClass)) typedef struct _ValaHashMap ValaHashMap; typedef struct _ValaHashMapClass ValaHashMapClass; typedef struct _ValaHashMapPrivate ValaHashMapPrivate; typedef struct _ValaSetPrivate ValaSetPrivate; #define VALA_TYPE_HASH_SET (vala_hash_set_get_type ()) #define VALA_HASH_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_HASH_SET, ValaHashSet)) #define VALA_HASH_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_HASH_SET, ValaHashSetClass)) #define VALA_IS_HASH_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_HASH_SET)) #define VALA_IS_HASH_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_HASH_SET)) #define VALA_HASH_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_HASH_SET, ValaHashSetClass)) typedef struct _ValaHashSet ValaHashSet; typedef struct _ValaHashSetClass ValaHashSetClass; typedef struct _ValaHashSetPrivate ValaHashSetPrivate; typedef struct _ValaMapIteratorPrivate ValaMapIteratorPrivate; typedef struct _ValaIteratorPrivate ValaIteratorPrivate; struct _ValaIterable { GTypeInstance parent_instance; volatile int ref_count; ValaIterablePrivate * priv; }; struct _ValaIterableClass { GTypeClass parent_class; void (*finalize) (ValaIterable *self); GType (*get_element_type) (ValaIterable* self); ValaIterator* (*iterator) (ValaIterable* self); }; struct _ValaCollection { ValaIterable parent_instance; ValaCollectionPrivate * priv; }; struct _ValaCollectionClass { ValaIterableClass parent_class; gboolean (*contains) (ValaCollection* self, gconstpointer item); gboolean (*add) (ValaCollection* self, gconstpointer item); gboolean (*remove) (ValaCollection* self, gconstpointer item); void (*clear) (ValaCollection* self); gboolean (*add_all) (ValaCollection* self, ValaCollection* collection); gpointer* (*to_array) (ValaCollection* self, int* result_length1); gint (*get_size) (ValaCollection* self); gboolean (*get_is_empty) (ValaCollection* self); }; struct _ValaList { ValaCollection parent_instance; ValaListPrivate * priv; }; struct _ValaListClass { ValaCollectionClass parent_class; gpointer (*get) (ValaList* self, gint index); void (*set) (ValaList* self, gint index, gconstpointer item); gint (*index_of) (ValaList* self, gconstpointer item); void (*insert) (ValaList* self, gint index, gconstpointer item); gpointer (*remove_at) (ValaList* self, gint index); gpointer (*first) (ValaList* self); gpointer (*last) (ValaList* self); void (*insert_all) (ValaList* self, gint index, ValaCollection* collection); void (*sort) (ValaList* self, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify); }; struct _ValaArrayList { ValaList parent_instance; ValaArrayListPrivate * priv; gpointer* _items; gint _items_length1; gint __items_size_; gint _size; }; struct _ValaArrayListClass { ValaListClass parent_class; }; struct _ValaMap { GTypeInstance parent_instance; volatile int ref_count; ValaMapPrivate * priv; }; struct _ValaMapClass { GTypeClass parent_class; void (*finalize) (ValaMap *self); ValaSet* (*get_keys) (ValaMap* self); ValaCollection* (*get_values) (ValaMap* self); gboolean (*contains) (ValaMap* self, gconstpointer key); gpointer (*get) (ValaMap* self, gconstpointer key); void (*set) (ValaMap* self, gconstpointer key, gconstpointer value); gboolean (*remove) (ValaMap* self, gconstpointer key); void (*clear) (ValaMap* self); ValaMapIterator* (*map_iterator) (ValaMap* self); gint (*get_size) (ValaMap* self); }; struct _ValaHashMap { ValaMap parent_instance; ValaHashMapPrivate * priv; }; struct _ValaHashMapClass { ValaMapClass parent_class; }; struct _ValaSet { ValaCollection parent_instance; ValaSetPrivate * priv; }; struct _ValaSetClass { ValaCollectionClass parent_class; }; struct _ValaHashSet { ValaSet parent_instance; ValaHashSetPrivate * priv; }; struct _ValaHashSetClass { ValaSetClass parent_class; }; struct _ValaMapIterator { GTypeInstance parent_instance; volatile int ref_count; ValaMapIteratorPrivate * priv; }; struct _ValaMapIteratorClass { GTypeClass parent_class; void (*finalize) (ValaMapIterator *self); gboolean (*next) (ValaMapIterator* self); gpointer (*get_key) (ValaMapIterator* self); gpointer (*get_value) (ValaMapIterator* self); }; struct _ValaIterator { GTypeInstance parent_instance; volatile int ref_count; ValaIteratorPrivate * priv; }; struct _ValaIteratorClass { GTypeClass parent_class; void (*finalize) (ValaIterator *self); gboolean (*next) (ValaIterator* self); gboolean (*has_next) (ValaIterator* self); gpointer (*get) (ValaIterator* self); void (*remove) (ValaIterator* self); gboolean (*get_valid) (ValaIterator* self); }; gpointer vala_iterable_ref (gpointer instance); void vala_iterable_unref (gpointer instance); GParamSpec* vala_param_spec_iterable (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_iterable (GValue* value, gpointer v_object); void vala_value_take_iterable (GValue* value, gpointer v_object); gpointer vala_value_get_iterable (const GValue* value); GType vala_iterable_get_type (void) G_GNUC_CONST; gpointer vala_iterator_ref (gpointer instance); void vala_iterator_unref (gpointer instance); GParamSpec* vala_param_spec_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_iterator (GValue* value, gpointer v_object); void vala_value_take_iterator (GValue* value, gpointer v_object); gpointer vala_value_get_iterator (const GValue* value); GType vala_iterator_get_type (void) G_GNUC_CONST; GType vala_collection_get_type (void) G_GNUC_CONST; GType vala_list_get_type (void) G_GNUC_CONST; GType vala_array_list_get_type (void) G_GNUC_CONST; ValaArrayList* vala_array_list_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GEqualFunc equal_func); ValaArrayList* vala_array_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GEqualFunc equal_func); void vala_array_list_set_equal_func (ValaArrayList* self, GEqualFunc value); gboolean vala_collection_contains (ValaCollection* self, gconstpointer item); gboolean vala_collection_add (ValaCollection* self, gconstpointer item); gboolean vala_collection_remove (ValaCollection* self, gconstpointer item); void vala_collection_clear (ValaCollection* self); gboolean vala_collection_add_all (ValaCollection* self, ValaCollection* collection); gpointer* vala_collection_to_array (ValaCollection* self, int* result_length1); ValaCollection* vala_collection_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func); gint vala_collection_get_size (ValaCollection* self); gboolean vala_collection_get_is_empty (ValaCollection* self); gpointer vala_map_ref (gpointer instance); void vala_map_unref (gpointer instance); GParamSpec* vala_param_spec_map (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_map (GValue* value, gpointer v_object); void vala_value_take_map (GValue* value, gpointer v_object); gpointer vala_value_get_map (const GValue* value); GType vala_map_get_type (void) G_GNUC_CONST; GType vala_set_get_type (void) G_GNUC_CONST; gpointer vala_map_iterator_ref (gpointer instance); void vala_map_iterator_unref (gpointer instance); GParamSpec* vala_param_spec_map_iterator (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_value_set_map_iterator (GValue* value, gpointer v_object); void vala_value_take_map_iterator (GValue* value, gpointer v_object); gpointer vala_value_get_map_iterator (const GValue* value); GType vala_map_iterator_get_type (void) G_GNUC_CONST; GType vala_hash_map_get_type (void) G_GNUC_CONST; ValaHashMap* vala_hash_map_new (GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GHashFunc key_hash_func, GEqualFunc key_equal_func, GEqualFunc value_equal_func); ValaHashMap* vala_hash_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func, GHashFunc key_hash_func, GEqualFunc key_equal_func, GEqualFunc value_equal_func); void vala_hash_map_set_key_hash_func (ValaHashMap* self, GHashFunc value); void vala_hash_map_set_key_equal_func (ValaHashMap* self, GEqualFunc value); void vala_hash_map_set_value_equal_func (ValaHashMap* self, GEqualFunc value); GType vala_hash_set_get_type (void) G_GNUC_CONST; ValaHashSet* vala_hash_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GHashFunc hash_func, GEqualFunc equal_func); ValaHashSet* vala_hash_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GHashFunc hash_func, GEqualFunc equal_func); void vala_hash_set_set_hash_func (ValaHashSet* self, GHashFunc value); void vala_hash_set_set_equal_func (ValaHashSet* self, GEqualFunc value); GType vala_iterable_get_element_type (ValaIterable* self); ValaIterator* vala_iterable_iterator (ValaIterable* self); ValaIterable* vala_iterable_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func); gboolean vala_map_iterator_next (ValaMapIterator* self); gpointer vala_map_iterator_get_key (ValaMapIterator* self); gpointer vala_map_iterator_get_value (ValaMapIterator* self); ValaMapIterator* vala_map_iterator_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func); gboolean vala_iterator_next (ValaIterator* self); gboolean vala_iterator_has_next (ValaIterator* self); gpointer vala_iterator_get (ValaIterator* self); void vala_iterator_remove (ValaIterator* self); ValaIterator* vala_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func); gboolean vala_iterator_get_valid (ValaIterator* self); gpointer vala_list_get (ValaList* self, gint index); void vala_list_set (ValaList* self, gint index, gconstpointer item); gint vala_list_index_of (ValaList* self, gconstpointer item); void vala_list_insert (ValaList* self, gint index, gconstpointer item); gpointer vala_list_remove_at (ValaList* self, gint index); gpointer vala_list_first (ValaList* self); gpointer vala_list_last (ValaList* self); void vala_list_insert_all (ValaList* self, gint index, ValaCollection* collection); void vala_list_sort (ValaList* self, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify); ValaList* vala_list_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func); ValaSet* vala_map_get_keys (ValaMap* self); ValaCollection* vala_map_get_values (ValaMap* self); gboolean vala_map_contains (ValaMap* self, gconstpointer key); gpointer vala_map_get (ValaMap* self, gconstpointer key); void vala_map_set (ValaMap* self, gconstpointer key, gconstpointer value); gboolean vala_map_remove (ValaMap* self, gconstpointer key); void vala_map_clear (ValaMap* self); ValaMapIterator* vala_map_map_iterator (ValaMap* self); ValaMap* vala_map_construct (GType object_type, GType k_type, GBoxedCopyFunc k_dup_func, GDestroyNotify k_destroy_func, GType v_type, GBoxedCopyFunc v_dup_func, GDestroyNotify v_destroy_func); gint vala_map_get_size (ValaMap* self); ValaSet* vala_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func); G_END_DECLS #endif valabind-1.5.0/swigwriter.vala000066400000000000000000000340701323123274000163510ustar00rootroot00000000000000/* Copyright 2009-2017 -- pancake, eddyb, ritesh */ using Vala; public class SwigWriter : ValabindWriter { public GLib.List includefiles = new GLib.List (); bool cxx_mode; string statics = ""; string structs = ""; string extends = ""; string enums = ""; string vectors = ""; string ?ns_pfx; public SwigWriter (bool cxx_mode) { this.cxx_mode = cxx_mode; } public override string get_filename (string base_name) { return base_name+".i"; } // FIXME duplicate from NodeFFIWriter and ctypeswriter void add_includes (Symbol s) { foreach (string i in Vala.get_ccode_header_filenames (s).split (",")) { bool include = true; foreach (string j in includefiles) { if (i == j) { include = false; break; } } if (include) includefiles.prepend (i); } } // FIXME duplicate from NodeFFIWriter string sep (string str, string separator) { if (str.length == 0) return str; char last = str[str.length-1]; if (last != '(' && last != '[' && last != '{') return str+separator; return str; } string get_alias (string oname) { string name = oname; if (this.camelgetters) { if (oname.has_prefix ("set_")) { var capital = "%c".printf (oname[4].toupper ()); return "set" + capital + oname.substring (5); } else if (oname.has_prefix ("get_")) { var capital = "%c".printf (oname[4].toupper ()); return "get" + capital + oname.substring (5); } } switch (oname) { case "call": case "lock": case "base": case "clone": case "break": case "delete": name = "_" + oname; break; case "continue": name = "cont"; break; } if (name != oname) { warning ("Method %s renamed to %s (don't ask where)".printf (oname, name)); } return name; } string type_name (DataType type, bool retType=false, bool ignoreRef=false) { if (type == null) { warning ("Cannot resolve type"); return "__UNRESOLVED_TYPE_OH_PLEASE_KILL_ME_NOW__"; } // HACK is this required? if (type is EnumValueType) { return "long int"; } // HACK needs proper generic support if (type is GenericType) { return "void*"; //return type.to_qualified_string (); } if (type is PointerType) { return type_name ((type as PointerType).base_type, retType, true)+"*"; } if (type is ArrayType) { ArrayType array = type as ArrayType; string element = type_name (array.element_type, retType); int len = array_length(array); if (len < 0 ) return element+"*"; // FIXME should this be element+"[]"? return element+"[%d]".printf (len); // FIXME will this work? } if (!ignoreRef && (type is ReferenceType)) { string unref_type = type_name (type, retType, true); // HACK just check for the string class instead (how?) if (unref_type == "char*" || unref_type == "const char*") return unref_type; // FIXME should it be & under C++? return unref_type+"*"; } string generic = ""; foreach (DataType t in type.get_type_arguments ()) { generic = sep (generic, ", ") + type_name (t); } string _type = type.to_string (); // HACK find a better way to remove generic type args _type = _type.split ("<", 2)[0]; _type = _type.replace (ns_pfx, "").replace (".", ""); _type = _type.replace ("?",""); _type = _type.replace ("unsigned ", "u"); switch (_type) { case "bool": case "gboolean": return "bool"; case "gconstpointer": case "gpointer": return "void*"; case "gchar": return "char"; /* Hack to bypass namespace rules in r2-bindings */ case "SDBSdb": return "Sdb"; case "gint": case "st32": case "int32": case "gint32": return "int"; case "uint": case "guint": case "ut32": case "uint32": case "guint32": return "unsigned int"; case "glong": return "long"; case "ut8": case "uint8": case "guint8": return "unsigned char"; case "guint16": case "uint16": return "unsigned short"; case "st64": case "int64": case "gint64": return "long long"; case "ut64": case "uint64": case "guint64": // HACK uint64_t doesn't work here because radare2 doesn't use the right type return "unsigned long long"; case "gdouble": return "double"; case "gfloat": return "float"; case "string": return retType ? "const char*" : "char*"; //case "const gchar*": // return "const char*"; // HACK needs proper generic support case "RList": if (generic != "") { return "std::vector<"+generic+">"; } break; case "SdbList": if (generic != "") { return "std::vector<"+generic+">"; } break; } return _type; } public override void visit_constant (Constant c) { var cname = Vala.get_ccode_name (c); extends += "%immutable "+c.name+";\n"; extends += "static const char *"+c.name+" = "+cname+";\n"; } public override void visit_enum (Vala.Enum e) { add_includes (e); /*extends += "enum %s {\n".printf (e.name); foreach (var v in e.get_values ()) extends += "\t%s = %s,\n".printf (v.name, Vala.get_ccode_name (v)); extends += "};\n";*/ } public override void visit_struct (Struct s) { add_includes (s); // FIXME does SWIG support actual namespaces? string name = s.get_full_name ().replace (ns_pfx, "").replace (".", ""); string cname = Vala.get_ccode_name (s); structs += "typedef struct %s {\n".printf (cname); foreach (Field f in s.get_fields ()) f.accept (this); structs += "} %s;\n".printf (name); var methods = s.get_methods (); if (methods.size > 0) { extends += "%%extend %s {\n".printf (name); // NOTE if m.accept (this) is used, it might try other functions than visit_method foreach (Method m in methods) visit_method (m); extends += "};\n"; } } public override void visit_class (Class c) { add_includes (c); // FIXME does SWIG support actual namespaces? string name = c.get_full_name ().replace (ns_pfx, "").replace (".", ""); string cname = Vala.get_ccode_name (c); structs += "typedef struct %s {\n".printf (cname); foreach (Field f in c.get_fields ()) f.accept (this); structs += "} %s;\n".printf (name); foreach (Vala.Enum e in c.get_enums ()) e.accept (this); string? freefun = null; if (Vala.is_reference_counting (c)) freefun = Vala.get_ccode_unref_function (c); else freefun = Vala.get_ccode_free_function (c); if (freefun == "") freefun = null; var methods = c.get_methods (); if (freefun != null || methods.size > 0) { extends += "%%extend %s {\n".printf (name); if (freefun != null && freefun != "") extends += "\t~%s() {\n\t\t%s(self);\n\t}\n".printf (name, freefun); // NOTE if m.accept (this) is used, it might try other functions than visit_method foreach (Method m in methods) visit_method (m); extends += "};\n"; } foreach (Struct s in c.get_structs ()) s.accept (this); foreach (Class k in c.get_classes ()) k.accept (this); } public override void visit_field (Field f) { if (f.is_private_symbol ()) return; // HACK don't output fields with C++ keywords as names. if (f.name == "class") return; string field = ""; DataType type = f.variable_type; if (type is ArrayType) { ArrayType array = type as ArrayType; string element = type_name (array.element_type); int len = array_length(array); if (len < 0) field = element + "* " + f.name; // FIXME should this be element+"[]"? field = element + " " + f.name + "[%d]".printf (len); // FIXME will this work? } else { /* HACK to support generics. this is r2 specific */ string _type = type.to_string (); if (_type.index_of ("RListIter") != -1) { field = "RListIter* " + f.name; } else if (_type.index_of ("RList") != -1) { field = "RList* " + f.name; } else if (_type.index_of ("SdbListIter") != -1) { field = "SdbListIter* " + f.name; } else if (_type.index_of ("SdbList") != -1) { field = "SdbList* " + f.name; } else { field = type_name (type) + " " + f.name; } } structs += "\t" + field + ";\n"; } public override void visit_method (Method m) { if (m.is_private_symbol ()) { return; } add_includes (m); string cname = Vala.get_ccode_name (m), alias = get_alias (m.name); var parent = m.parent_symbol; bool is_static = (m.binding & MemberBinding.STATIC) != 0, is_constructor = (m is CreationMethod); bool parent_is_class = parent is Class || parent is Struct; // TODO: Implement contractual support // m.get_preconditions (); // m.get_postconditions (); string ret = type_name (m.return_type, true); string def_args = "", call_args = ""; string applys = "", clears = ""; foreach (var foo in m.get_parameters ()) { //DataType? bar = foo.parameter_type; DataType? bar = foo.variable_type; if (bar == null) continue; string arg_name = get_alias (foo.name); string? arg_type = type_name (bar); /* TODO: move to type_name */ if (foo.direction != ParameterDirection.IN) { var var_name = ""; if (foo.direction == ParameterDirection.OUT) var_name = "OUTPUT"; else if (foo.direction == ParameterDirection.REF) var_name = "INOUT"; if (arg_type.index_of ("*") == -1) arg_type += "*"; applys += "\t%%apply %s %s { %s %s };\n".printf (arg_type, var_name, arg_type, arg_name); clears += "\t%%clear %s %s;\n".printf (arg_type, arg_name); } call_args = sep (call_args, ", ") + arg_name; def_args = sep (def_args, ", ") + arg_type + " " + arg_name; } if (is_constructor) { //externs += "extern %s* %s (%s);\n".printf (classcname, cname, def_args); var classname = parent.get_full_name ().replace (ns_pfx, "").replace (".", ""); extends += applys; extends += "\t%s (%s) {\n".printf (classname, def_args); if (context.is_defined ("GOBJECT")) extends += "\t\tg_type_init ();\n"; extends += "\t\treturn %s (%s);\n\t}\n".printf (cname, call_args); extends += clears; } else { string func = ""; string fbdy = ""; //if (is_static) //statics += "extern %s %s (%s);\n".printf (ret, cname, def_args); //else { if (!is_static) { if (call_args == "") call_args = "self"; else call_args = "self, " + call_args; } //externs += "extern %s %s (%s*, %s);\n".printf (ret, cname, classname, def_args); func += applys; //BEGIN HACK HACK HACK DIE IN A FIRE if (cxx_mode && ret.index_of ("std::vector") != -1) { ret = ret.replace (">*", ">").replace ("*>",">"); int ptr = ret.index_of ("<"); string iter_type = (ptr==-1) ? ret : ret[ptr : ret.length]; iter_type = iter_type.replace ("<", ""); iter_type = iter_type.replace (">", ""); iter_type = iter_type.replace ("*", ""); //ret = ret.replace ("*>", ">"); // TODO: Check if iter type exists before failing // instead of hardcoding the most common type '' // TODO: Do not construct a generic class if not supported // instead of failing. if (iter_type == "G*") /* No generic */ error ("Oops. No type support.\n"); // TODO: Do not recheck the return_type if (m.return_type.to_string ().index_of ("RList") != -1) { fbdy += "\t\t%s ret;\n".printf (ret); fbdy += "\t\tRList *list;\n"; fbdy += "\t\tRListIter *iter;\n"; fbdy += "\t\t%s *item;\n".printf (iter_type); fbdy += "\t\tlist = %s (%s);\n".printf (cname, call_args); fbdy += "\t\tif (list)\n"; fbdy += "\t\tfor (iter = list->head; iter && (item = (%s*)iter->data); iter = iter->n)\n".printf (iter_type); fbdy += "\t\t\tret.push_back(*item);\n"; fbdy += "\t\treturn ret;\n"; fbdy += "\t}\n"; } if (m.return_type.to_string ().index_of ("SdbList") != -1) { fbdy += "\t\t%s ret;\n".printf (ret); fbdy += "\t\tSdbList *list;\n"; fbdy += "\t\tSdbListIter *iter;\n"; fbdy += "\t\t%s *item;\n".printf (iter_type); fbdy += "\t\tlist = %s (%s);\n".printf (cname, call_args); fbdy += "\t\tif (list)\n"; fbdy += "\t\tfor (iter = list->head; iter && (item = (%s*)iter->data); iter = iter->n)\n".printf (iter_type); fbdy += "\t\t\tret.push_back(*item);\n"; fbdy += "\t\treturn ret;\n"; fbdy += "\t}\n"; } vectors += "\t%%template(%sVector) std::vector<%s>;\n".printf ( iter_type, iter_type); } else //END HACK HACK HACK DIE IN A FIRE fbdy += "\t\t%s%s(%s);\n\t}\n".printf ((ret == "void")?"":"return ", cname, call_args); if (is_static) func += "\tstatic %s %s(%s) {\n".printf (ret, alias, def_args); else func += "\t%s %s(%s) {\n".printf (ret, alias, def_args); func += fbdy; func += clears; if (!parent_is_class) { statics += func; extends += "\tstatic %s %s(%s);\n".printf (ret, alias, def_args); } else extends += func; } } public override void visit_namespace (Namespace ns) { string name = ns.get_full_name (); bool use = use_namespace (ns); if (use) ns_pfx = name+ "."; if (ns_pfx != null) add_includes (ns); foreach (var n in ns.get_namespaces ()) n.accept (this); if (ns_pfx != null) { foreach (Constant c in ns.get_constants ()) c.accept (this); //foreach (Field f in ns.get_fields ()) // f.accept (this); foreach (Vala.Enum e in ns.get_enums ()) e.accept (this); foreach (Struct s in ns.get_structs ()) s.accept (this); foreach (Class c in ns.get_classes ()) c.accept (this); //foreach (Method m in ns.get_methods ()) // m.accept (this); } if (use) ns_pfx = null; } public override void write (string file) { var stream = FileStream.open (file, "w"); if (stream == null) error ("Cannot open %s for writing".printf (file)); context.root.accept (this); stream.printf ("%%module %s\n%%{\n", modulename); if (!cxx_mode) stream.printf ( "\t#define bool int\n"+ "\t#define true 1\n"+ "\t#define false 0\n"); if (statics != "" || includefiles.length () > 0) { if (cxx_mode) stream.printf ("\textern \"C\" {\n"); foreach (string inc in includefiles) stream.printf ("\t#include <%s>\n", inc); stream.printf ("%s", statics); if (cxx_mode) stream.printf ("\t}\n\t#include \n"); } stream.printf ("%%}\n"); if (cxx_mode && vectors != "") stream.printf ("%%include \"std_vector.i\"\n\nnamespace std {\n%s}\n", vectors); stream.printf ("%s\n", structs); stream.printf ("%s\n", enums); stream.printf ("%s\n", extends); } } valabind-1.5.0/t/000077500000000000000000000000001323123274000135355ustar00rootroot00000000000000valabind-1.5.0/t/gir/000077500000000000000000000000001323123274000143165ustar00rootroot00000000000000valabind-1.5.0/t/gir/Makefile000066400000000000000000000000751323123274000157600ustar00rootroot00000000000000VB=../../valabind all: ${VB} --gir --module=Test Test.vapi valabind-1.5.0/t/gir/Test.vapi000066400000000000000000000004001323123274000161100ustar00rootroot00000000000000namespace Test { public static void hello (); [CCode (cname="getenv")] public static string getenv (string k); public class Animal { int legs; public Animal (); public bool can_walk (); } public struct Ball { int size; string color; } } valabind-1.5.0/t/go/000077500000000000000000000000001323123274000141425ustar00rootroot00000000000000valabind-1.5.0/t/go/camelcase.vapi000066400000000000000000000006501323123274000167410ustar00rootroot00000000000000// test for converting lowercase symbol names with a bunch of '_' // to CamelCase namespace Test { [CCode (lower_case_cprefix="test_")] namespace N { public static void fn1(); // --> Fn1 public static void fn_fn2(); // --> FnFn2 public static void fn_fn3_(); // --> FnFn3_ public static void fn_fn4_a(); // --> FnFn4A public static void fn6__(); // --> Fn6__ public static void fn_f7(); // --> FnF7 } } valabind-1.5.0/t/go/classes.vapi000066400000000000000000000011561323123274000164630ustar00rootroot00000000000000namespace Test { [Compact] [CCode (cprefix="a_", cname="A", free_function="a_free")] public class AA { public int m1; public char m2; public string m3; public int type; public AA(); public AA.from_string(string p1); public int f1(); public void f2(); public int f3(int p1); public string f4(string p1); public void *f5(void *p1); } // has no free function [Compact] [CCode (cprefix="b_", cname="B")] public class BB { public BB(); } // has unusually named free function [Compact] [CCode (cprefix="c_", cname="C", free_function="free_at_last")] public class CC { public CC(); } } valabind-1.5.0/t/go/enums.vapi000066400000000000000000000001231323123274000161460ustar00rootroot00000000000000namespace Test { [CCode (cprefix="NN_")] public enum N { A, B, C, D } } valabind-1.5.0/t/go/generic_names.vapi000066400000000000000000000007731323123274000176310ustar00rootroot00000000000000namespace Test { [Compact] [CCode (cprefix="l_", cname="L", free_function="l_free")] public class List { public List(); } [Compact] [CCode (cprefix="m_", cname="M", free_function="m_free")] public class Map { public Map(); } [Compact] [CCode (cprefix="a_", cname="A", free_function="a_free")] public class AA { public List m1; public Map m2; public List> m3; public Map> m4; public Map, int> m5; public AA(); } } valabind-1.5.0/t/go/generics.vapi000066400000000000000000000020111323123274000166140ustar00rootroot00000000000000namespace Test { [Compact] [CCode (cprefix="a_", cname="A", free_function="a_free")] public class AA { public int m1; public char m2; public string m3; public int type; public AA(); public AA.from_it(G p1); public G f1(); public void f2(); public G f3(G p1); public void f4(G *p1); public G *f5(); } [Compact] [CCode (cprefix="b_", cname="B", free_function="b_free")] public class BB { public AA m1; } [Compact] [CCode (cprefix="c_", cname="C", free_function="c_free")] public class CC { public G m1; public H m2; public CC(); } [Compact] [CCode (cprefix="D_", cname="D", free_function="d_free")] public class DD { public CC m1; } [Compact] [CCode (cprefix="e_", cname="E", free_function="e_free")] public class EE { public CC> m1; // note, AA already used [Compact] [CCode (cprefix="f_", cname="F", free_function="f_free")] public class FF { public CC> m1; // note, AA not yet defined } } } valabind-1.5.0/t/go/namespace_function.vapi000066400000000000000000000004761323123274000206730ustar00rootroot00000000000000namespace Test { [CCode (lower_case_cprefix="test_")] namespace N { public static void fn1(); public static int fn2(int p1, char p2, char *p3, int *p4); public static void fn3(out int p1); public static void fn4(string? p1=null); public static void fn5(out int p1=null); public static string fn6(); } } valabind-1.5.0/t/go/structs.vapi000066400000000000000000000002111323123274000165240ustar00rootroot00000000000000namespace Test { [CCode (cname="NN")] public struct N { public int f1; public char f2; public string f3; public int type; } } valabind-1.5.0/t/java/000077500000000000000000000000001323123274000144565ustar00rootroot00000000000000valabind-1.5.0/t/java/AsmExample.java000066400000000000000000000007631323123274000173630ustar00rootroot00000000000000import com.sun.jna.Library; import com.sun.jna.Native; import com.sun.jna.Platform; import com.sun.jna.Pointer; import com.sun.jna.Structure; public class AsmExample { public static void main(String[] args) { RAsm a = new RAsm (); a.use ("x86"); a.set_bits (32); RAsmCode code = a.mdisassemble_hexstr ("909090"); System.out.println ("LEN "+ code.len); System.out.println ("CODE "+ code.buf_asm); code = a.massemble ("mov eax, 33"); System.out.println ("HEX "+code.buf_hex); } } valabind-1.5.0/t/java/Makefile000066400000000000000000000004111323123274000161120ustar00rootroot00000000000000WGET=wget --no-check-certificate all: jna.jar javac -cp jna.jar:. AsmExample.java RAsmCode.java RAsm.java java -cp jna.jar:. AsmExample jna.jar: ${WGET} https://raw.github.com/twall/jna/3.4.1/dist/jna.jar clean: rm -f *.class mrproper: clean rm -f jna.jar valabind-1.5.0/t/java/RAsm.java000066400000000000000000000016071323123274000161670ustar00rootroot00000000000000 import com.sun.jna.Library; import com.sun.jna.Native; import com.sun.jna.Platform; import com.sun.jna.Pointer; import com.sun.jna.Structure; public class RAsm { public interface C extends Library { C lib = (C) Native.loadLibrary ("r_asm", C.class); Pointer r_asm_new (); int r_asm_use (Pointer p, String s); int r_asm_set_bits (Pointer p, int b); RAsmCode r_asm_mdisassemble_hexstr (Pointer p, String s); RAsmCode r_asm_massemble (Pointer p, String s); } Pointer self = null; public RAsm() { self = C.lib.r_asm_new (); } public boolean use (String str) { return (C.lib.r_asm_use (self, str) == 1); } public boolean set_bits (int b) { return (C.lib.r_asm_set_bits (self, b) == 1); } public RAsmCode mdisassemble_hexstr (String s) { return C.lib.r_asm_mdisassemble_hexstr (self, s); } public RAsmCode massemble(String s) { return C.lib.r_asm_massemble (self, s); } } valabind-1.5.0/t/java/RAsmCode.java000066400000000000000000000004201323123274000167520ustar00rootroot00000000000000import com.sun.jna.Library; import com.sun.jna.Native; import com.sun.jna.Platform; import com.sun.jna.Pointer; import com.sun.jna.Structure; public class RAsmCode extends Structure { public int len; public String buf; public String buf_hex; public String buf_asm; } valabind-1.5.0/t/python/000077500000000000000000000000001323123274000150565ustar00rootroot00000000000000valabind-1.5.0/t/python/example.py000066400000000000000000000035401323123274000170650ustar00rootroot00000000000000# RAsm ctypes example # from ctypes import * from ctypes.util import find_library # helper functions lib = CDLL (find_library ("r_asm")) free = getattr (lib, "free") def register (self, name, cname, args, ret): g = globals () g['self'] = self if (ret!='' and ret[0]>='A' and ret[0]<='Z'): last = ".contents" ret = "POINTER("+ret+")" ret2 = "" else: last = "" ret2 = ret setattr (self,cname, getattr (lib, cname)) exec ("self.%s.argtypes = [%s]"%(cname, args)) if ret != "": exec ("self.%s.restype = %s"%(cname, ret), g) exec ("self.%s = lambda x: %s(self.%s(self._o, x))%s"% (name, ret2, cname, last),g) # define classes class RAsmCode(Structure): _fields_ = [ ("len", c_int), ("buf", c_char_p), ("buf_hex", c_char_p), ("buf_asm", c_char_p) ] class RAsm(Structure): _fields_ = [ ("bits", c_int), ("big_endian", c_int), ("syntax", c_int), ("pc", c_ulonglong) ] def __init__(self): r_asm_new = getattr (lib, "r_asm_new"); r_asm_new.restype = c_void_p self._o = r_asm_new () register (self, 'use', 'r_asm_use', 'c_void_p, c_char_p', 'c_bool') register (self, '__del__', 'r_asm_free', 'c_void_p', '') register (self, 'set_pc', 'r_asm_set_pc', 'c_void_p, c_ulonglong', 'c_bool') register (self, 'set_bits', 'r_asm_set_bits', 'c_void_p, c_int', 'c_bool') register (self, 'massemble', 'r_asm_massemble', 'c_void_p, c_char_p', 'RAsmCode') register (self, 'mdisassemble_hexstr', 'r_asm_mdisassemble_hexstr', 'c_void_p, c_char_p', 'RAsmCode') # Example a = RAsm() ok0 = a.use ("x86") ok1 = a.set_bits (32) ok2 = a.mdisassemble_hexstr ("909090") ok4 = a.set_pc (0x8048000) print (ok0, ok1, a, ok4) print ("Disasm len: ",ok2.len) print ("Disasm buf: ",ok2.buf_hex) print ("Disasm asm: ",ok2.buf_asm) print (ok2.buf_asm) # print (a.SYNTAX.INTEL) ok3 = a.massemble ("mov eax, 33") print ("Assemble hex:", ok3.buf_hex) a = None valabind-1.5.0/t/r2/000077500000000000000000000000001323123274000140605ustar00rootroot00000000000000valabind-1.5.0/t/r2/Makefile000066400000000000000000000007271323123274000155260ustar00rootroot00000000000000# XXX: Hardcoded path # HACK(eddyb): Relative path, more chance of success :) R2PATH:=../../../radare2 MOD:=r_bp NS:=Radare FLAGS:=$(MOD) $(MOD) -N$(NS) -I$(R2PATH)/libr/include --vapidir=$(R2PATH)/r2-bindings/vapi -l$(MOD) all: perl ruby python csharp perl: valabind-cc perl $(FLAGS) ruby: valabind-cc ruby $(FLAGS) python: rm -f r_bp.so valabind-cc python $(FLAGS) csharp: valabind-cc csharp $(FLAGS) mcs -main:test *.cs .PHONY: all perl ruby python csharp valabind-1.5.0/t/r2/test.cs000066400000000000000000000003241323123274000153650ustar00rootroot00000000000000using System; public class test { public static void Main () { Console.WriteLine ("Hello World\n"); RBreakpoint bp = new RBreakpoint (); bp.use ("x86"); bp.add_hw (0x8048400, 0, 0); bp.list (0); } } valabind-1.5.0/t/r2/test.java000066400000000000000000000003631323123274000157040ustar00rootroot00000000000000//import java.math; class test { public static void main (String[] args) { System.loadLibrary ("r_bp"); rBreakpoint bp = new rBreakpoint (); bp.use ("x86"); bp.add_sw (new java.math.BigInteger("0x804800"), 0, 0); bp.list (0); } } valabind-1.5.0/t/r2/test.pl000077500000000000000000000002411323123274000153740ustar00rootroot00000000000000#!/usr/bin/perl require 'r_bp.pm'; $a = new r_bp::RBreakpoint (); $a->use ("x86"); $a->add_hw (0x8048000, 10, 0); $a->add_sw (0x8048000, 10, 0); $a->list (0); valabind-1.5.0/t/r2/test.py000077500000000000000000000002171323123274000154140ustar00rootroot00000000000000#!/usr/bin/python from r_bp import * a = RBreakpoint () a.use ('x86') a.add_hw (0x8048000, 10, 0) a.add_sw (0x8048000, 10, 0) a.list (False) valabind-1.5.0/t/r2/test.rb000077500000000000000000000001601323123274000153640ustar00rootroot00000000000000#!/usr/bin/ruby require 'r_bp' bp = R_bp::RBreakpoint.new bp.use('x86'); bp.add_hw(0x8048400,0,0); bp.list(0) valabind-1.5.0/t/vala/000077500000000000000000000000001323123274000144605ustar00rootroot00000000000000valabind-1.5.0/t/vala/Makefile000066400000000000000000000016621323123274000161250ustar00rootroot00000000000000VAPI=vstest.vapi VALBINDCCFLAGS=-I. `pkg-config --cflags --libs gobject-2.0` -I/usr/include -L. -lvstest all: valac -H vstest.h -C --vapi=${VAPI} --library=libvstest vstest.vala ${CC} -fPIC -shared vstest.c -o libvstest.so `pkg-config --cflags --libs gobject-2.0` valabind-cc python vstest -NFood ${VAPI} ${VALBINDCCFLAGS} -x cxx: valac -H vstest.h -C --vapi=${VAPI} --library=libvstest vstest.vala valabind-cc python vstest -NFood -x ${VAPI} ${VALBINDCCFLAGS} # compile vstest.cxx as included in test.cxx gcc -c vstest.c -I. `pkg-config gobject-2.0 --cflags --libs` g++ vstest.o test.cxx -I. `pkg-config gobject-2.0 --cflags --libs` #g++ test.cxx -I. `pkg-config gobject-2.0 --cflags --libs` test: LD_LIBRARY_PATH=$${PWD} python test.py foo: valabind-cc python vstest -NFood ${VAPI} -I. `pkg-config --cflags --libs gobject-2.0` clean: rm -f vstest.vapi vstest.h *.so vstest.cxx *.o *.i a.out vstest.c vstest.py* vstest_wrap.c* valabind-1.5.0/t/vala/test.cxx000066400000000000000000000002431323123274000161620ustar00rootroot00000000000000#include "vstest.cxx" int main () { vstestFoodElement *foo = new vstestFoodElement (); foo->say ("world"); foo->say ("cruel world"); delete foo; return 0; } valabind-1.5.0/t/vala/test.py000066400000000000000000000003041323123274000160060ustar00rootroot00000000000000import vstest #import gobject a = vstest.Element () a.say ("world") print ("--") a.say ("cruel world") print ("--") # Creating a 2nd element make it segfault b=vstest.Element () b.say ("salsa") valabind-1.5.0/t/vala/vstest.vala000066400000000000000000000004171323123274000166570ustar00rootroot00000000000000using GLib; public class Food.Element { public enum Counter { START, STOP, RESET } public Element () { print ("Element constructed\n"); } ~Element () { print ("Element destroyed\n"); } public void say (string str) { print (@"Hello $(str)\n"); } } valabind-1.5.0/utils.vala000066400000000000000000000043371323123274000153060ustar00rootroot00000000000000/* Copyright 2009-2015 -- pancake, ritesh */ #if W32 using Windows; #endif public void notice (string msg) { stderr.printf ("\x1b[34;1mNOTICE\x1b[0m %s\n", msg); } public void warning (string msg) { stderr.printf ("\x1b[33;1mWARNING\x1b[0m %s\n", msg); } public void error (string msg) { stderr.printf ("\x1b[31;1mERROR\x1b[0m %s\n", msg); #if W32 Windows.exit (1); #else Posix.exit (1); #endif } // TODO: check out if this is really required ? public int array_length (Vala.ArrayType array) { #if VALA_0_25 || VALA_0_26 /* If valac >= 0.25 use this workaround to resolve the array length */ if (array.fixed_length && array.length is Vala.IntegerLiteral) { Vala.IntegerLiteral lit = (Vala.IntegerLiteral) array.length; return int.parse (lit.value); } return -1; #else return array.length; #endif } // TODO: make it reusable for other backends public string get_enums_for (string str, GLib.List includefiles) { string enums_exec, enums_out = ""; try { FileUtils.close (FileUtils.open_tmp ("vbeXXXXXX", out enums_exec)); } catch (FileError e) { error (e.message); } string[] gcc_args = {"gcc", "-x", "c", "-o", enums_exec, "-"}; foreach (var i in include_dirs) gcc_args += "-I"+i; try { Pid gcc_pid; int gcc_stdinfd; Process.spawn_async_with_pipes (null, gcc_args, null, SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD, null, out gcc_pid, out gcc_stdinfd); var gcc_stdin = FileStream.fdopen (gcc_stdinfd, "w"); if (gcc_stdin == null) throw new SpawnError.IO ("Cannot open gcc's stdin"); foreach (string i in includefiles) gcc_stdin.printf ("#include <%s>\n", i); gcc_stdin.printf ("int main(){%s;return 0;}\n", str); gcc_stdin = null; int status; #if W32 status = Windows.waitpid (gcc_pid); #else Posix.waitpid (gcc_pid, out status, 0); #endif Process.close_pid (gcc_pid); if (status != 0) throw new SpawnError.FAILED ("gcc exited with status %d", status); Process.spawn_sync (null, {enums_exec}, null, 0, null, out enums_out, null, out status); if (status != 0) throw new SpawnError.FAILED ("enums helper exited with status %d", status); } catch (SpawnError e) { FileUtils.unlink (enums_exec); error (e.message); } FileUtils.unlink (enums_exec); return enums_out; } valabind-1.5.0/valabind-cc000077500000000000000000000255051323123274000153720ustar00rootroot00000000000000#!/bin/sh # Copyleft valabind 2009-2017 pancake LANG=$1 MOD=$2 show_help () { echo "Usage: valabind-cc [lang] [module-name] [-flags] vapifile .." echo "Example: valabind-cc python r_bp -I/usr/include/r_bp r_bp.vapi" echo " lang: ctypes, python, dlang, nodejs, ocaml, guile, go, ruby," echo " perl, lua, java, csharp, ..." echo " --help,-h show this help message" echo " --version show version of valabind" echo " --vapidir=dir specify path to vapi files" echo " --glib assume vapi source is glib/gobject based" echo " --test [lang] test if it is possible to build" echo " -x generate C++ swig code" echo " -X output C++ instead of SWIG interface" echo " -I[path] add includepath for SWIGFLAGS and CFLAGS" echo " -V[path] add includepath for vapi files" echo " -L[path] append library path to LDFLAGS" echo " -l[lib] append to LDFLAGS to link a library" echo " -C do not compile, just let the .c/.cxx and .i files" echo " -n do not generate .i/.c/.cxx code, but compile it" echo " -N[nspace] include namespace in the output" echo " -D[SYMBOL] define vala symbol Symbol" echo " --nolibpython do not include libpython in Python flags" echo " Environment:" echo " VALABIND_DEBUG if not empty show stderr of commands" echo " PYTHON_CONFIG path to python-config program (select py2 or py3)" echo " SWIGFLAGS extra flags to be passed to swig" echo " SOEXT force extension for shared library (so, dll, dylib)" echo " SWIG path to swig program" exit 0 } OMOD=${MOD} [ -z "${SWIG}" ] && SWIG=swig [ -z "${LANG}" ] && show_help [ -z "${CC}" ] && CC=gcc [ -z "${CXX}" ] && CXX=g++ COMPILE=Yes ARG_VAPIDIR="" EXT="c" CXXOUT=0 NOGEN=0 if [ -z "${SOEXT}" ]; then if [ -n "`uname -a | grep -i darwin`" ]; then SOEXT="dylib" elif [ -n "`echo ${CC} | grep mingw`" ]; then SOEXT="dll" else SOEXT="so" fi fi if [ -z "${VALABIND_DEBUG}" ]; then NULLPIPE=">/dev/null" else NULLPIPE="" fi use_cxx() { CC="${CXX}" EXT="cxx" CFLAGS="${CFLAGS} ${CXXFLAGS}" SWIGFLAGS="-c++ ${SWIGFLAGS}" VALABINDFLAGS="-x ${VALABINDFLAGS}" } TEST=0 case "$1" in "--test") TEST=1 LANG=$2 ;; "--version") printf "valabind " ; valabind --version ${SWIG} -version | grep SWIG ${CC} --version | grep ${CC} exit 0 ;; "--help"|"-h") show_help ;; esac SWIG="${SWIG} -small" case "${LANG}" in ctypes) python2 --version >/dev/null 2>&1 || \ python --version > /dev/null 2>&1 || \ exit 1 ;; dlang) dmd --help >/dev/null 2>&1 || \ ldc2 --help >/dev/null 2>&1 || \ exit 1 ;; nodejs|node|node-ffi) node --version >/dev/null 2>&1 || exit 1 ;; ocaml) use_cxx echo "SWIG is buggy. Please set in ocamldec.swg the following line:" echo "#define caml_array_length swig_caml_array_length" OCAMLPATH=`ocamlc -where` CFLAGS="${CFLAGS} -I${OCAMLPATH}/ -Dcaml_array_length=caml_array_length__" LDFLAGS="${LDFLAGS} -L${OCAMLPATH} -lcamlrun" ;; guile) use_cxx CFLAGS="${CFLAGS} `guile-config compile 2>/dev/null`" LDFLAGS="${LDFLAGS} `guile-config link 2>/dev/null`" ;; python) use_cxx LDFLAGS="${LDFLAGS} -L/usr/local/lib -L/usr/pkg/lib" if [ -n "`echo ${CXX} | grep mingw`" ]; then CFLAGS="${CFLAGS} -I${HOME}/.wine/drive_c/Python27/include" LDFLAGS="${LDFLAGS} -L${HOME}/.wine/drive_c/Python27/libs -lpython27" else PYCFG="" for a in ${PYTHON_CONFIG} python-config python2-config python3-config ; do $a --help >/dev/null 2>&1 if [ $? = 0 ]; then PYCFG=$a break fi done if [ -z "$PYCFG" ]; then echo "No valid PYTHON_CONFIG command found" >&2 exit 1 fi CFLAGS="${CFLAGS} `$PYCFG --cflags | sed -e 's,-arch [^ ]*,,g'`" LDFLAGS="${LDFLAGS} `$PYCFG --ldflags| sed -e 's,-arch [^ ]*,,g'`" fi OMOD="_${MOD}" # XXX SWIGFLAGS="${SWIGFLAGS} -threads" ;; ruby) if [ "`ruby --version 2>/dev/null | grep 1.8`" ]; then RB_CFLAGS=`ruby -e 'require "mkmf"; print "-I" + RbConfig::CONFIG["archdir"];' 2>/dev/null` else if [ "`ruby --version 2>/dev/null | grep 1.9`" ]; then RB_CFLAGS=`ruby -e 'require "mkmf"; a=RbConfig::CONFIG["rubyhdrdir"]; print "-I#{a} -I#{a}/" + RbConfig::CONFIG["arch"];'` else if [ "`ruby --version 2>/dev/null | grep 2.0`" ]; then RB_CFLAGS=`ruby -e 'require "mkmf"; a=RbConfig::CONFIG["rubyhdrdir"]; print "-I#{a} -I#{a}/" + RbConfig::CONFIG["arch"];'` else if [ "`ruby --version 2>/dev/null | grep 2.1`" ]; then RB_CFLAGS=`ruby -e 'require "mkmf"; a=RbConfig::CONFIG["rubyhdrdir"]; print "-I#{a} -I#{a}/" + RbConfig::CONFIG["arch"];'` fi ; fi ; fi ; fi CFLAGS="${CFLAGS} ${RB_CFLAGS}" ;; perl) LC_ALL=C # fix anoying perl warning export LC_ALL CFLAGS="${CFLAGS} `perl -MExtUtils::Embed -e ccopts 2>/dev/null | sed -e 's,-arch [^ ]*,,g'`" LDFLAGS="${LDFLAGS} `perl -MExtUtils::Embed -e ldopts 2>/dev/null | sed -e 's,-arch [^ ]*,,g'`" ;; java) if [ -n "$JAVA_HOME" ]; then [ "`uname`" = Darwin ] && osname=darwin || osname=linux CFLAGS="${CFLAGS} -I${JAVA_HOME}/include -I${JAVA_HOME}/include/$osname" elif [ -f /opt/java/include/jni.h ]; then CFLAGS="${CFLAGS} -I/opt/java/include -I/opt/java/include/linux" fi ;; php5) CFLAGS="${CFLAGS} `php-config --includes 2>/dev/null` `pkg-config --libs libpng 2>/dev/null`" LDFLAGS="${LDFLAGS} `php-config --libs 2>/dev/null`" ;; lua) SOEXT=so LUAPKG=`pkg-config --list-all|awk '/lua|lua-/{print $1;}'` if [ -n "${LUAPKG}" ]; then CFLAGS="${CFLAGS} `pkg-config --cflags ${LUAPKG}`" LDFLAGS="${LDFLAGS} `pkg-config --libs ${LUAPKG}`" fi ;; go) ;; csharp) VALABINDFLAGS="--camel-getters ${VALABINDFLAGS}" ;; node-swig) SWIGFLAGS="-javascript" CFLAGS="${CFLAGS} -I/usr/include/node" ;; esac shift shift while : ; do [ -z "$1" ] && break if [ "`echo $1 | grep -- '^-I'`" ]; then CFLAGS="${CFLAGS} $1" SWIGFLAGS="$1 ${SWIGFLAGS}" VALABINDFLAGS="`echo $1|sed -e 's,^-I,-I ,'` ${VALABINDFLAGS}" elif [ "`echo $1 | grep -- '^-V'`" ]; then CFLAGS="${CFLAGS} $1" VALABINDFLAGS="`echo $1|sed -e 's,^-V,-V ,'` ${VALABINDFLAGS}" elif [ "`echo $1 | grep -- '--vapidir'`" ]; then ARG_VAPIDIR="`echo $1|sed -e 's,=, ,'`" elif [ "`echo $1 | grep -- '^-x'`" ]; then use_cxx elif [ "`echo $1 | grep -- '^-n'`" ]; then NOGEN=1 elif [ "`echo $1 | grep -- '^-N'`" ]; then VALABINDFLAGS="`echo $1|sed -e 's,^-N,-N ,'` ${VALABINDFLAGS}" elif [ "`echo $1 | grep -- '^-X'`" ]; then EXT="cxx" CXXOUT=1 elif [ "`echo $1 | grep -- '^-l'`" ]; then LDFLAGS="$1 ${LDFLAGS}" elif [ "`echo $1 | grep -- '^--glib'`" ]; then SWIGFLAGS="$1 ${SWIGFLAGS}" elif [ "`echo $1 | grep -- '^-L'`" ]; then LDFLAGS="$1 ${LDFLAGS}" elif [ "`echo $1 | grep -- '^-C'`" ]; then COMPILE="" elif [ "`echo $1 | grep -- '^-pthread'`" ]; then echo ignored $1 elif [ "`echo $1 | grep -- '^-D'`" ]; then VALABINDFLAGS="`echo $1|sed -e 's,^-D,-D ,'` ${VALABINDFLAGS}" elif [ "`echo $1 | grep -- '^--nolibpython'`" ]; then SEDFLAGS="-r" if [ -z "`sed --version 2>/dev/null | grep GNU`" ]; then SEDFLAGS="-E" fi LDFLAGS="$(echo ${LDFLAGS} | sed ${SEDFLAGS} 's,-lpython[0-9.]+,,g')" else FILES="$1 ${FILES}" fi shift done SWIGCPP="-DG_BEGIN_DECLS -DG_END_DECLS -DG_GNUC_CONST -DSWIG_PYTHON_SILENT_MEMLEAK" # strip problematic cflags. can be problematic if not used CFLAGS="`echo "${CFLAGS}" | sed -e 's,-pie,,g' -e 's,-PIE,,g'`" LDFLAGS="`echo "${LDFLAGS}" | sed -e 's,-pie,,g' -e 's,-PIE,,g'`" if [ "$CXXOUT" = 1 ]; then echo valabind -X ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.i -m ${MOD} ${FILES} valabind -X ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.cxx -m ${MOD} ${FILES} || exit 1 #TODO: #if [ -n "${COMPILE}" ]; then # echo ${CC} ${MOD}.cxx -fPIC -shared ${MOD}_wrap.${EXT} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} # ${CC} $@ -fPIC -shared ${MOD}_wrap.${EXT} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} || exit 1 #fi # echo ${CXX} ${MOD}.cxx $@ -fPIC -shared ${MOD}.cxx ${CXXFLAGS} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} # ${CXX} ${MOD}.cxx $@ -fPIC -shared ${MOD}.cxx ${CXXFLAGS} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} > /dev/null 2>&1 elif [ "$TEST" = 1 ]; then case "${LANG}" in ctypes) python2 --version > /dev/null 2>&1 || \ python --version > /dev/null 2>&1 || \ exit 1 ;; dlang) dmd --help >/dev/null 2>&1 || \ ldc2 --help >/dev/null 2>&1 || \ exit 1 ;; "nodejs"|"node"|"node-ffi") exec node --version > /dev/null 2>&1 ;; *) DIR=`mktemp -d /tmp/tmp.XXXXXX` if [ ! $? = 0 ]; then echo "Cannot create temporary directory" exit 1 fi cd ${DIR} MOD=test # hack to fix guile echo "%module ${MOD}" > ${MOD}.i eval echo ${SWIG} -O -o ${MOD}_wrap.${EXT} ${SWIGCPP} ${SWIGFLAGS} -${LANG} ${MOD}.i ${NULLPIPE} eval ${SWIG} -O -o ${MOD}_wrap.${EXT} ${SWIGCPP} ${SWIGFLAGS} -${LANG} ${MOD}.i ${NULLPIPE} if [ ! $? = 0 ]; then rm -rf ${DIR} ; exit 1 ; fi if [ "${EXT}" = cxx ]; then CFLAGS="${CFLAGS} ${CXXFLAGS}" fi eval echo ${CC} $@ -fPIC -shared ${MOD}_wrap.${EXT} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} ${NULLPIPE} eval ${CC} $@ -fPIC -shared ${MOD}_wrap.${EXT} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} ${NULLPIPE} if [ ! $? = 0 ]; then rm -rf ${DIR} ; exit 1 ; fi rm -rf ${DIR} ;; esac else case "${LANG}" in "ctypes") eval echo valabind --ctypes ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.py -m ${MOD} ${FILES} eval valabind --ctypes ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.py -m ${MOD} ${FILES} ${NULLPIPE} exit $? ;; "nodejs"|node|"node-ffi") eval echo valabind --node-ffi ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.js -m ${MOD} ${FILES} eval valabind --node-ffi ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.js -m ${MOD} ${FILES} ${NULLPIPE} exit $? ;; *) [ "${LANG}" = node-swig ] && LANG=node if [ "${NOGEN}" = 0 ]; then echo valabind --swig ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.i -m ${MOD} ${FILES} valabind --swig ${VALABINDFLAGS} ${ARG_VAPIDIR} -o ${MOD}.i -m ${MOD} ${FILES} || exit 1 eval echo ${SWIG} -O -o ${MOD}_wrap.cxx ${SWIGCPP} ${SWIGFLAGS} -${LANG} ${MOD}.i ${SWIG} -O -o ${MOD}_wrap.cxx ${SWIGCPP} ${SWIGFLAGS} -${LANG} ${MOD}.i || exit 1 fi if [ -n "${COMPILE}" ]; then # Damn Python flags! CFLAGS="`echo ${CFLAGS} | sed -e 's,-mno[^\ ]*,,g' -e 's,-f[^\ ]*,,g'`" LDFLAGS="`echo ${LDFLAGS} | sed -e 's,-pagezero_size [^\ ]*,,g'`" LDFLAGS="`echo ${LDFLAGS} | sed -e 's,-image_base [^\ ]*,,g'`" if [ "${EXT}" = cxx ]; then CFLAGS="${CFLAGS} ${CXXFLAGS}" fi echo ${CC} $@ -fPIC -shared ${MOD}_wrap.${EXT} ${SWIGCPP} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} ${CC} $@ -fPIC -shared ${MOD}_wrap.${EXT} ${SWIGCPP} ${CFLAGS} -o ${OMOD}.${SOEXT} ${LDFLAGS} || exit 1 fi esac fi valabind-1.5.0/valabind-cc.1000066400000000000000000000016521323123274000155230ustar00rootroot00000000000000.Dd Nov 15,2012 .Dt valabind-cc \&1 "Valabind compiler frontend" .Os valabind-cc .Sh NAME . .Dd .Nm valabind-cc .Nd Vala to swig interface compiler .Pp .Sh SYNOPSIS .Nm valabind-cc .Ar language .Ar modname .Op Fl -version .Op Fl -vapidir Ar dir .Op Fl -glib .Op Fl -test Ar lang .Op Fl n .Op Fl x .Op Fl X .Op Fl I Ar path .Op Fl L Ar path .Op Fl l Ar libname .Op Fl D Ar SYMBOL .Op Fl C .Ar vapifile .Sh DESCRIPTION valabind-cc is a frontend for valabind, swig and the C compiler (gcc by default). .Pp It aims to simplify the use of all the wrapped tools and compile usable bindings for many programming languages. .Pp .Sh EXAMPLE valabind-cc python r_bp \-I/usr/include/r_bp r_bp.vapi .Pp .Sh ENVIRONMENT .Bl -tag -width Fl .Ar XDG_DATA_DIRS Standard freedesktop environment variable to point to the share prefix directory where vala looks for vapi files. .El .Sh SEE ALSO .Pp .Xr valabind(1) .Pp .Sh AUTHORS .Pp pancake <@nopcode.org> valabind-1.5.0/valabind.1000066400000000000000000000027521323123274000151420ustar00rootroot00000000000000.Dd Nov 15, 2012 .Dt valabind \&1 "Valabind manual page" .Os radare .Sh NAME .Nm valabind .Nd vala to swig interface conversor .Pp .Sh SYNOPSIS .Nm valabind .Op Fl h .Op Fl x .Op Fl v .Op Fl V Ar vapidir .Op Fl o Ar ofile .Op Fl m Ar modname .Op Fl p Ar profile .Op Fl N Ar namespace .Op Fl D Ar SYMBOL .Op Fl -swig .Op Fl -node-ffi .Op Fl -ctypes .Op Fl -gir .Op Fl -cxx .Ar vapifile .Sh DESCRIPTION Valabind is a program written in Vala that aims to generate nodejs, c++ or SWIG interfaces (.i) from a vala-generated or hand-made vapi files. .Pp SWIG opens the door to create bindings for Python, Perl, ruby, lua, and many other scripting languages. .Pp .Bl -tag -width Fl .It Fl h show help message .It Fl o Ar OUTPUT specify output file name .It Fl m Ar NAME specify module name .It Fl N Ar NS include given namespace for processing .It Fl D Ar SYMBOL define a preprocessor symbol inside Vala code .It Fl p Ar PROFILE select Vala profile (posix, gobject, dova) .It Fl x generate c++ code for SWIG bindings .It Fl v show version information .It Fl V Ar PATH specify an alternative vapidir path .El .Sh ENVIRONMENT .Bl -tag -width Fl .It XDG_DATA_DIRS Standard freedesktop environment variable to point to the share prefix directory where vala looks for vapi files. .El . .Sh HYPER-REFERENCES .Bl -tag -width Fl .It Vala http://live.gnome.org/Vala .It SWIG http://www.swig.org .El . .Sh SEE ALSO .Pp .Xr valabind-cc(1) .Pp . .Sh AUTHORS .Pp pancake .Pp Eduard Burtescu valabind-1.5.0/valabindwriter.vala000066400000000000000000000102161323123274000171540ustar00rootroot00000000000000/* Copyright 2009-2015 -- pancake */ using Vala; public class ValabindWriter : CodeVisitor { public string modulename; public string library; public bool pkgmode; public bool camelgetters; public string pkgname; [CCode (array_length = false, array_null_terminated = true)] public string[] include_dirs; [CCode (array_length = false, array_null_terminated = true)] public string[] namespaces; protected CodeContext context = new CodeContext (); protected string vapidir; protected GLib.List source_files = new GLib.List (); protected GLib.List packages = new GLib.List (); protected GLib.List defines = new GLib.List (); protected bool glibmode; public ValabindWriter () { } public void init (string vapidir, bool glibmode) { CodeContext.push (context); this.vapidir = vapidir; this.glibmode = glibmode; context.vapi_directories = { vapidir }; add_package (context, "glib-2.0"); add_package (context, "gobject-2.0"); /* vala 0.17 only support gobject profile */ if (glibmode) context.add_define ("GOBJECT"); // required to avoid ugly runtime errors context.profile = Profile.GOBJECT; } public void parse () { var parser = new Parser (); parser.parse (context); if (!check ()) error ("Problems found, aborting..."); } public bool check () { context.check (); return (context.report.get_errors () == 0); } public void add_define (string define) { notice ("Symbol defined "+define); this.defines.append(define); context.add_define(define); } public bool add_external_package (string pkg) { notice ("Adding dependency "+pkg); this.packages.append(pkg); return context.add_external_package (pkg); } public bool add_source_file (string path) { if (path == "") { error ("Missing path to source vapi"); return false; } path.replace (".vapi", ""); foreach (string f in source_files) if (path == f) return false; bool found = FileUtils.test (path, FileTest.IS_REGULAR); if (found) { if (!pkgmode) context.add_source_file (new SourceFile ( context, SourceFileType.PACKAGE, path)); source_files.append(path); } else if (!add_package (context, path)) error ("Cannot find '%s'".printf (path)); return found; } /* Ripped from Vala Compiler */ private bool add_package (CodeContext context, string pkg) { if (pkg == "") { warning ("Empty add_package()?"); return true; } // ignore multiple occurences of the same package if (context.has_package (pkg)) return true; notice ("Adding dependency package "+pkg); var package_path = context.get_vapi_path (pkg); if (package_path == null) { warning ("Cannot find package path '%s'".printf (pkg)); return false; } if (pkgmode) add_source_file (package_path); context.add_source_file (new SourceFile (context, SourceFileType.PACKAGE, package_path)); context.add_package (pkg); var deps_filename = Path.build_filename (Path.get_dirname ( package_path), "%s.deps".printf (pkg)); if (FileUtils.test (deps_filename, FileTest.EXISTS)) { try { string deps_content; size_t deps_len; FileUtils.get_contents (deps_filename, out deps_content, out deps_len); foreach (string dep in deps_content.split ("\n")) { dep = dep.strip (); if (dep != "") { if (!add_package (context, dep)) Report.error (null, "%s, dependency of %s, not found in specified Vala API directories".printf (dep, pkg)); } } } catch (FileError e) { Report.error (null, "Unable to read dependency file: %s".printf (e.message)); } } return true; } protected bool use_namespace (Namespace ns) { if (namespaces == null) return true; string name = ns.get_full_name (); foreach (string i in namespaces) if(name == i) return true; return false; } public virtual void write (string file) { error ("ValabindWriter.write not implemented"); } public virtual string get_filename (string base_name) { warning ("ValabindWriter.get_filename not implemented"); return base_name; } /*public void emit_vapi (string? output, string file) { var vapi_writer = new CodeWriter (); vapi_writer.write_file (context, file); }*/ } valabind-1.5.0/windows.c000066400000000000000000000006151323123274000151320ustar00rootroot00000000000000/* Copyleft 2015 -- pancake */ #include void w32_exit(int x) { ExitProcess (x); } int w32_waitpid (int processId) { HANDLE nProc; DWORD dwExitCode; nProc = OpenProcess (PROCESS_ALL_ACCESS, TRUE, processId); if (nProc != NULL) { GetExitCodeProcess (nProc, &dwExitCode); if (dwExitCode == STILL_ACTIVE ) return dwExitCode; //RC_PROCESS_EXIST; } return -1; } valabind-1.5.0/windows.vapi000066400000000000000000000002211323123274000156400ustar00rootroot00000000000000[CCode (cheader_filename="windows.h", cname="w32")] namespace Windows { public static int waitpid(int pid); public static void exit(int rc); }