├── .gitignore ├── LICENSE ├── README.md ├── config.ld ├── docs ├── examples │ ├── add_symbol.lua.html │ ├── get_symbol.lua.html │ ├── libtcc_test.lua.html │ └── run.lua.html ├── index.html └── ldoc_pale.css ├── examples ├── add_symbol.lua ├── get_symbol.lua ├── libtcc_test.lua └── run.lua ├── rockspec ├── tcc-0.0.1-1.rockspec ├── tcc-0.0.2-1.rockspec └── tcc-scm-1.rockspec └── tcc.lua /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Lua sources 2 | luac.out 3 | 4 | # luarocks build files 5 | *.src.rock 6 | *.zip 7 | *.tar.gz 8 | 9 | # Object files 10 | *.o 11 | *.os 12 | *.ko 13 | *.obj 14 | *.elf 15 | 16 | # Precompiled Headers 17 | *.gch 18 | *.pch 19 | 20 | # Libraries 21 | *.lib 22 | *.a 23 | *.la 24 | *.lo 25 | *.def 26 | *.exp 27 | 28 | # Shared objects (inc. Windows DLLs) 29 | *.dll 30 | *.so 31 | *.so.* 32 | *.dylib 33 | 34 | # Executables 35 | *.exe 36 | *.out 37 | *.app 38 | *.i*86 39 | *.x86_64 40 | *.hex 41 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | GNU LESSER GENERAL PUBLIC LICENSE 2 | Version 2.1, February 1999 3 | 4 | Copyright (C) 1991, 1999 Free Software Foundation, Inc. 5 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 6 | Everyone is permitted to copy and distribute verbatim copies 7 | of this license document, but changing it is not allowed. 8 | 9 | [This is the first released version of the Lesser GPL. It also counts 10 | as the successor of the GNU Library Public License, version 2, hence 11 | the version number 2.1.] 12 | 13 | Preamble 14 | 15 | The licenses for most software are designed to take away your 16 | freedom to share and change it. By contrast, the GNU General Public 17 | Licenses are intended to guarantee your freedom to share and change 18 | free software--to make sure the software is free for all its users. 19 | 20 | This license, the Lesser General Public License, applies to some 21 | specially designated software packages--typically libraries--of the 22 | Free Software Foundation and other authors who decide to use it. You 23 | can use it too, but we suggest you first think carefully about whether 24 | this license or the ordinary General Public License is the better 25 | strategy to use in any particular case, based on the explanations below. 26 | 27 | When we speak of free software, we are referring to freedom of use, 28 | not price. Our General Public Licenses are designed to make sure that 29 | you have the freedom to distribute copies of free software (and charge 30 | for this service if you wish); that you receive source code or can get 31 | it if you want it; that you can change the software and use pieces of 32 | it in new free programs; and that you are informed that you can do 33 | these things. 34 | 35 | To protect your rights, we need to make restrictions that forbid 36 | distributors to deny you these rights or to ask you to surrender these 37 | rights. These restrictions translate to certain responsibilities for 38 | you if you distribute copies of the library or if you modify it. 39 | 40 | For example, if you distribute copies of the library, whether gratis 41 | or for a fee, you must give the recipients all the rights that we gave 42 | you. You must make sure that they, too, receive or can get the source 43 | code. If you link other code with the library, you must provide 44 | complete object files to the recipients, so that they can relink them 45 | with the library after making changes to the library and recompiling 46 | it. And you must show them these terms so they know their rights. 47 | 48 | We protect your rights with a two-step method: (1) we copyright the 49 | library, and (2) we offer you this license, which gives you legal 50 | permission to copy, distribute and/or modify the library. 51 | 52 | To protect each distributor, we want to make it very clear that 53 | there is no warranty for the free library. Also, if the library is 54 | modified by someone else and passed on, the recipients should know 55 | that what they have is not the original version, so that the original 56 | author's reputation will not be affected by problems that might be 57 | introduced by others. 58 | 59 | Finally, software patents pose a constant threat to the existence of 60 | any free program. We wish to make sure that a company cannot 61 | effectively restrict the users of a free program by obtaining a 62 | restrictive license from a patent holder. Therefore, we insist that 63 | any patent license obtained for a version of the library must be 64 | consistent with the full freedom of use specified in this license. 65 | 66 | Most GNU software, including some libraries, is covered by the 67 | ordinary GNU General Public License. This license, the GNU Lesser 68 | General Public License, applies to certain designated libraries, and 69 | is quite different from the ordinary General Public License. We use 70 | this license for certain libraries in order to permit linking those 71 | libraries into non-free programs. 72 | 73 | When a program is linked with a library, whether statically or using 74 | a shared library, the combination of the two is legally speaking a 75 | combined work, a derivative of the original library. The ordinary 76 | General Public License therefore permits such linking only if the 77 | entire combination fits its criteria of freedom. The Lesser General 78 | Public License permits more lax criteria for linking other code with 79 | the library. 80 | 81 | We call this license the "Lesser" General Public License because it 82 | does Less to protect the user's freedom than the ordinary General 83 | Public License. It also provides other free software developers Less 84 | of an advantage over competing non-free programs. These disadvantages 85 | are the reason we use the ordinary General Public License for many 86 | libraries. However, the Lesser license provides advantages in certain 87 | special circumstances. 88 | 89 | For example, on rare occasions, there may be a special need to 90 | encourage the widest possible use of a certain library, so that it becomes 91 | a de-facto standard. To achieve this, non-free programs must be 92 | allowed to use the library. A more frequent case is that a free 93 | library does the same job as widely used non-free libraries. In this 94 | case, there is little to gain by limiting the free library to free 95 | software only, so we use the Lesser General Public License. 96 | 97 | In other cases, permission to use a particular library in non-free 98 | programs enables a greater number of people to use a large body of 99 | free software. For example, permission to use the GNU C Library in 100 | non-free programs enables many more people to use the whole GNU 101 | operating system, as well as its variant, the GNU/Linux operating 102 | system. 103 | 104 | Although the Lesser General Public License is Less protective of the 105 | users' freedom, it does ensure that the user of a program that is 106 | linked with the Library has the freedom and the wherewithal to run 107 | that program using a modified version of the Library. 108 | 109 | The precise terms and conditions for copying, distribution and 110 | modification follow. Pay close attention to the difference between a 111 | "work based on the library" and a "work that uses the library". The 112 | former contains code derived from the library, whereas the latter must 113 | be combined with the library in order to run. 114 | 115 | GNU LESSER GENERAL PUBLIC LICENSE 116 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 117 | 118 | 0. This License Agreement applies to any software library or other 119 | program which contains a notice placed by the copyright holder or 120 | other authorized party saying it may be distributed under the terms of 121 | this Lesser General Public License (also called "this License"). 122 | Each licensee is addressed as "you". 123 | 124 | A "library" means a collection of software functions and/or data 125 | prepared so as to be conveniently linked with application programs 126 | (which use some of those functions and data) to form executables. 127 | 128 | The "Library", below, refers to any such software library or work 129 | which has been distributed under these terms. A "work based on the 130 | Library" means either the Library or any derivative work under 131 | copyright law: that is to say, a work containing the Library or a 132 | portion of it, either verbatim or with modifications and/or translated 133 | straightforwardly into another language. (Hereinafter, translation is 134 | included without limitation in the term "modification".) 135 | 136 | "Source code" for a work means the preferred form of the work for 137 | making modifications to it. For a library, complete source code means 138 | all the source code for all modules it contains, plus any associated 139 | interface definition files, plus the scripts used to control compilation 140 | and installation of the library. 141 | 142 | Activities other than copying, distribution and modification are not 143 | covered by this License; they are outside its scope. The act of 144 | running a program using the Library is not restricted, and output from 145 | such a program is covered only if its contents constitute a work based 146 | on the Library (independent of the use of the Library in a tool for 147 | writing it). Whether that is true depends on what the Library does 148 | and what the program that uses the Library does. 149 | 150 | 1. You may copy and distribute verbatim copies of the Library's 151 | complete source code as you receive it, in any medium, provided that 152 | you conspicuously and appropriately publish on each copy an 153 | appropriate copyright notice and disclaimer of warranty; keep intact 154 | all the notices that refer to this License and to the absence of any 155 | warranty; and distribute a copy of this License along with the 156 | Library. 157 | 158 | You may charge a fee for the physical act of transferring a copy, 159 | and you may at your option offer warranty protection in exchange for a 160 | fee. 161 | 162 | 2. You may modify your copy or copies of the Library or any portion 163 | of it, thus forming a work based on the Library, and copy and 164 | distribute such modifications or work under the terms of Section 1 165 | above, provided that you also meet all of these conditions: 166 | 167 | a) The modified work must itself be a software library. 168 | 169 | b) You must cause the files modified to carry prominent notices 170 | stating that you changed the files and the date of any change. 171 | 172 | c) You must cause the whole of the work to be licensed at no 173 | charge to all third parties under the terms of this License. 174 | 175 | d) If a facility in the modified Library refers to a function or a 176 | table of data to be supplied by an application program that uses 177 | the facility, other than as an argument passed when the facility 178 | is invoked, then you must make a good faith effort to ensure that, 179 | in the event an application does not supply such function or 180 | table, the facility still operates, and performs whatever part of 181 | its purpose remains meaningful. 182 | 183 | (For example, a function in a library to compute square roots has 184 | a purpose that is entirely well-defined independent of the 185 | application. Therefore, Subsection 2d requires that any 186 | application-supplied function or table used by this function must 187 | be optional: if the application does not supply it, the square 188 | root function must still compute square roots.) 189 | 190 | These requirements apply to the modified work as a whole. If 191 | identifiable sections of that work are not derived from the Library, 192 | and can be reasonably considered independent and separate works in 193 | themselves, then this License, and its terms, do not apply to those 194 | sections when you distribute them as separate works. But when you 195 | distribute the same sections as part of a whole which is a work based 196 | on the Library, the distribution of the whole must be on the terms of 197 | this License, whose permissions for other licensees extend to the 198 | entire whole, and thus to each and every part regardless of who wrote 199 | it. 200 | 201 | Thus, it is not the intent of this section to claim rights or contest 202 | your rights to work written entirely by you; rather, the intent is to 203 | exercise the right to control the distribution of derivative or 204 | collective works based on the Library. 205 | 206 | In addition, mere aggregation of another work not based on the Library 207 | with the Library (or with a work based on the Library) on a volume of 208 | a storage or distribution medium does not bring the other work under 209 | the scope of this License. 210 | 211 | 3. You may opt to apply the terms of the ordinary GNU General Public 212 | License instead of this License to a given copy of the Library. To do 213 | this, you must alter all the notices that refer to this License, so 214 | that they refer to the ordinary GNU General Public License, version 2, 215 | instead of to this License. (If a newer version than version 2 of the 216 | ordinary GNU General Public License has appeared, then you can specify 217 | that version instead if you wish.) Do not make any other change in 218 | these notices. 219 | 220 | Once this change is made in a given copy, it is irreversible for 221 | that copy, so the ordinary GNU General Public License applies to all 222 | subsequent copies and derivative works made from that copy. 223 | 224 | This option is useful when you wish to copy part of the code of 225 | the Library into a program that is not a library. 226 | 227 | 4. You may copy and distribute the Library (or a portion or 228 | derivative of it, under Section 2) in object code or executable form 229 | under the terms of Sections 1 and 2 above provided that you accompany 230 | it with the complete corresponding machine-readable source code, which 231 | must be distributed under the terms of Sections 1 and 2 above on a 232 | medium customarily used for software interchange. 233 | 234 | If distribution of object code is made by offering access to copy 235 | from a designated place, then offering equivalent access to copy the 236 | source code from the same place satisfies the requirement to 237 | distribute the source code, even though third parties are not 238 | compelled to copy the source along with the object code. 239 | 240 | 5. A program that contains no derivative of any portion of the 241 | Library, but is designed to work with the Library by being compiled or 242 | linked with it, is called a "work that uses the Library". Such a 243 | work, in isolation, is not a derivative work of the Library, and 244 | therefore falls outside the scope of this License. 245 | 246 | However, linking a "work that uses the Library" with the Library 247 | creates an executable that is a derivative of the Library (because it 248 | contains portions of the Library), rather than a "work that uses the 249 | library". The executable is therefore covered by this License. 250 | Section 6 states terms for distribution of such executables. 251 | 252 | When a "work that uses the Library" uses material from a header file 253 | that is part of the Library, the object code for the work may be a 254 | derivative work of the Library even though the source code is not. 255 | Whether this is true is especially significant if the work can be 256 | linked without the Library, or if the work is itself a library. The 257 | threshold for this to be true is not precisely defined by law. 258 | 259 | If such an object file uses only numerical parameters, data 260 | structure layouts and accessors, and small macros and small inline 261 | functions (ten lines or less in length), then the use of the object 262 | file is unrestricted, regardless of whether it is legally a derivative 263 | work. (Executables containing this object code plus portions of the 264 | Library will still fall under Section 6.) 265 | 266 | Otherwise, if the work is a derivative of the Library, you may 267 | distribute the object code for the work under the terms of Section 6. 268 | Any executables containing that work also fall under Section 6, 269 | whether or not they are linked directly with the Library itself. 270 | 271 | 6. As an exception to the Sections above, you may also combine or 272 | link a "work that uses the Library" with the Library to produce a 273 | work containing portions of the Library, and distribute that work 274 | under terms of your choice, provided that the terms permit 275 | modification of the work for the customer's own use and reverse 276 | engineering for debugging such modifications. 277 | 278 | You must give prominent notice with each copy of the work that the 279 | Library is used in it and that the Library and its use are covered by 280 | this License. You must supply a copy of this License. If the work 281 | during execution displays copyright notices, you must include the 282 | copyright notice for the Library among them, as well as a reference 283 | directing the user to the copy of this License. Also, you must do one 284 | of these things: 285 | 286 | a) Accompany the work with the complete corresponding 287 | machine-readable source code for the Library including whatever 288 | changes were used in the work (which must be distributed under 289 | Sections 1 and 2 above); and, if the work is an executable linked 290 | with the Library, with the complete machine-readable "work that 291 | uses the Library", as object code and/or source code, so that the 292 | user can modify the Library and then relink to produce a modified 293 | executable containing the modified Library. (It is understood 294 | that the user who changes the contents of definitions files in the 295 | Library will not necessarily be able to recompile the application 296 | to use the modified definitions.) 297 | 298 | b) Use a suitable shared library mechanism for linking with the 299 | Library. A suitable mechanism is one that (1) uses at run time a 300 | copy of the library already present on the user's computer system, 301 | rather than copying library functions into the executable, and (2) 302 | will operate properly with a modified version of the library, if 303 | the user installs one, as long as the modified version is 304 | interface-compatible with the version that the work was made with. 305 | 306 | c) Accompany the work with a written offer, valid for at 307 | least three years, to give the same user the materials 308 | specified in Subsection 6a, above, for a charge no more 309 | than the cost of performing this distribution. 310 | 311 | d) If distribution of the work is made by offering access to copy 312 | from a designated place, offer equivalent access to copy the above 313 | specified materials from the same place. 314 | 315 | e) Verify that the user has already received a copy of these 316 | materials or that you have already sent this user a copy. 317 | 318 | For an executable, the required form of the "work that uses the 319 | Library" must include any data and utility programs needed for 320 | reproducing the executable from it. However, as a special exception, 321 | the materials to be distributed need not include anything that is 322 | normally distributed (in either source or binary form) with the major 323 | components (compiler, kernel, and so on) of the operating system on 324 | which the executable runs, unless that component itself accompanies 325 | the executable. 326 | 327 | It may happen that this requirement contradicts the license 328 | restrictions of other proprietary libraries that do not normally 329 | accompany the operating system. Such a contradiction means you cannot 330 | use both them and the Library together in an executable that you 331 | distribute. 332 | 333 | 7. You may place library facilities that are a work based on the 334 | Library side-by-side in a single library together with other library 335 | facilities not covered by this License, and distribute such a combined 336 | library, provided that the separate distribution of the work based on 337 | the Library and of the other library facilities is otherwise 338 | permitted, and provided that you do these two things: 339 | 340 | a) Accompany the combined library with a copy of the same work 341 | based on the Library, uncombined with any other library 342 | facilities. This must be distributed under the terms of the 343 | Sections above. 344 | 345 | b) Give prominent notice with the combined library of the fact 346 | that part of it is a work based on the Library, and explaining 347 | where to find the accompanying uncombined form of the same work. 348 | 349 | 8. You may not copy, modify, sublicense, link with, or distribute 350 | the Library except as expressly provided under this License. Any 351 | attempt otherwise to copy, modify, sublicense, link with, or 352 | distribute the Library is void, and will automatically terminate your 353 | rights under this License. However, parties who have received copies, 354 | or rights, from you under this License will not have their licenses 355 | terminated so long as such parties remain in full compliance. 356 | 357 | 9. You are not required to accept this License, since you have not 358 | signed it. However, nothing else grants you permission to modify or 359 | distribute the Library or its derivative works. These actions are 360 | prohibited by law if you do not accept this License. Therefore, by 361 | modifying or distributing the Library (or any work based on the 362 | Library), you indicate your acceptance of this License to do so, and 363 | all its terms and conditions for copying, distributing or modifying 364 | the Library or works based on it. 365 | 366 | 10. Each time you redistribute the Library (or any work based on the 367 | Library), the recipient automatically receives a license from the 368 | original licensor to copy, distribute, link with or modify the Library 369 | subject to these terms and conditions. You may not impose any further 370 | restrictions on the recipients' exercise of the rights granted herein. 371 | You are not responsible for enforcing compliance by third parties with 372 | this License. 373 | 374 | 11. If, as a consequence of a court judgment or allegation of patent 375 | infringement or for any other reason (not limited to patent issues), 376 | conditions are imposed on you (whether by court order, agreement or 377 | otherwise) that contradict the conditions of this License, they do not 378 | excuse you from the conditions of this License. If you cannot 379 | distribute so as to satisfy simultaneously your obligations under this 380 | License and any other pertinent obligations, then as a consequence you 381 | may not distribute the Library at all. For example, if a patent 382 | license would not permit royalty-free redistribution of the Library by 383 | all those who receive copies directly or indirectly through you, then 384 | the only way you could satisfy both it and this License would be to 385 | refrain entirely from distribution of the Library. 386 | 387 | If any portion of this section is held invalid or unenforceable under any 388 | particular circumstance, the balance of the section is intended to apply, 389 | and the section as a whole is intended to apply in other circumstances. 390 | 391 | It is not the purpose of this section to induce you to infringe any 392 | patents or other property right claims or to contest validity of any 393 | such claims; this section has the sole purpose of protecting the 394 | integrity of the free software distribution system which is 395 | implemented by public license practices. Many people have made 396 | generous contributions to the wide range of software distributed 397 | through that system in reliance on consistent application of that 398 | system; it is up to the author/donor to decide if he or she is willing 399 | to distribute software through any other system and a licensee cannot 400 | impose that choice. 401 | 402 | This section is intended to make thoroughly clear what is believed to 403 | be a consequence of the rest of this License. 404 | 405 | 12. If the distribution and/or use of the Library is restricted in 406 | certain countries either by patents or by copyrighted interfaces, the 407 | original copyright holder who places the Library under this License may add 408 | an explicit geographical distribution limitation excluding those countries, 409 | so that distribution is permitted only in or among countries not thus 410 | excluded. In such case, this License incorporates the limitation as if 411 | written in the body of this License. 412 | 413 | 13. The Free Software Foundation may publish revised and/or new 414 | versions of the Lesser General Public License from time to time. 415 | Such new versions will be similar in spirit to the present version, 416 | but may differ in detail to address new problems or concerns. 417 | 418 | Each version is given a distinguishing version number. If the Library 419 | specifies a version number of this License which applies to it and 420 | "any later version", you have the option of following the terms and 421 | conditions either of that version or of any later version published by 422 | the Free Software Foundation. If the Library does not specify a 423 | license version number, you may choose any version ever published by 424 | the Free Software Foundation. 425 | 426 | 14. If you wish to incorporate parts of the Library into other free 427 | programs whose distribution conditions are incompatible with these, 428 | write to the author to ask for permission. For software which is 429 | copyrighted by the Free Software Foundation, write to the Free 430 | Software Foundation; we sometimes make exceptions for this. Our 431 | decision will be guided by the two goals of preserving the free status 432 | of all derivatives of our free software and of promoting the sharing 433 | and reuse of software generally. 434 | 435 | NO WARRANTY 436 | 437 | 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO 438 | WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. 439 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR 440 | OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY 441 | KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE 442 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 443 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE 444 | LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME 445 | THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 446 | 447 | 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN 448 | WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY 449 | AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU 450 | FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR 451 | CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE 452 | LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING 453 | RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A 454 | FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF 455 | SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 456 | DAMAGES. 457 | 458 | END OF TERMS AND CONDITIONS 459 | 460 | How to Apply These Terms to Your New Libraries 461 | 462 | If you develop a new library, and you want it to be of the greatest 463 | possible use to the public, we recommend making it free software that 464 | everyone can redistribute and change. You can do so by permitting 465 | redistribution under these terms (or, alternatively, under the terms of the 466 | ordinary General Public License). 467 | 468 | To apply these terms, attach the following notices to the library. It is 469 | safest to attach them to the start of each source file to most effectively 470 | convey the exclusion of warranty; and each file should have at least the 471 | "copyright" line and a pointer to where the full notice is found. 472 | 473 | 474 | Copyright (C) 475 | 476 | This library is free software; you can redistribute it and/or 477 | modify it under the terms of the GNU Lesser General Public 478 | License as published by the Free Software Foundation; either 479 | version 2 of the License, or (at your option) any later version. 480 | 481 | This library is distributed in the hope that it will be useful, 482 | but WITHOUT ANY WARRANTY; without even the implied warranty of 483 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 484 | Lesser General Public License for more details. 485 | 486 | You should have received a copy of the GNU Lesser General Public 487 | License along with this library; if not, write to the Free Software 488 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 489 | 490 | Also add information on how to contact you by electronic and paper mail. 491 | 492 | You should also get your employer (if you work as a programmer) or your 493 | school, if any, to sign a "copyright disclaimer" for the library, if 494 | necessary. Here is a sample; alter the names: 495 | 496 | Yoyodyne, Inc., hereby disclaims all copyright interest in the 497 | library `Frob' (a library for tweaking knobs) written by James Random Hacker. 498 | 499 | , 1 April 1990 500 | Ty Coon, President of Vice 501 | 502 | That's all there is to it! 503 | 504 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | [tcc.lua](https://nucular.github.io/tcclua) 2 | =========================================== 3 | 4 | ``` 5 | luarocks install tcc 6 | ``` 7 | 8 | Provides semi-high-level bindings for `libtcc`, the library interface of the 9 | [Tiny C Compiler](http://bellard.org/tcc/). 10 | 11 | 12 | ```lua 13 | local tcc = require("tcc").load() 14 | 15 | local state = tcc.new() 16 | assert(state:set_output_type(tcc.OUTPUT.MEMORY)) 17 | 18 | assert(state:compile_string([[ 19 | #include 20 | int main(int argc, char** argv) 21 | { 22 | if (argc == 0) { return 1; } 23 | printf("Hello, %s!\n", argv[0]); 24 | return 0; 25 | } 26 | ]])) 27 | 28 | assert(state:run(tcc.args("World")) == 0) 29 | ``` 30 | -------------------------------------------------------------------------------- /config.ld: -------------------------------------------------------------------------------- 1 | project = "tcc.lua" 2 | format = "markdown" 3 | not_luadoc = true 4 | style = "!pale" 5 | dir = "./docs" 6 | file = "./tcc.lua" 7 | examples = { 8 | "examples/run.lua", 9 | "examples/get_symbol.lua", 10 | "examples/add_symbol.lua", 11 | "examples/libtcc_test.lua" 12 | } 13 | 14 | backtick_references = false 15 | 16 | custom_see_handler("%./(.+)", function(link) 17 | return link, ("./%s"):format(link) 18 | end) 19 | -------------------------------------------------------------------------------- /docs/examples/add_symbol.lua.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | Reference 7 | 8 | 9 | 10 | 11 |
12 | 13 |
14 | 15 |
16 |
17 |
18 | 19 | 20 |
21 | 22 | 23 | 24 | 25 | 45 | 46 |
47 | 48 |

add_symbol.lua

49 | 
50 | --- Demonstrates adding a Lua callback as a symbol to a compilation context.
51 | --- `luajit examples/add_symbol.lua`
52 | 
53 | local ffi = require("ffi")
54 | local tcc = require("tcc").load()
55 | 
56 | local output = ""
57 | function test(msg)
58 |   output = ffi.string(msg)
59 | end
60 | 
61 | local state = tcc.new()
62 | assert(state:set_output_type(tcc.OUTPUT.MEMORY))
63 | 
64 | assert(state:compile_string([[
65 |   #include <stdlib.h>
66 |   #include <string.h>
67 | 
68 |   extern void test(char* msg);
69 | 
70 |   int main(int argc, char** argv)
71 |   {
72 |     if (argc == 0) { return 1; }
73 |     char* msg = (char*)malloc(strlen(argv[0]) + 8);
74 |     sprintf(msg, "Hello, %s!\n", argv[0]);
75 |     test(msg);
76 |     free(msg);
77 |     return 0;
78 |   }
79 | ]]))
80 | 
81 | local test_sym = ffi.cast("void (*)(char* msg)", test)
82 | assert(state:add_symbol("test", test_sym))
83 | assert(state:run(tcc.args("World")) == 0)
84 | assert(output == "Hello, World!\n")
85 | 86 | 87 |
88 |
89 |
90 | generated by LDoc 1.4.3 91 | Last updated 2016-12-31 16:17:51 92 |
93 |
94 | 95 | 96 | -------------------------------------------------------------------------------- /docs/examples/get_symbol.lua.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | Reference 7 | 8 | 9 | 10 | 11 |
12 | 13 |
14 | 15 |
16 |
17 |
18 | 19 | 20 |
21 | 22 | 23 | 24 | 25 | 45 | 46 |
47 | 48 |

get_symbol.lua

49 | 
50 | --- Demonstrates getting and calling a symbol from a compilation context.
51 | --- `luajit examples/call_symbol.lua`
52 | 
53 | local ffi = require("ffi")
54 | local tcc = require("tcc").load()
55 | 
56 | local state = tcc.new()
57 | assert(state:set_output_type(tcc.OUTPUT.MEMORY))
58 | 
59 | assert(state:compile_string([[
60 |   double test(double a, double b)
61 |   {
62 |     return a + b;
63 |   }
64 | ]]))
65 | 
66 | assert(state:relocate(tcc.RELOCATE.AUTO))
67 | local test_sym = assert(state:get_symbol("test"))
68 | local test = ffi.cast("double (*)(double, double)", test_sym)
69 | assert(test(1, 2) == 3)
70 | 71 | 72 |
73 |
74 |
75 | generated by LDoc 1.4.3 76 | Last updated 2016-12-31 16:17:51 77 |
78 |
79 | 80 | 81 | -------------------------------------------------------------------------------- /docs/examples/libtcc_test.lua.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | Reference 7 | 8 | 9 | 10 | 11 |
12 | 13 |
14 | 15 |
16 |
17 |
18 | 19 | 20 |
21 | 22 | 23 | 24 | 25 | 45 | 46 |
47 | 48 |

libtcc_test.lua

49 | 
 50 | --- Ported from libtcc_test.c.
 51 | --- `luajit examples/libtcc_test.lua`
 52 | 
 53 | local ffi = require("ffi")
 54 | local tcc = require("tcc").load()
 55 | 
 56 | --- this function is called by the generated code
 57 | local function add(a, b)
 58 |   return a + b
 59 | end
 60 | 
 61 | local my_program = [[
 62 | int fib(int n)
 63 | {
 64 |   if (n <= 2)
 65 |     return 1;
 66 |   else
 67 |     return fib(n-1) + fib(n-2);
 68 | }
 69 | 
 70 | int foo(int n)
 71 | {
 72 |   printf("Hello World!\n");
 73 |   printf("fib(%d) = %d\n", n, fib(n));
 74 |   printf("add(%d, %d) = %d\n", n, 2 * n, add(n, 2 * n));
 75 |   return 0;
 76 | }
 77 | ]]
 78 | 
 79 | local function main()
 80 |   local s = tcc.new()
 81 |   if not s then
 82 |     io.stderr:write("Could not create tcc state\n")
 83 |     return 1
 84 |   end
 85 | 
 86 |   -- MUST BE CALLED before any compilation
 87 |   s:set_output_type(tcc.OUTPUT.MEMORY)
 88 | 
 89 |   if not s:compile_string(my_program) then
 90 |     return 1
 91 |   end
 92 | 
 93 |   -- as a test, we add a symbol that the compiled program can use.
 94 |   s:add_symbol("add", ffi.cast("double (*)(double, double)", add))
 95 | 
 96 |   -- relocate the code
 97 |   if not s:relocate(tcc.RELOCATE.AUTO) then
 98 |     return 1
 99 |   end
100 | 
101 |   -- get entry symbol
102 |   local func = s:get_symbol("foo")
103 |   if not func then
104 |     return 1
105 |   end
106 | 
107 |   -- run the code
108 |   ffi.cast("int (*)(int)", func)(32)
109 | 
110 |   return 0
111 | end
112 | 
113 | os.exit(main())
114 | 115 | 116 |
117 |
118 |
119 | generated by LDoc 1.4.3 120 | Last updated 2016-12-31 16:17:51 121 |
122 |
123 | 124 | 125 | -------------------------------------------------------------------------------- /docs/examples/run.lua.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | Reference 7 | 8 | 9 | 10 | 11 |
12 | 13 |
14 | 15 |
16 |
17 |
18 | 19 | 20 |
21 | 22 | 23 | 24 | 25 | 45 | 46 |
47 | 48 |

run.lua

49 | 
50 | --- Demonstrates running the main function of a compilation context.
51 | --- `luajit examples/run_main.lua`
52 | 
53 | local tcc = require("tcc").load()
54 | 
55 | local state = tcc.new()
56 | assert(state:set_output_type(tcc.OUTPUT.MEMORY))
57 | 
58 | assert(state:compile_string([[
59 |   #include <stdio.h>
60 |   int main(int argc, char** argv)
61 |   {
62 |     if (argc == 0) { return 1; }
63 |     printf("Hello, %s!\n", argv[0]);
64 |     return 0;
65 |   }
66 | ]]))
67 | 
68 | assert(state:run(tcc.args("World")) == 0)
69 | 70 | 71 |
72 |
73 |
74 | generated by LDoc 1.4.3 75 | Last updated 2016-12-31 16:17:51 76 |
77 |
78 | 79 | 80 | -------------------------------------------------------------------------------- /docs/index.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | Reference 7 | 8 | 9 | 10 | 11 |
12 | 13 |
14 | 15 |
16 |
17 |
18 | 19 | 20 |
21 | 22 | 23 | 24 | 25 | 55 | 56 |
57 | 58 |

Module tcc

59 |

Provides semi-high-level bindings for libtcc, the library interface of the 60 | Tiny C Compiler.

61 |

Source on GitHub

62 |

Info:

63 |
    64 |
  • License: LGPL
    • 65 |
66 | 67 | 68 |

Functions

69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 82 | 83 |
load ([lib="[lib]tcc"[, home_path=$CONFIG_TCCDIR]])Load the libtcc dynamic library.
new ([add_paths=true])Create a new TCC compilation context (State).
args (...)Convert all passed strings to argc and argv arguments that can be passed 81 | to State:run.
84 |

Tables

85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 |
OUTPUTOutput types used by State:set_output_type
RELOCATERelocation constants used by State:relocate
95 |

Fields

96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 |
TCC_VERSIONCompatible version of TCC (currently 0.9.26)
home_pathPath to the TCC home, containing the lib and include directories.
clibC library namespace of the dynamically loaded libtcc.
110 |

Class State

111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 |
State:delete ()Free the compilation context and associated resources.
State:set_home_path (path)Set the home path of TCC used by this context.
State:set_error_func (error_func)Set the error/warning display callback.
State:set_options (args)Set one or multiple command line arguments for the compiler.
129 |

Preprocessor

130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 |
State:add_include_path (path)Add an include path.
State:add_sysinclude_path (path)Add a system include path.
State:define_symbol (name[, value])Define a preprocessor symbol with an optional value.
State:undefine_symbol (name)Undefine a preprocessor symbol.
148 |

Compiling

149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 |
State:add_file (file_path)Add a file.
State:compile_string (source)Compile a string containing a C source.
159 |

Linking commands

160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 |
State:set_output_type (output_type)Set the output type.
State:add_library_path (path)Add a library path.
State:add_library (name)Add a library to be linked against.
State:add_symbol (name, value)Add a pointer symbol to the compiled program.
State:output_file (file_path)Output a compiled executable, library or object file to a path.
State:run ([argc[, argv]])Link and run the main() function and return its return code.
State:relocate (ptr)Do all relocations needed for using State:get_symbol.
State:get_symbol (name)Return the pointer to a symbol or NULL if it was not found.
194 | 195 |
196 |
197 | 198 | 199 |

Functions

200 | 201 |
202 |
203 | 204 | load ([lib="[lib]tcc"[, home_path=$CONFIG_TCCDIR]]) 205 |
206 |
207 | Load the libtcc dynamic library.

208 | 209 |

If the environment variable CONFIG_TCCDIR is set, home_path will be set 210 | to its value. It can be overriden by passing the home_path parameter.

211 | 212 |

If home_path is set, it will be searched for the library before the 213 | default paths. 214 | 215 | 216 |

Parameters:

217 |
    218 |
  • lib 219 | string 220 | name of the libtcc library, defaults to 221 | libtcc on Windows and tcc on other platforms due to naming issues 222 | (default "[lib]tcc") 223 |
    • 224 |
  • home_path 225 | string 226 | path to the TCC home 227 | (default $CONFIG_TCCDIR) 228 |
    • 229 |
230 | 231 |

Returns:

232 |
    233 | 234 | table 235 | the tcc module itself (to allow for chaining) 236 |
237 | 238 | 239 | 240 |

Usage:

241 |
    242 | 
    local tcc = require("tcc").load("tcc", "/lib/tcc")
    243 |
244 | 245 |
246 |
247 | 248 | new ([add_paths=true]) 249 |
250 |
251 | Create a new TCC compilation context (State).

252 | 253 |

If add_paths is not false and home_path is set, call 254 | State:set_home_path on it, State:add_sysinclude_path on 255 | home_path/include and State:add_library_path on home_path/lib. 256 | 257 | 258 |

Parameters:

259 |
    260 |
  • add_paths 261 | bool 262 | whether to set the home path on the new 263 | State 264 | (default true) 265 |
    • 266 |
267 | 268 |

Returns:

269 |
    270 | 271 | State 272 | the new compilation context 273 |
274 | 275 | 276 | 277 | 278 |
279 |
280 | 281 | args (...) 282 |
283 |
284 | Convert all passed strings to argc and argv arguments that can be passed 285 | to State:run. 286 | 287 | 288 |

Parameters:

289 |
    290 |
  • ... 291 | string 292 | any number of string arguments 293 |
    • 294 |
295 | 296 |

Returns:

297 |
    298 |
  1. 299 | cdata(int) 300 | number of passed arguments
    2. 301 |
  2. 302 | cdata(char**) 303 | passed arguments as an array of C strings
    3. 304 |
305 | 306 | 307 | 308 |

Usage:

309 |
    310 | 
    state:run(tcc.args("foo", "bar"))
    311 |
312 | 313 |
314 |
315 |

Tables

316 | 317 |
318 |
319 | 320 | OUTPUT 321 |
322 |
323 | Output types used by State:set_output_type 324 | 325 | 326 |

Fields:

327 |
    328 |
  • MEMORY 329 | output will be run in memory (default) 330 |
    • 331 |
  • EXE 332 | executable file 333 |
    • 334 |
  • DLL 335 | dynamic library 336 |
    • 337 |
  • OBJ 338 | object file 339 |
    • 340 |
  • PREPROCESS 341 | only preprocess (used internally) 342 |
    • 343 |
344 | 345 | 346 | 347 | 348 | 349 |
350 |
351 | 352 | RELOCATE 353 |
354 |
355 | Relocation constants used by State:relocate 356 | 357 | 358 |

Fields:

359 |
    360 |
  • SIZE 361 | return required memory size for relocation 362 |
    • 363 |
  • AUTO 364 | allocate and manage memory internally 365 |
    • 366 |
367 | 368 | 369 | 370 | 371 | 372 |
373 |
374 |

Fields

375 | 376 |
377 |
378 | 379 | TCC_VERSION 380 |
381 |
382 | Compatible version of TCC (currently 0.9.26) 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 |
391 |
392 | 393 | home_path 394 |
395 |
396 | Path to the TCC home, containing the lib and include directories. 397 | Usually set automatically by tcc.load. 398 | 399 | 400 | 401 | 402 | 403 | 404 | 405 |
406 |
407 | 408 | clib 409 |
410 |
411 | C library namespace of the dynamically loaded libtcc. Set by tcc.load. 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 |
420 |
421 |

Class State

422 | 423 |
424 | A TCC compilation context. 425 |
426 |
427 |
428 | 429 | State:delete () 430 |
431 |
432 | Free the compilation context and associated resources. Usually called 433 | automatically when the State is garbage-collected. 434 | 435 | 436 | 437 | 438 | 439 | 440 | 441 |
442 |
443 | 444 | State:set_home_path (path) 445 |
446 |
447 | Set the home path of TCC used by this context. Usually called automatically 448 | by new.

449 | 450 |

Originally named set_lib_path but renamed for consistency and clarity. 451 | 452 | 453 |

Parameters:

454 |
    455 |
  • path 456 | string 457 | 458 | 459 | 460 |
    • 461 |
462 | 463 | 464 | 465 | 466 | 467 |
468 |
469 | 470 | State:set_error_func (error_func) 471 |
472 |
473 | Set the error/warning display callback.

474 | 475 |

The passed output strings will be formatted like 476 | <file or "tcc">:[<line>:] <severity> <message>. 477 | 478 | 479 |

Parameters:

480 |
    481 |
  • error_func 482 | function(string) 483 | function to be called 484 |
    • 485 |
486 | 487 | 488 | 489 | 490 | 491 |
492 |
493 | 494 | State:set_options (args) 495 |
496 |
497 | Set one or multiple command line arguments for the compiler. 498 | 499 | 500 |

Parameters:

501 |
    502 |
  • args 503 | string 504 | the arguments 505 |
    • 506 |
507 | 508 |

Returns:

509 |
    510 | 511 | bool 512 | success 513 |
514 | 515 | 516 | 517 | 518 |
519 |
520 |

Preprocessor

521 | 522 |
523 |
524 | 525 | State:add_include_path (path) 526 |
527 |
528 | Add an include path. 529 | 530 | 531 |

Parameters:

532 |
    533 |
  • path 534 | string 535 | include path to be added 536 |
    • 537 |
538 | 539 |

Returns:

540 |
    541 | 542 | bool 543 | success 544 |
545 | 546 | 547 | 548 | 549 |
550 |
551 | 552 | State:add_sysinclude_path (path) 553 |
554 |
555 | Add a system include path. Usually called automatically by new. 556 | 557 | 558 |

Parameters:

559 |
    560 |
  • path 561 | string 562 | system include path to be added 563 |
    • 564 |
565 | 566 |

Returns:

567 |
    568 | 569 | bool 570 | success 571 |
572 | 573 | 574 | 575 | 576 |
577 |
578 | 579 | State:define_symbol (name[, value]) 580 |
581 |
582 | Define a preprocessor symbol with an optional value. 583 | 584 | 585 |

Parameters:

586 |
    587 |
  • name 588 | string 589 | name of the symbol 590 |
    • 591 |
  • value 592 | string 593 | optional value of the symbol 594 | (optional) 595 |
    • 596 |
597 | 598 | 599 | 600 | 601 | 602 |
603 |
604 | 605 | State:undefine_symbol (name) 606 |
607 |
608 | Undefine a preprocessor symbol. 609 | 610 | 611 |

Parameters:

612 |
    613 |
  • name 614 | string 615 | name of the symbol 616 |
    • 617 |
618 | 619 | 620 | 621 | 622 | 623 |
624 |
625 |

Compiling

626 | 627 |
628 |
629 | 630 | State:add_file (file_path) 631 |
632 |
633 | 634 |

Add a file. 635 | This includes:

636 | 637 |
    638 |
  • C files to be compiled
    • 639 |
  • DLLs, object files and libraries to be linked against
    • 640 |
  • ld scripts
    • 641 |
642 | 643 | 644 | 645 |

Parameters:

646 |
    647 |
  • file_path 648 | string 649 | path to the file to be added 650 |
    • 651 |
652 | 653 |

Returns:

654 |
    655 | 656 | bool 657 | success 658 |
659 | 660 | 661 | 662 | 663 |
664 |
665 | 666 | State:compile_string (source) 667 |
668 |
669 | Compile a string containing a C source. 670 | 671 | 672 |

Parameters:

673 |
    674 |
  • source 675 | string 676 | source code to be compiled 677 |
    • 678 |
679 | 680 |

Returns:

681 |
    682 | 683 | bool 684 | success 685 |
686 | 687 | 688 | 689 | 690 |
691 |
692 |

Linking commands

693 | 694 |
695 |
696 | 697 | State:set_output_type (output_type) 698 |
699 |
700 | Set the output type.

701 | 702 |

Must be called before any compilation. 703 | 704 | 705 |

Parameters:

706 |
    707 |
  • output_type 708 | OUTPUT 709 | 710 | 711 | 712 |
    • 713 |
714 | 715 |

Returns:

716 |
    717 | 718 | bool 719 | success 720 |
721 | 722 | 723 | 724 | 725 |
726 |
727 | 728 | State:add_library_path (path) 729 |
730 |
731 | Add a library path. Equivalent to the -Lpath option. 732 | 733 | 734 |

Parameters:

735 |
    736 |
  • path 737 | string 738 | library path to be added 739 |
    • 740 |
741 | 742 |

Returns:

743 |
    744 | 745 | bool 746 | success 747 |
748 | 749 | 750 | 751 | 752 |
753 |
754 | 755 | State:add_library (name) 756 |
757 |
758 | Add a library to be linked against. Equivalent to the -lname option. 759 | 760 | 761 |

Parameters:

762 |
    763 |
  • name 764 | string 765 | name of the library to be linked against 766 |
    • 767 |
768 | 769 |

Returns:

770 |
    771 | 772 | bool 773 | success 774 |
775 | 776 | 777 | 778 | 779 |
780 |
781 | 782 | State:add_symbol (name, value) 783 |
784 |
785 | Add a pointer symbol to the compiled program. 786 | 787 | 788 |

Parameters:

789 |
    790 |
  • name 791 | string 792 | name of the symbol 793 |
    • 794 |
  • value 795 | cdata(void*) 796 | pointer of the symbol 797 |
    • 798 |
799 | 800 |

Returns:

801 |
    802 | 803 | bool 804 | success 805 |
806 | 807 | 808 |

See also:

809 | 812 | 813 | 814 |
815 |
816 | 817 | State:output_file (file_path) 818 |
819 |
820 | Output a compiled executable, library or object file to a path. Do not 821 | call State:relocate before. 822 | 823 | 824 |

Parameters:

825 |
    826 |
  • file_path 827 | string 828 | output file path 829 |
    • 830 |
831 | 832 |

Returns:

833 |
    834 | 835 | bool 836 | success 837 |
838 | 839 | 840 | 841 | 842 |
843 |
844 | 845 | State:run ([argc[, argv]]) 846 |
847 |
848 | Link and run the main() function and return its return code. Do not 849 | call State:relocate before. 850 | 851 | 852 |

Parameters:

853 |
    854 |
  • argc 855 | cdata(int) 856 | number of passed arguments 857 | (optional) 858 |
    • 859 |
  • argv 860 | cdata(char**) 861 | arguments as an array of C-strings 862 | (optional) 863 |
    • 864 |
865 | 866 |

Returns:

867 |
    868 | 869 | cdata(int) 870 | return code 871 |
872 | 873 | 874 |

See also:

875 | 878 | 879 |

Usage:

880 |
    881 | 
    882 | local argv = ffi.new("char*[2]")
883 | argv[0] = "foo"
884 | argv[1] = "bar"
885 | state:run(2, argv)
    886 |
887 | 888 |
889 |
890 | 891 | State:relocate (ptr) 892 |
893 |
894 | Do all relocations needed for using State:get_symbol. 895 | This can be done either within internally managed memory (by passing 896 | RELOCATE.AUTO) or within an user-managed memory chunk that is at 897 | least of the size that is returned by passing RELOCATE.SIZE. 898 | 899 | 900 |

Parameters:

901 |
    902 |
  • ptr 903 | cdata(void*) 904 | pointer to a memory chunk or one of the members of 905 | RELOCATE 906 |
    • 907 |
908 | 909 |

Returns:

910 |
    911 | 912 | bool 913 | success 914 |
915 |

Or

916 |
    917 | 918 | number 919 | required memory size if RELOCATE.SIZE was 920 | passed 921 |
922 | 923 | 924 | 925 |

Usage:

926 |
    927 | 
    928 | local size = state:relocate(tcc.RELOCATE.SIZE)
929 | local mem = ffi.new("char[?]", size)
930 | state:relocate(mem)
    931 |
932 | 933 |
934 |
935 | 936 | State:get_symbol (name) 937 |
938 |
939 | Return the pointer to a symbol or NULL if it was not found. 940 | 941 | 942 |

Parameters:

943 |
    944 |
  • name 945 | string 946 | name of the symbol 947 |
    • 948 |
949 | 950 |

Returns:

951 |
    952 | 953 | cdata(void*) 954 | pointer to the symbol 955 |
956 | 957 | 958 |

See also:

959 | 962 | 963 | 964 |
965 |
966 | 967 | 968 |
969 |
970 |
971 | generated by LDoc 1.4.3 972 | Last updated 2016-12-31 16:17:51 973 |
974 |
975 | 976 | 977 | -------------------------------------------------------------------------------- /docs/ldoc_pale.css: -------------------------------------------------------------------------------- 1 | /* BEGIN RESET 2 | 3 | Copyright (c) 2010, Yahoo! Inc. All rights reserved. 4 | Code licensed under the BSD License: 5 | http://developer.yahoo.com/yui/license.html 6 | version: 2.8.2r1 7 | */ 8 | html { 9 | color: #000; 10 | background: #FFF; 11 | } 12 | body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,code,form,fieldset,legend,input,button,textarea,p,blockquote,th,td { 13 | margin: 0; 14 | padding: 0; 15 | } 16 | table { 17 | border-collapse: collapse; 18 | border-spacing: 0; 19 | } 20 | fieldset,img { 21 | border: 0; 22 | } 23 | address,caption,cite,code,dfn,em,strong,th,var,optgroup { 24 | font-style: inherit; 25 | font-weight: inherit; 26 | } 27 | del,ins { 28 | text-decoration: none; 29 | } 30 | li { 31 | list-style: disc; 32 | margin-left: 20px; 33 | } 34 | caption,th { 35 | text-align: left; 36 | } 37 | h1,h2,h3,h4,h5,h6 { 38 | font-size: 100%; 39 | font-weight: bold; 40 | } 41 | q:before,q:after { 42 | content: ''; 43 | } 44 | abbr,acronym { 45 | border: 0; 46 | font-variant: normal; 47 | } 48 | sup { 49 | vertical-align: baseline; 50 | } 51 | sub { 52 | vertical-align: baseline; 53 | } 54 | legend { 55 | color: #000; 56 | } 57 | input,button,textarea,select,optgroup,option { 58 | font-family: inherit; 59 | font-size: inherit; 60 | font-style: inherit; 61 | font-weight: inherit; 62 | } 63 | input,button,textarea,select {*font-size:100%; 64 | } 65 | /* END RESET */ 66 | 67 | body { 68 | margin-left: 1em; 69 | margin-right: 1em; 70 | font-family: arial, helvetica, geneva, sans-serif; 71 | background-color: #ffffff; margin: 0px; 72 | } 73 | 74 | code, tt { font-family: monospace; font-size: 1.1em; } 75 | span.parameter { font-family:monospace; } 76 | span.parameter:after { content:":"; } 77 | span.types:before { content:"("; } 78 | span.types:after { content:")"; } 79 | .type { font-weight: bold; font-style:italic } 80 | 81 | body, p, td, th { font-size: .95em; line-height: 1.2em;} 82 | 83 | p, ul { margin: 10px 0 0 0px;} 84 | 85 | strong { font-weight: bold;} 86 | 87 | em { font-style: italic;} 88 | 89 | h1 { 90 | font-size: 1.5em; 91 | margin: 0 0 20px 0; 92 | } 93 | h2, h3, h4 { margin: 15px 0 10px 0; } 94 | h2 { font-size: 1.25em; } 95 | h3 { font-size: 1.15em; } 96 | h4 { font-size: 1.06em; } 97 | 98 | a:link { font-weight: bold; color: #004080; text-decoration: none; } 99 | a:visited { font-weight: bold; color: #006699; text-decoration: none; } 100 | a:link:hover { text-decoration: underline; } 101 | 102 | hr { 103 | color:#cccccc; 104 | background: #00007f; 105 | height: 1px; 106 | } 107 | 108 | blockquote { margin-left: 3em; } 109 | 110 | ul { list-style-type: disc; } 111 | 112 | p.name { 113 | font-family: "Andale Mono", monospace; 114 | padding-top: 1em; 115 | } 116 | 117 | pre { 118 | background-color: rgb(245, 245, 245); 119 | border: 1px solid #C0C0C0; /* silver */ 120 | padding: 10px; 121 | margin: 10px 0 10px 0; 122 | overflow: auto; 123 | font-family: "Andale Mono", monospace; 124 | } 125 | 126 | pre.example { 127 | font-size: .85em; 128 | } 129 | 130 | table.index { border: 1px #00007f; } 131 | table.index td { text-align: left; vertical-align: top; } 132 | 133 | #container { 134 | margin-left: 1em; 135 | margin-right: 1em; 136 | background-color: #ffffff; 137 | } 138 | 139 | #product { 140 | text-align: center; 141 | border-bottom: 1px solid #cccccc; 142 | background-color: #ffffff; 143 | } 144 | 145 | #product big { 146 | font-size: 2em; 147 | } 148 | 149 | #main { 150 | background-color:#FFFFFF; // #f0f0f0; 151 | //border-left: 2px solid #cccccc; 152 | } 153 | 154 | #navigation { 155 | float: left; 156 | width: 14em; 157 | vertical-align: top; 158 | background-color:#FFFFFF; // #f0f0f0; 159 | border-right: 2px solid #cccccc; 160 | overflow: visible; 161 | } 162 | 163 | #navigation h2 { 164 | background-color:#FFFFFF;//:#e7e7e7; 165 | font-size:1.1em; 166 | color:#000000; 167 | text-align: left; 168 | padding:0.2em; 169 | //border-top:1px solid #dddddd; 170 | border-bottom:1px solid #dddddd; 171 | } 172 | 173 | #navigation ul 174 | { 175 | font-size:1em; 176 | list-style-type: none; 177 | margin: 1px 1px 10px 1px; 178 | } 179 | 180 | #navigation li { 181 | text-indent: -1em; 182 | display: block; 183 | margin: 3px 0px 0px 22px; 184 | } 185 | 186 | #navigation li li a { 187 | margin: 0px 3px 0px -1em; 188 | } 189 | 190 | #content { 191 | margin-left: 14em; 192 | padding: 1em; 193 | width: 700px; 194 | border-left: 2px solid #cccccc; 195 | // border-right: 2px solid #cccccc; 196 | background-color: #ffffff; 197 | } 198 | 199 | #about { 200 | clear: both; 201 | padding: 5px; 202 | border-top: 2px solid #cccccc; 203 | background-color: #ffffff; 204 | } 205 | 206 | @media print { 207 | body { 208 | font: 12pt "Times New Roman", "TimeNR", Times, serif; 209 | } 210 | a { font-weight: bold; color: #004080; text-decoration: underline; } 211 | 212 | #main { 213 | background-color: #ffffff; 214 | border-left: 0px; 215 | } 216 | 217 | #container { 218 | margin-left: 2%; 219 | margin-right: 2%; 220 | background-color: #ffffff; 221 | } 222 | 223 | #content { 224 | padding: 1em; 225 | background-color: #ffffff; 226 | } 227 | 228 | #navigation { 229 | display: none; 230 | } 231 | pre.example { 232 | font-family: "Andale Mono", monospace; 233 | font-size: 10pt; 234 | page-break-inside: avoid; 235 | } 236 | } 237 | 238 | table.module_list { 239 | border-width: 1px; 240 | border-style: solid; 241 | border-color: #cccccc; 242 | border-collapse: collapse; 243 | } 244 | table.module_list td { 245 | border-width: 1px; 246 | padding: 3px; 247 | border-style: solid; 248 | border-color: #cccccc; 249 | } 250 | table.module_list td.name { background-color: #f0f0f0; ; min-width: 200px; } 251 | table.module_list td.summary { width: 100%; } 252 | 253 | table.function_list { 254 | border-width: 1px; 255 | border-style: solid; 256 | border-color: #cccccc; 257 | border-collapse: collapse; 258 | } 259 | table.function_list td { 260 | border-width: 1px; 261 | padding: 3px; 262 | border-style: solid; 263 | border-color: #cccccc; 264 | } 265 | table.function_list td.name { background-color: #f6f6ff; ; min-width: 200px; } 266 | table.function_list td.summary { width: 100%; } 267 | 268 | dl.table dt, dl.function dt {border-top: 1px solid #ccc; padding-top: 1em;} 269 | dl.table dd, dl.function dd {padding-bottom: 1em; margin: 10px 0 0 20px;} 270 | dl.table h3, dl.function h3 {font-size: .95em;} 271 | 272 | ul.nowrap { 273 | overflow:auto; 274 | whitespace:nowrap; 275 | } 276 | 277 | /* stop sublists from having initial vertical space */ 278 | ul ul { margin-top: 0px; } 279 | ol ul { margin-top: 0px; } 280 | ol ol { margin-top: 0px; } 281 | ul ol { margin-top: 0px; } 282 | 283 | /* make the target distinct; helps when we're navigating to a function */ 284 | a:target + * { 285 | background-color: #FF9; 286 | } 287 | 288 | 289 | /* styles for prettification of source */ 290 | pre .comment { color: #558817; } 291 | pre .constant { color: #a8660d; } 292 | pre .escape { color: #844631; } 293 | pre .keyword { color: #aa5050; font-weight: bold; } 294 | pre .library { color: #0e7c6b; } 295 | pre .marker { color: #512b1e; background: #fedc56; font-weight: bold; } 296 | pre .string { color: #8080ff; } 297 | pre .number { color: #f8660d; } 298 | pre .operator { color: #2239a8; font-weight: bold; } 299 | pre .preprocessor, pre .prepro { color: #a33243; } 300 | pre .global { color: #800080; } 301 | pre .user-keyword { color: #800080; } 302 | pre .prompt { color: #558817; } 303 | pre .url { color: #272fc2; text-decoration: underline; } 304 | 305 | -------------------------------------------------------------------------------- /examples/add_symbol.lua: -------------------------------------------------------------------------------- 1 | --- Demonstrates adding a Lua callback as a symbol to a compilation context. 2 | --- `luajit examples/add_symbol.lua` 3 | 4 | local ffi = require("ffi") 5 | local tcc = require("tcc").load() 6 | 7 | local output = "" 8 | function test(msg) 9 | output = ffi.string(msg) 10 | end 11 | 12 | local state = tcc.new() 13 | assert(state:set_output_type(tcc.OUTPUT.MEMORY)) 14 | 15 | assert(state:compile_string([[ 16 | #include 17 | #include 18 | 19 | extern void test(char* msg); 20 | 21 | int main(int argc, char** argv) 22 | { 23 | if (argc == 0) { return 1; } 24 | char* msg = (char*)malloc(strlen(argv[0]) + 8); 25 | sprintf(msg, "Hello, %s!\n", argv[0]); 26 | test(msg); 27 | free(msg); 28 | return 0; 29 | } 30 | ]])) 31 | 32 | local test_sym = ffi.cast("void (*)(char* msg)", test) 33 | assert(state:add_symbol("test", test_sym)) 34 | assert(state:run(tcc.args("World")) == 0) 35 | assert(output == "Hello, World!\n") 36 | -------------------------------------------------------------------------------- /examples/get_symbol.lua: -------------------------------------------------------------------------------- 1 | --- Demonstrates getting and calling a symbol from a compilation context. 2 | --- `luajit examples/call_symbol.lua` 3 | 4 | local ffi = require("ffi") 5 | local tcc = require("tcc").load() 6 | 7 | local state = tcc.new() 8 | assert(state:set_output_type(tcc.OUTPUT.MEMORY)) 9 | 10 | assert(state:compile_string([[ 11 | double test(double a, double b) 12 | { 13 | return a + b; 14 | } 15 | ]])) 16 | 17 | assert(state:relocate(tcc.RELOCATE.AUTO)) 18 | local test_sym = assert(state:get_symbol("test")) 19 | local test = ffi.cast("double (*)(double, double)", test_sym) 20 | assert(test(1, 2) == 3) 21 | -------------------------------------------------------------------------------- /examples/libtcc_test.lua: -------------------------------------------------------------------------------- 1 | --- Ported from libtcc_test.c. 2 | --- `luajit examples/libtcc_test.lua` 3 | 4 | local ffi = require("ffi") 5 | local tcc = require("tcc").load() 6 | 7 | --- this function is called by the generated code 8 | local function add(a, b) 9 | return a + b 10 | end 11 | 12 | local my_program = [[ 13 | int fib(int n) 14 | { 15 | if (n <= 2) 16 | return 1; 17 | else 18 | return fib(n-1) + fib(n-2); 19 | } 20 | 21 | int foo(int n) 22 | { 23 | printf("Hello World!\n"); 24 | printf("fib(%d) = %d\n", n, fib(n)); 25 | printf("add(%d, %d) = %d\n", n, 2 * n, add(n, 2 * n)); 26 | return 0; 27 | } 28 | ]] 29 | 30 | local function main() 31 | local s = tcc.new() 32 | if not s then 33 | io.stderr:write("Could not create tcc state\n") 34 | return 1 35 | end 36 | 37 | -- MUST BE CALLED before any compilation 38 | s:set_output_type(tcc.OUTPUT.MEMORY) 39 | 40 | if not s:compile_string(my_program) then 41 | return 1 42 | end 43 | 44 | -- as a test, we add a symbol that the compiled program can use. 45 | s:add_symbol("add", ffi.cast("double (*)(double, double)", add)) 46 | 47 | -- relocate the code 48 | if not s:relocate(tcc.RELOCATE.AUTO) then 49 | return 1 50 | end 51 | 52 | -- get entry symbol 53 | local func = s:get_symbol("foo") 54 | if not func then 55 | return 1 56 | end 57 | 58 | -- run the code 59 | ffi.cast("int (*)(int)", func)(32) 60 | 61 | return 0 62 | end 63 | 64 | os.exit(main()) 65 | -------------------------------------------------------------------------------- /examples/run.lua: -------------------------------------------------------------------------------- 1 | --- Demonstrates running the main function of a compilation context. 2 | --- `luajit examples/run_main.lua` 3 | 4 | local tcc = require("tcc").load() 5 | 6 | local state = tcc.new() 7 | assert(state:set_output_type(tcc.OUTPUT.MEMORY)) 8 | 9 | assert(state:compile_string([[ 10 | #include 11 | int main(int argc, char** argv) 12 | { 13 | if (argc == 0) { return 1; } 14 | printf("Hello, %s!\n", argv[0]); 15 | return 0; 16 | } 17 | ]])) 18 | 19 | assert(state:run(tcc.args("World")) == 0) 20 | -------------------------------------------------------------------------------- /rockspec/tcc-0.0.1-1.rockspec: -------------------------------------------------------------------------------- 1 | package = "tcc" 2 | version = "0.0.1-1" 3 | source = { 4 | url = "git://github.com/nucular/tcclua", 5 | tag = "v0.0.1" 6 | } 7 | description = { 8 | summary = "FFI bindings for the Tiny C Compiler", 9 | detailed = [[ 10 | Provides semi-high-level bindings for libtcc, the library interface of the 11 | Tiny C Compiler. 12 | ]], 13 | homepage = "https://nucular.github.io/tcclua", 14 | license = "LGPL" 15 | } 16 | dependencies = { 17 | "lua >= 5.1" -- "luajit >= 2.0.0" 18 | } 19 | build = { 20 | type = "builtin", 21 | modules = { 22 | tcc = "tcc.lua" 23 | }, 24 | copy_directories = { 25 | "docs" 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /rockspec/tcc-0.0.2-1.rockspec: -------------------------------------------------------------------------------- 1 | package = "tcc" 2 | version = "0.0.2-1" 3 | source = { 4 | url = "git://github.com/nucular/tcclua", 5 | tag = "v0.0.2" 6 | } 7 | description = { 8 | summary = "FFI bindings for the Tiny C Compiler", 9 | detailed = [[ 10 | Provides semi-high-level bindings for libtcc, the library interface of the 11 | Tiny C Compiler. 12 | ]], 13 | homepage = "https://nucular.github.io/tcclua", 14 | license = "LGPL" 15 | } 16 | dependencies = { 17 | "lua >= 5.1" -- "luajit >= 2.0.0" 18 | } 19 | build = { 20 | type = "builtin", 21 | modules = { 22 | tcc = "tcc.lua" 23 | }, 24 | copy_directories = { 25 | "docs" 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /rockspec/tcc-scm-1.rockspec: -------------------------------------------------------------------------------- 1 | package = "tcc" 2 | version = "scm" 3 | source = { 4 | url = "git://github.com/nucular/tcclua", 5 | branch = "master" 6 | } 7 | description = { 8 | summary = "FFI bindings for the Tiny C Compiler", 9 | detailed = [[ 10 | Provides semi-high-level bindings for libtcc, the library interface of the 11 | Tiny C Compiler. 12 | ]], 13 | homepage = "https://nucular.github.io/tcclua", 14 | license = "LGPL" 15 | } 16 | dependencies = { 17 | "lua >= 5.1" -- "luajit >= 2.0.0" 18 | } 19 | build = { 20 | type = "builtin", 21 | modules = { 22 | tcc = "tcc.lua" 23 | }, 24 | copy_directories = { 25 | "docs" 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /tcc.lua: -------------------------------------------------------------------------------- 1 | --- Provides semi-high-level bindings for `libtcc`, the library interface of the 2 | --- [Tiny C Compiler](http://bellard.org/tcc/). 3 | --- [Source on GitHub](https://github.com/nucular/tcclua) 4 | -- @license LGPL 5 | local tcc = {} 6 | local ffi = require("ffi") 7 | 8 | tcc._NAME = "tcc" 9 | tcc._VERSION = "scm" 10 | 11 | --- Compatible version of TCC (currently `0.9.26`) 12 | tcc.TCC_VERSION = "0.9.26" 13 | 14 | --- Output types used by @{State:set_output_type} 15 | tcc.OUTPUT = { 16 | MEMORY = 0, -- output will be run in memory (default) 17 | EXE = 1, -- executable file 18 | DLL = 2, -- dynamic library 19 | OBJ = 3, -- object file 20 | PREPROCESS = 4 -- only preprocess (used internally) 21 | } 22 | 23 | --- Relocation constants used by @{State:relocate} 24 | tcc.RELOCATE = { 25 | SIZE = ffi.cast("void*", 0), -- return required memory size for relocation 26 | AUTO = ffi.cast("void*", 1) -- allocate and manage memory internally 27 | } 28 | 29 | --- Path to the TCC home, containing the `lib` and `include` directories. 30 | --- Usually set automatically by @{tcc.load}. 31 | tcc.home_path = nil 32 | 33 | --- C library namespace of the dynamically loaded `libtcc`. Set by @{tcc.load}. 34 | tcc.clib = nil 35 | 36 | --- Load the `libtcc` dynamic library. 37 | --- 38 | --- If the environment variable `CONFIG_TCCDIR` is set, @{home_path} will be set 39 | --- to its value. It can be overriden by passing the `home_path` parameter. 40 | --- 41 | --- If @{home_path} is set, it will be searched for the library before the 42 | --- default paths. 43 | -- @tparam[opt="[lib]tcc"] string lib name of the libtcc library, defaults to 44 | -- `libtcc` on Windows and `tcc` on other platforms due to naming issues 45 | -- @tparam[opt=$CONFIG_TCCDIR] string home_path path to the TCC home 46 | -- @treturn table the `tcc` module itself (to allow for chaining) 47 | -- @usage 48 | --local tcc = require("tcc").load("tcc", "/lib/tcc") 49 | function tcc.load(lib, home_path) 50 | if home_path then 51 | tcc.home_path = tccdir 52 | else 53 | tcc.home_path = os.getenv("CONFIG_TCCDIR") or tcc.home_path 54 | end 55 | lib = lib or (ffi.os == "Windows" and "libtcc" or "tcc") 56 | 57 | ffi.cdef([[ 58 | struct TCCState; 59 | typedef struct TCCState TCCState; 60 | TCCState *tcc_new(void); 61 | void tcc_delete(TCCState *s); 62 | void tcc_set_lib_path(TCCState *s, const char *path); 63 | void tcc_set_error_func(TCCState *s, void *error_opaque, 64 | void (*error_func)(void *opaque, const char *msg)); 65 | int tcc_set_options(TCCState *s, const char *str); 66 | int tcc_add_include_path(TCCState *s, const char *pathname); 67 | int tcc_add_sysinclude_path(TCCState *s, const char *pathname); 68 | void tcc_define_symbol(TCCState *s, const char *sym, const char *value); 69 | void tcc_undefine_symbol(TCCState *s, const char *sym); 70 | int tcc_add_file(TCCState *s, const char *filename); 71 | int tcc_compile_string(TCCState *s, const char *buf); 72 | int tcc_set_output_type(TCCState *s, int output_type); 73 | int tcc_add_library_path(TCCState *s, const char *pathname); 74 | int tcc_add_library(TCCState *s, const char *libraryname); 75 | int tcc_add_symbol(TCCState *s, const char *name, const void *val); 76 | int tcc_output_file(TCCState *s, const char *filename); 77 | int tcc_run(TCCState *s, int argc, char **argv); 78 | int tcc_relocate(TCCState *s1, void *ptr); 79 | void *tcc_get_symbol(TCCState *s, const char *name); 80 | ]]) 81 | ffi.metatype("TCCState", tcc.State) 82 | 83 | local clib 84 | if tcc.home_path then 85 | clib = pcall(ffi.load(("%s/%s"):format(tcc.home_path, lib))) 86 | end 87 | if not clib then 88 | clib = ffi.load(lib) 89 | end 90 | tcc.clib = clib 91 | return tcc 92 | end 93 | 94 | --- Create a new TCC compilation context (@{State}). 95 | --- 96 | --- If `add_paths` is not `false` and @{home_path} is set, call 97 | --- @{State:set_home_path} on it, @{State:add_sysinclude_path} on 98 | --- `home_path/include` and @{State:add_library_path} on `home_path/lib`. 99 | -- @tparam[opt=true] bool add_paths whether to set the home path on the new 100 | -- @{State} 101 | -- @treturn State the new compilation context 102 | function tcc.new(add_paths) 103 | local state = tcc.clib.tcc_new() 104 | ffi.gc(state, tcc.State.__gc) 105 | if addpaths ~= false and tcc.tccdir then 106 | state:set_home_path(tcc.tccdir) 107 | state:add_sysinclude_path(tcc.tccdir .. "/include") 108 | state:add_library_path(tcc.tccdir .. "/lib") 109 | end 110 | return state 111 | end 112 | 113 | --- Convert all passed strings to `argc` and `argv` arguments that can be passed 114 | --- to @{State:run}. 115 | -- @tparam string ... any number of string arguments 116 | -- @treturn cdata(int) number of passed arguments 117 | -- @treturn cdata(char**) passed arguments as an array of C strings 118 | -- @usage 119 | --state:run(tcc.args("foo", "bar")) 120 | function tcc.args(...) 121 | local argc = select("#", ...) 122 | local argv 123 | 124 | argv = ffi.new("char*[?]", argc) 125 | for i = 1, argc do 126 | local arg = select(i, ...) 127 | argv[i - 1] = ffi.cast("char*", arg) 128 | end 129 | 130 | return argc, argv 131 | end 132 | 133 | --- A TCC compilation context. 134 | -- @type State 135 | local State = {} 136 | tcc.State = State 137 | State.__index = State 138 | 139 | --- Free the compilation context and associated resources. Usually called 140 | --- automatically when the @{State} is garbage-collected. 141 | function State:delete() 142 | tcc.clib.tcc_delete(self) 143 | end 144 | 145 | --- Set the home path of TCC used by this context. Usually called automatically 146 | --- by @{new}. 147 | --- 148 | --- Originally named `set_lib_path` but renamed for consistency and clarity. 149 | -- @tparam string path 150 | function State:set_home_path(path) 151 | tcc.clib.tcc_set_lib_path(self, path) 152 | end 153 | 154 | --- Set the error/warning display callback. 155 | --- 156 | --- The passed output strings will be formatted like 157 | --- `:[:] `. 158 | -- @tparam function(string) error_func function to be called 159 | function State:set_error_func(error_func) 160 | tcc.clib.tcc_set_error_func(self, nil, function(_, msg) 161 | error_func(ffi.string(msg)) 162 | end) 163 | end 164 | 165 | --- Set one or multiple command line arguments for the compiler. 166 | -- @tparam string args the arguments 167 | -- @treturn bool success 168 | function State:set_options(args) 169 | return tcc.clib.tcc_set_options(self, args) == 0 170 | end 171 | 172 | --- Preprocessor 173 | -- @section 174 | 175 | --- Add an include path. 176 | -- @tparam string path include path to be added 177 | -- @treturn bool success 178 | function State:add_include_path(path) 179 | return tcc.clib.tcc_add_include_path(self, path) == 0 180 | end 181 | 182 | --- Add a system include path. Usually called automatically by @{new}. 183 | -- @tparam string path system include path to be added 184 | -- @treturn bool success 185 | function State:add_sysinclude_path(path) 186 | return tcc.clib.tcc_add_sysinclude_path(self, path) == 0 187 | end 188 | 189 | --- Define a preprocessor symbol with an optional value. 190 | -- @tparam string name name of the symbol 191 | -- @tparam[opt] string value optional value of the symbol 192 | function State:define_symbol(name, value) 193 | tcc.clib.tcc_define_symbol(self, sym, value) 194 | end 195 | 196 | --- Undefine a preprocessor symbol. 197 | -- @tparam string name name of the symbol 198 | function State:undefine_symbol(name) 199 | tcc.clib.tcc_undefine_symbol(self, sym) 200 | end 201 | 202 | --- Compiling 203 | -- @section 204 | 205 | --- Add a file. 206 | --- This includes: 207 | --- 208 | --- - C files to be compiled 209 | --- - DLLs, object files and libraries to be linked against 210 | --- - ld scripts 211 | -- @tparam string file_path path to the file to be added 212 | -- @treturn bool success 213 | function State:add_file(file_path) 214 | return tcc.clib.tcc_add_file(self, file_path) == 0 215 | end 216 | 217 | --- Compile a string containing a C source. 218 | -- @tparam string source source code to be compiled 219 | -- @treturn bool success 220 | function State:compile_string(source) 221 | return tcc.clib.tcc_compile_string(self, source) == 0 222 | end 223 | 224 | --- Linking commands 225 | -- @section 226 | 227 | --- Set the output type. 228 | --- 229 | --- **Must be called** before any compilation. 230 | -- @tparam OUTPUT output_type 231 | -- @treturn bool success 232 | function State:set_output_type(output_type) 233 | return tcc.clib.tcc_set_output_type(self, output_type) == 0 234 | end 235 | 236 | --- Add a library path. Equivalent to the `-Lpath` option. 237 | -- @tparam string path library path to be added 238 | -- @treturn bool success 239 | function State:add_library_path(path) 240 | return tcc.clib.tcc_add_library_path(self, path) == 0 241 | end 242 | 243 | --- Add a library to be linked against. Equivalent to the `-lname` option. 244 | -- @tparam string name name of the library to be linked against 245 | -- @treturn bool success 246 | function State:add_library(name) 247 | return tcc.clib.tcc_add_library(self, name) == 0 248 | end 249 | 250 | --- Add a pointer symbol to the compiled program. 251 | -- @tparam string name name of the symbol 252 | -- @tparam cdata(void*) value pointer of the symbol 253 | -- @treturn bool success 254 | -- @see ./examples/add_symbol.lua.html 255 | function State:add_symbol(name, value) 256 | return tcc.clib.tcc_add_symbol(self, name, value) == 0 257 | end 258 | 259 | --- Output a compiled executable, library or object file to a path. **Do not** 260 | --- call @{State:relocate} before. 261 | -- @tparam string file_path output file path 262 | -- @treturn bool success 263 | function State:output_file(file_path) 264 | return tcc.clib.tcc_output_file(self, file_path) == 0 265 | end 266 | 267 | --- Link and run the `main()` function and return its return code. **Do not** 268 | --- call @{State:relocate} before. 269 | -- @tparam[opt] cdata(int) argc number of passed arguments 270 | -- @tparam[opt] cdata(char**) argv arguments as an array of C-strings 271 | -- @treturn cdata(int) return code 272 | -- @usage 273 | --local argv = ffi.new("char*[2]") 274 | --argv[0] = "foo" 275 | --argv[1] = "bar" 276 | --state:run(2, argv) 277 | -- @see ./examples/run.lua.html 278 | function State:run(argc, argv) 279 | return tcc.clib.tcc_run(self, argc, argv) 280 | end 281 | 282 | --- Do all relocations needed for using @{State:get_symbol}. 283 | --- This can be done either within internally managed memory (by passing 284 | --- @{RELOCATE|RELOCATE.AUTO}) or within an user-managed memory chunk that is at 285 | --- least of the size that is returned by passing @{RELOCATE|RELOCATE.SIZE}. 286 | -- @tparam cdata(void*) ptr pointer to a memory chunk or one of the members of 287 | -- @{RELOCATE} 288 | -- @treturn[0] bool success 289 | -- @treturn[1] number required memory size if @{RELOCATE|RELOCATE.SIZE} was 290 | -- passed 291 | -- @usage 292 | --local size = state:relocate(tcc.RELOCATE.SIZE) 293 | --local mem = ffi.new("char[?]", size) 294 | --state:relocate(mem) 295 | function State:relocate(ptr) 296 | if ptr == tcc.RELOCATE.SIZE then 297 | return tcc.clib.tcc_relocate(self, ptr) 298 | else 299 | return tcc.clib.tcc_relocate(self, ptr) == 0 300 | end 301 | end 302 | 303 | --- Return the pointer to a symbol or `NULL` if it was not found. 304 | -- @tparam string name name of the symbol 305 | -- @treturn cdata(void*) pointer to the symbol 306 | -- @see ./examples/get_symbol.lua.html 307 | function State:get_symbol(name) 308 | return tcc.clib.tcc_get_symbol(self, name) 309 | end 310 | 311 | function State:__gc() 312 | self:delete() 313 | end 314 | 315 | return tcc 316 | --------------------------------------------------------------------------------