diff options
| -rwxr-xr-x | doc/lib.txt | 250 | ||||
| -rwxr-xr-x | lib/system.nim | 2 | ||||
| -rw-r--r-- | lib/wrappers/expat.nim | 877 | ||||
| -rwxr-xr-x | rod/astalgo.nim | 1 | ||||
| -rwxr-xr-x | rod/c2nim/c2nim.nim | 4 | ||||
| -rwxr-xr-x | rod/c2nim/cparse.nim | 144 | ||||
| -rwxr-xr-x | rod/c2nim/cpp.nim | 24 | ||||
| -rwxr-xr-x | rod/c2nim/manual.txt | 47 | ||||
| -rwxr-xr-x | rod/c2nim/tests/systest.c | 68 | ||||
| -rwxr-xr-x | todo.txt | 2 | ||||
| -rwxr-xr-x | web/news.txt | 1 | ||||
| -rwxr-xr-x | web/nimrod.ini | 3 |
12 files changed, 1257 insertions, 166 deletions
diff --git a/doc/lib.txt b/doc/lib.txt index fa29ff6ff..abe4ed020 100755 --- a/doc/lib.txt +++ b/doc/lib.txt @@ -55,10 +55,6 @@ String handling * `unicode <unicode.html>`_ This module provides support to handle the Unicode UTF-8 encoding. -* `re <re.html>`_ - This module contains procedures and operators for handling regular - expressions. Consider using `pegs` instead. - * `pegs <pegs.html>`_ This module contains procedures and operators for handling PEGs. @@ -208,22 +204,12 @@ Multimedia support Impure libraries ================ -* `graphics <graphics.html>`_ - This module implements graphical output for Nimrod; the current - implementation uses SDL but the interface is meant to support multiple - backends some day. - -* `dialogs <dialogs.html>`_ - This module implements portable dialogs for Nimrod; the implementation - builds on the GTK interface. On Windows, native dialogs are shown if - appropriate. - -* `zipfiles <zipfiles.html>`_ - This module implements a zip archive creator/reader/modifier. +Regular expressions +------------------- -* `web <web.html>`_ - This module contains simple high-level procedures for dealing with the - Web like loading the contents of a Web page from an URL. +* `re <re.html>`_ + This module contains procedures and operators for handling regular + expressions. The current implementation uses PCRE. Database support @@ -242,6 +228,27 @@ Database support for other databases too. +Other +----- + +* `graphics <graphics.html>`_ + This module implements graphical output for Nimrod; the current + implementation uses SDL but the interface is meant to support multiple + backends some day. + +* `dialogs <dialogs.html>`_ + This module implements portable dialogs for Nimrod; the implementation + builds on the GTK interface. On Windows, native dialogs are shown if + appropriate. + +* `zipfiles <zipfiles.html>`_ + This module implements a zip archive creator/reader/modifier. + +* `web <web.html>`_ + This module contains simple high-level procedures for dealing with the + Web like loading the contents of a Web page from an URL. + + Wrappers ======== @@ -249,26 +256,71 @@ Wrappers The generated HTML for some of these wrappers is so huge, that it is not contained in the distribution. You can then find them on the website. -* `posix <posix.html>`_ - Contains a wrapper for the POSIX standard. +Windows specific +---------------- + * `windows <windows.html>`_ Contains a wrapper for the Win32 API. -* `mysql <mysql.html>`_ - Contains a wrapper for the mySQL API. -* `sqlite3 <sqlite3.html>`_ - Contains a wrapper for SQLite 3 API. -* `libcurl <libcurl.html>`_ - Contains a wrapper for the libcurl library. +* `ole2 <ole2.html>`_ + Contains GUIDs for OLE2 automation support. * `shellapi <shellapi.html>`_ Contains a wrapper for the ``shellapi.h`` header. * `shfolder <shfolder.html>`_ Contains a wrapper for the ``shfolder.h`` header. * `mmsystem <mmsystem.html>`_ Contains a wrapper for the ``mmsystem.h`` header. -* `ole2 <ole2.html>`_ - Contains GUIDs for OLE2 automation support. * `nb30 <nb30.html>`_ This module contains the definitions for portable NetBIOS 3.0 support. + + +UNIX specific +------------- + +* `posix <posix.html>`_ + Contains a wrapper for the POSIX standard. +* `cursorfont <cursorfont.html>`_ + Part of the wrapper for X11. +* `keysym <keysym.html>`_ + Part of the wrapper for X11. +* `x <x.html>`_ + Part of the wrapper for X11. +* `xatom <xatom.html>`_ + Part of the wrapper for X11. +* `xcms <xcms.html>`_ + Part of the wrapper for X11. +* `xf86dga <xf86dga.html>`_ + Part of the wrapper for X11. +* `xf86vmode <xf86vmode.html>`_ + Part of the wrapper for X11. +* `xi <xi.html>`_ + Part of the wrapper for X11. +* `xinerama <xinerama.html>`_ + Part of the wrapper for X11. +* `xkb <xkb.html>`_ + Part of the wrapper for X11. +* `xkblib <xkblib.html>`_ + Part of the wrapper for X11. +* `xlib <xlib.html>`_ + Part of the wrapper for X11. +* `xrandr <xrandr.html>`_ + Part of the wrapper for X11. +* `xrender <xrender.html>`_ + Part of the wrapper for X11. +* `xresource <xresource.html>`_ + Part of the wrapper for X11. +* `xshm <xshm.html>`_ + Part of the wrapper for X11. +* `xutil <xutil.html>`_ + Part of the wrapper for X11. +* `xv <xv.html>`_ + Part of the wrapper for X11. +* `xvlib <xvlib.html>`_ + Part of the wrapper for X11. + + +Graphics libraries +------------------ + * `cairo <cairo.html>`_ Wrapper for the cairo library. * `cairoft <cairoft.html>`_ @@ -277,6 +329,38 @@ not contained in the distribution. You can then find them on the website. Wrapper for the cairowin32 library. * `cairoxlib <cairoxlib.html>`_ Wrapper for the cairoxlib library. + +* `sdl <sdl.html>`_ + Part of the wrapper for SDL. +* `sdl_gfx <sdl_gfx.html>`_ + Part of the wrapper for SDL. +* `sdl_image <sdl_image.html>`_ + Part of the wrapper for SDL. +* `sdl_mixer <sdl_mixer.html>`_ + Part of the wrapper for SDL. +* `sdl_net <sdl_net.html>`_ + Part of the wrapper for SDL. +* `sdl_ttf <sdl_ttf.html>`_ + Part of the wrapper for SDL. +* `smpeg <smpeg.html>`_ + Part of the wrapper for SDL. + +* `gl <gl.html>`_ + Part of the wrapper for OpenGL. +* `glext <glext.html>`_ + Part of the wrapper for OpenGL. +* `glu <glu.html>`_ + Part of the wrapper for OpenGL. +* `glut <glut.html>`_ + Part of the wrapper for OpenGL. +* `glx <glx.html>`_ + Part of the wrapper for OpenGL. +* `wingl <wingl.html>`_ + Part of the wrapper for OpenGL. + + +GUI libraries +------------- * `atk <atk.html>`_ Wrapper for the atk library. * `gdk2 <gdk2.html>`_ @@ -299,18 +383,40 @@ not contained in the distribution. You can then find them on the website. Wrapper for the pango library. * `pangoutils <pangoutils.html>`_ Wrapper for the pangoutils library. -* `gl <gl.html>`_ - Part of the wrapper for OpenGL. -* `glext <glext.html>`_ - Part of the wrapper for OpenGL. -* `glu <glu.html>`_ - Part of the wrapper for OpenGL. -* `glut <glut.html>`_ - Part of the wrapper for OpenGL. -* `glx <glx.html>`_ - Part of the wrapper for OpenGL. -* `wingl <wingl.html>`_ - Part of the wrapper for OpenGL. +* `iup <iup.html>`_ + Wrapper of the IUP GUI library. + + +Database support +---------------- + +* `postgres <postgres.html>`_ + Contains a wrapper for the PostgreSQL API. +* `mysql <mysql.html>`_ + Contains a wrapper for the mySQL API. +* `sqlite3 <sqlite3.html>`_ + Contains a wrapper for SQLite 3 API. +* `odbcsql <odbcsql.html>`_ + interface to the ODBC driver. + + +XML Processing +-------------- + +* `expat <expat.html>`_ + Wrapper of the expat XML parser. + + +Internet Protocols and Support +------------------------------ + +* `libcurl <libcurl.html>`_ + Contains a wrapper for the libcurl library. + + +Scripting languages +------------------- + * `lua <lua.html>`_ Part of the wrapper for Lua. * `lualib <lualib.html>`_ @@ -321,65 +427,15 @@ not contained in the distribution. You can then find them on the website. Wrapper for the TCL programming language. * `python <python.html>`_ Wrapper for the Python programming language. -* `odbcsql <odbcsql.html>`_ - interface to the ODBC driver. + + +Data Compression and Archiving +------------------------------ + * `zlib <zlib.html>`_ Wrapper for the zlib library. -* `sdl <sdl.html>`_ - Part of the wrapper for SDL. -* `sdl_gfx <sdl_gfx.html>`_ - Part of the wrapper for SDL. -* `sdl_image <sdl_image.html>`_ - Part of the wrapper for SDL. -* `sdl_mixer <sdl_mixer.html>`_ - Part of the wrapper for SDL. -* `sdl_net <sdl_net.html>`_ - Part of the wrapper for SDL. -* `sdl_ttf <sdl_ttf.html>`_ - Part of the wrapper for SDL. -* `smpeg <smpeg.html>`_ - Part of the wrapper for SDL. -* `cursorfont <cursorfont.html>`_ - Part of the wrapper for X11. -* `keysym <keysym.html>`_ - Part of the wrapper for X11. -* `x <x.html>`_ - Part of the wrapper for X11. -* `xatom <xatom.html>`_ - Part of the wrapper for X11. -* `xcms <xcms.html>`_ - Part of the wrapper for X11. -* `xf86dga <xf86dga.html>`_ - Part of the wrapper for X11. -* `xf86vmode <xf86vmode.html>`_ - Part of the wrapper for X11. -* `xi <xi.html>`_ - Part of the wrapper for X11. -* `xinerama <xinerama.html>`_ - Part of the wrapper for X11. -* `xkb <xkb.html>`_ - Part of the wrapper for X11. -* `xkblib <xkblib.html>`_ - Part of the wrapper for X11. -* `xlib <xlib.html>`_ - Part of the wrapper for X11. -* `xrandr <xrandr.html>`_ - Part of the wrapper for X11. -* `xrender <xrender.html>`_ - Part of the wrapper for X11. -* `xresource <xresource.html>`_ - Part of the wrapper for X11. -* `xshm <xshm.html>`_ - Part of the wrapper for X11. -* `xutil <xutil.html>`_ - Part of the wrapper for X11. -* `xv <xv.html>`_ - Part of the wrapper for X11. -* `xvlib <xvlib.html>`_ - Part of the wrapper for X11. + * `libzip <libzip.html>`_ Interface to the `lib zip <http://www.nih.at/libzip/index.html>`_ library by Dieter Baron and Thomas Klausner. -* `iup <iup.html>`_ - Wrapper of the IUP GUI library. diff --git a/lib/system.nim b/lib/system.nim index da64b233e..626002794 100755 --- a/lib/system.nim +++ b/lib/system.nim @@ -14,7 +14,7 @@ ## explicitly. Because of this there cannot be a user-defined module named ## ``system``. -{.push hints: on.} +{.push hints: off.} type int* {.magic: Int.} ## default integer type; bitwidth depends on diff --git a/lib/wrappers/expat.nim b/lib/wrappers/expat.nim new file mode 100644 index 000000000..59e698263 --- /dev/null +++ b/lib/wrappers/expat.nim @@ -0,0 +1,877 @@ +# Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd +# See the file COPYING for copying permission. +# + +when not defined(expatDll): + when defined(windows): + const + expatDll = "expat.dll" + elif defined(macosx): + const + expatDll = "libexpat.dynlib" + else: + const + expatDll = "libexpat.so(.1|)" +type + TParserStruct{.pure, final.} = object + + PParser* = ptr TParserStruct + +# The XML_Status enum gives the possible return values for several +# API functions. The preprocessor #defines are included so this +# stanza can be added to code that still needs to support older +# versions of Expat 1.95.x: +# +# #ifndef XML_STATUS_OK +# #define XML_STATUS_OK 1 +# #define XML_STATUS_ERROR 0 +# #endif +# +# Otherwise, the #define hackery is quite ugly and would have been +# dropped. +# + +type + TStatus*{.size: sizeof(cint).} = enum + STATUS_ERROR = 0, STATUS_OK = 1, STATUS_SUSPENDED = 2 + TError*{.size: sizeof(cint).} = enum + ERROR_NONE, ERROR_NO_MEMORY, ERROR_SYNTAX, ERROR_NO_ELEMENTS, + ERROR_INVALID_TOKEN, ERROR_UNCLOSED_TOKEN, ERROR_PARTIAL_CHAR, + ERROR_TAG_MISMATCH, ERROR_DUPLICATE_ATTRIBUTE, + ERROR_JUNK_AFTER_DOC_ELEMENT, + ERROR_PARAM_ENTITY_REF, ERROR_UNDEFINED_ENTITY, ERROR_RECURSIVE_ENTITY_REF, + ERROR_ASYNC_ENTITY, ERROR_BAD_CHAR_REF, ERROR_BINARY_ENTITY_REF, + ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, ERROR_MISPLACED_XML_PI, + ERROR_UNKNOWN_ENCODING, ERROR_INCORRECT_ENCODING, + ERROR_UNCLOSED_CDATA_SECTION, ERROR_EXTERNAL_ENTITY_HANDLING, + ERROR_NOT_STANDALONE, ERROR_UNEXPECTED_STATE, ERROR_ENTITY_DECLARED_IN_PE, + ERROR_FEATURE_REQUIRES_XML_DTD, ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING, + ERROR_UNBOUND_PREFIX, + ERROR_UNDECLARING_PREFIX, ERROR_INCOMPLETE_PE, ERROR_XML_DECL, + ERROR_TEXT_DECL, ERROR_PUBLICID, ERROR_SUSPENDED, ERROR_NOT_SUSPENDED, + ERROR_ABORTED, ERROR_FINISHED, ERROR_SUSPEND_PE, + ERROR_RESERVED_PREFIX_XML, ERROR_RESERVED_PREFIX_XMLNS, + ERROR_RESERVED_NAMESPACE_URI + TContent_Type*{.size: sizeof(cint).} = enum + CTYPE_EMPTY = 1, CTYPE_ANY, CTYPE_MIXED, CTYPE_NAME, CTYPE_CHOICE, CTYPE_SEQ + TContent_Quant*{.size: sizeof(cint).} = enum + CQUANT_NONE, CQUANT_OPT, CQUANT_REP, CQUANT_PLUS + +# If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be +# XML_CQUANT_NONE, and the other fields will be zero or NULL. +# If type == XML_CTYPE_MIXED, then quant will be NONE or REP and +# numchildren will contain number of elements that may be mixed in +# and children point to an array of XML_Content cells that will be +# all of XML_CTYPE_NAME type with no quantification. +# +# If type == XML_CTYPE_NAME, then the name points to the name, and +# the numchildren field will be zero and children will be NULL. The +# quant fields indicates any quantifiers placed on the name. +# +# CHOICE and SEQ will have name NULL, the number of children in +# numchildren and children will point, recursively, to an array +# of XML_Content cells. +# +# The EMPTY, ANY, and MIXED types will only occur at top level. +# + +type + TContent*{.pure, final.} = object + typ*: TContent_Type + quant*: TContent_Quant + name*: cstring + numchildren*: cint + children*: ptr TContent + + +# This is called for an element declaration. See above for +# description of the model argument. It's the caller's responsibility +# to free model when finished with it. +# + +type + TElementDeclHandler* = proc (userData: pointer, name: cstring, + model: ptr TContent){.cdecl.} + +proc SetElementDeclHandler*(parser: PParser, eldecl: TElementDeclHandler){. + cdecl, importc: "XML_SetElementDeclHandler", dynlib: expatDll.} +# The Attlist declaration handler is called for *each* attribute. So +# a single Attlist declaration with multiple attributes declared will +# generate multiple calls to this handler. The "default" parameter +# may be NULL in the case of the "#IMPLIED" or "#REQUIRED" +# keyword. The "isrequired" parameter will be true and the default +# value will be NULL in the case of "#REQUIRED". If "isrequired" is +# true and default is non-NULL, then this is a "#FIXED" default. +# + +type + TAttlistDeclHandler* = proc (userData: pointer, elname: cstring, + attname: cstring, att_type: cstring, + dflt: cstring, isrequired: cint){.cdecl.} + +proc SetAttlistDeclHandler*(parser: PParser, attdecl: TAttlistDeclHandler){. + cdecl, importc: "XML_SetAttlistDeclHandler", dynlib: expatDll.} +# The XML declaration handler is called for *both* XML declarations +# and text declarations. The way to distinguish is that the version +# parameter will be NULL for text declarations. The encoding +# parameter may be NULL for XML declarations. The standalone +# parameter will be -1, 0, or 1 indicating respectively that there +# was no standalone parameter in the declaration, that it was given +# as no, or that it was given as yes. +# + +type + TXmlDeclHandler* = proc (userData: pointer, version: cstring, + encoding: cstring, standalone: cint){.cdecl.} + +proc SetXmlDeclHandler*(parser: PParser, xmldecl: TXmlDeclHandler){.cdecl, + importc: "XML_SetXmlDeclHandler", dynlib: expatDll.} +type + TMemory_Handling_Suite*{.pure, final.} = object + malloc_fcn*: proc (size: int): pointer{.cdecl.} + realloc_fcn*: proc (p: pointer, size: int): pointer{.cdecl.} + free_fcn*: proc (p: pointer){.cdecl.} + + +# Constructs a new parser; encoding is the encoding specified by the +# external protocol or NULL if there is none specified. +# + +proc ParserCreate*(encoding: cstring): PParser{.cdecl, + importc: "XML_ParserCreate", dynlib: expatDll.} +# Constructs a new parser and namespace processor. Element type +# names and attribute names that belong to a namespace will be +# expanded; unprefixed attribute names are never expanded; unprefixed +# element type names are expanded only if there is a default +# namespace. The expanded name is the concatenation of the namespace +# URI, the namespace separator character, and the local part of the +# name. If the namespace separator is '\0' then the namespace URI +# and the local part will be concatenated without any separator. +# It is a programming error to use the separator '\0' with namespace +# triplets (see XML_SetReturnNSTriplet). +# + +proc ParserCreateNS*(encoding: cstring, namespaceSeparator: char): PParser{. + cdecl, importc: "XML_ParserCreateNS", dynlib: expatDll.} +# Constructs a new parser using the memory management suite referred to +# by memsuite. If memsuite is NULL, then use the standard library memory +# suite. If namespaceSeparator is non-NULL it creates a parser with +# namespace processing as described above. The character pointed at +# will serve as the namespace separator. +# +# All further memory operations used for the created parser will come from +# the given suite. +# + +proc ParserCreate_MM*(encoding: cstring, memsuite: ptr TMemory_Handling_Suite, + namespaceSeparator: cstring): PParser{.cdecl, + importc: "XML_ParserCreate_MM", dynlib: expatDll.} +# Prepare a parser object to be re-used. This is particularly +# valuable when memory allocation overhead is disproportionatly high, +# such as when a large number of small documnents need to be parsed. +# All handlers are cleared from the parser, except for the +# unknownEncodingHandler. The parser's external state is re-initialized +# except for the values of ns and ns_triplets. +# +# Added in Expat 1.95.3. +# + +proc ParserReset*(parser: PParser, encoding: cstring): Bool{.cdecl, + importc: "XML_ParserReset", dynlib: expatDll.} +# atts is array of name/value pairs, terminated by 0; +# names and values are 0 terminated. +# + +type + TStartElementHandler* = proc (userData: pointer, name: cstring, + atts: cstringArray){.cdecl.} + TEndElementHandler* = proc (userData: pointer, name: cstring){.cdecl.} + +# s is not 0 terminated. + +type + TCharacterDataHandler* = proc (userData: pointer, s: cstring, len: cint){. + cdecl.} + +# target and data are 0 terminated + +type + TProcessingInstructionHandler* = proc (userData: pointer, target: cstring, + data: cstring){.cdecl.} + +# data is 0 terminated + +type + TCommentHandler* = proc (userData: pointer, data: cstring){.cdecl.} + TStartCdataSectionHandler* = proc (userData: pointer){.cdecl.} + TEndCdataSectionHandler* = proc (userData: pointer){.cdecl.} + +# This is called for any characters in the XML document for which +# there is no applicable handler. This includes both characters that +# are part of markup which is of a kind that is not reported +# (comments, markup declarations), or characters that are part of a +# construct which could be reported but for which no handler has been +# supplied. The characters are passed exactly as they were in the XML +# document except that they will be encoded in UTF-8 or UTF-16. +# Line boundaries are not normalized. Note that a byte order mark +# character is not passed to the default handler. There are no +# guarantees about how characters are divided between calls to the +# default handler: for example, a comment might be split between +# multiple calls. +# + +type + TDefaultHandler* = proc (userData: pointer, s: cstring, len: cint){.cdecl.} + +# This is called for the start of the DOCTYPE declaration, before +# any DTD or internal subset is parsed. +# + +type + TStartDoctypeDeclHandler* = proc (userData: pointer, doctypeName: cstring, + sysid: cstring, pubid: cstring, + has_internal_subset: cint){.cdecl.} + +# This is called for the start of the DOCTYPE declaration when the +# closing > is encountered, but after processing any external +# subset. +# + +type + TEndDoctypeDeclHandler* = proc (userData: pointer){.cdecl.} + +# This is called for entity declarations. The is_parameter_entity +# argument will be non-zero if the entity is a parameter entity, zero +# otherwise. +# +# For internal entities (<!ENTITY foo "bar">), value will +# be non-NULL and systemId, publicID, and notationName will be NULL. +# The value string is NOT nul-terminated; the length is provided in +# the value_length argument. Since it is legal to have zero-length +# values, do not use this argument to test for internal entities. +# +# For external entities, value will be NULL and systemId will be +# non-NULL. The publicId argument will be NULL unless a public +# identifier was provided. The notationName argument will have a +# non-NULL value only for unparsed entity declarations. +# +# Note that is_parameter_entity can't be changed to XML_Bool, since +# that would break binary compatibility. +# + +type + TEntityDeclHandler* = proc (userData: pointer, entityName: cstring, + is_parameter_entity: cint, value: cstring, + value_length: cint, base: cstring, + systemId: cstring, publicId: cstring, + notationName: cstring){.cdecl.} + +proc SetEntityDeclHandler*(parser: PParser, handler: TEntityDeclHandler){.cdecl, + importc: "XML_SetEntityDeclHandler", dynlib: expatDll.} +# OBSOLETE -- OBSOLETE -- OBSOLETE +# This handler has been superceded by the EntityDeclHandler above. +# It is provided here for backward compatibility. +# +# This is called for a declaration of an unparsed (NDATA) entity. +# The base argument is whatever was set by XML_SetBase. The +# entityName, systemId and notationName arguments will never be +# NULL. The other arguments may be. +# + +type + TUnparsedEntityDeclHandler* = proc (userData: pointer, entityName: cstring, + base: cstring, systemId: cstring, + publicId, notationName: cstring){. + cdecl.} + +# This is called for a declaration of notation. The base argument is +# whatever was set by XML_SetBase. The notationName will never be +# NULL. The other arguments can be. +# + +type + TNotationDeclHandler* = proc (userData: pointer, notationName: cstring, + base: cstring, systemId: cstring, + publicId: cstring){.cdecl.} + +# When namespace processing is enabled, these are called once for +# each namespace declaration. The call to the start and end element +# handlers occur between the calls to the start and end namespace +# declaration handlers. For an xmlns attribute, prefix will be +# NULL. For an xmlns="" attribute, uri will be NULL. +# + +type + TStartNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring, + uri: cstring){.cdecl.} + TEndNamespaceDeclHandler* = proc (userData: pointer, prefix: cstring){.cdecl.} + +# This is called if the document is not standalone, that is, it has an +# external subset or a reference to a parameter entity, but does not +# have standalone="yes". If this handler returns XML_STATUS_ERROR, +# then processing will not continue, and the parser will return a +# XML_ERROR_NOT_STANDALONE error. +# If parameter entity parsing is enabled, then in addition to the +# conditions above this handler will only be called if the referenced +# entity was actually read. +# + +type + TNotStandaloneHandler* = proc (userData: pointer): cint{.cdecl.} + +# This is called for a reference to an external parsed general +# entity. The referenced entity is not automatically parsed. The +# application can parse it immediately or later using +# XML_ExternalEntityParserCreate. +# +# The parser argument is the parser parsing the entity containing the +# reference; it can be passed as the parser argument to +# XML_ExternalEntityParserCreate. The systemId argument is the +# system identifier as specified in the entity declaration; it will +# not be NULL. +# +# The base argument is the system identifier that should be used as +# the base for resolving systemId if systemId was relative; this is +# set by XML_SetBase; it may be NULL. +# +# The publicId argument is the public identifier as specified in the +# entity declaration, or NULL if none was specified; the whitespace +# in the public identifier will have been normalized as required by +# the XML spec. +# +# The context argument specifies the parsing context in the format +# expected by the context argument to XML_ExternalEntityParserCreate; +# context is valid only until the handler returns, so if the +# referenced entity is to be parsed later, it must be copied. +# context is NULL only when the entity is a parameter entity. +# +# The handler should return XML_STATUS_ERROR if processing should not +# continue because of a fatal error in the handling of the external +# entity. In this case the calling parser will return an +# XML_ERROR_EXTERNAL_ENTITY_HANDLING error. +# +# Note that unlike other handlers the first argument is the parser, +# not userData. +# + +type + TExternalEntityRefHandler* = proc (parser: PParser, context: cstring, + base: cstring, systemId: cstring, + publicId: cstring): cint{.cdecl.} + +# This is called in two situations: +# 1) An entity reference is encountered for which no declaration +# has been read *and* this is not an error. +# 2) An internal entity reference is read, but not expanded, because +# XML_SetDefaultHandler has been called. +# Note: skipped parameter entities in declarations and skipped general +# entities in attribute values cannot be reported, because +# the event would be out of sync with the reporting of the +# declarations or attribute values +# + +type + TSkippedEntityHandler* = proc (userData: pointer, entityName: cstring, + is_parameter_entity: cint){.cdecl.} + +# This structure is filled in by the XML_UnknownEncodingHandler to +# provide information to the parser about encodings that are unknown +# to the parser. +# +# The map[b] member gives information about byte sequences whose +# first byte is b. +# +# If map[b] is c where c is >= 0, then b by itself encodes the +# Unicode scalar value c. +# +# If map[b] is -1, then the byte sequence is malformed. +# +# If map[b] is -n, where n >= 2, then b is the first byte of an +# n-byte sequence that encodes a single Unicode scalar value. +# +# The data member will be passed as the first argument to the convert +# function. +# +# The convert function is used to convert multibyte sequences; s will +# point to a n-byte sequence where map[(unsigned char)*s] == -n. The +# convert function must return the Unicode scalar value represented +# by this byte sequence or -1 if the byte sequence is malformed. +# +# The convert function may be NULL if the encoding is a single-byte +# encoding, that is if map[b] >= -1 for all bytes b. +# +# When the parser is finished with the encoding, then if release is +# not NULL, it will call release passing it the data member; once +# release has been called, the convert function will not be called +# again. +# +# Expat places certain restrictions on the encodings that are supported +# using this mechanism. +# +# 1. Every ASCII character that can appear in a well-formed XML document, +# other than the characters +# +# $@\^`{}~ +# +# must be represented by a single byte, and that byte must be the +# same byte that represents that character in ASCII. +# +# 2. No character may require more than 4 bytes to encode. +# +# 3. All characters encoded must have Unicode scalar values <= +# 0xFFFF, (i.e., characters that would be encoded by surrogates in +# UTF-16 are not allowed). Note that this restriction doesn't +# apply to the built-in support for UTF-8 and UTF-16. +# +# 4. No Unicode character may be encoded by more than one distinct +# sequence of bytes. +# + +type + TEncoding*{.pure, final.} = object + map*: array[0..256 - 1, cint] + data*: pointer + convert*: proc (data: pointer, s: cstring): cint{.cdecl.} + release*: proc (data: pointer){.cdecl.} + + +# This is called for an encoding that is unknown to the parser. +# +# The encodingHandlerData argument is that which was passed as the +# second argument to XML_SetUnknownEncodingHandler. +# +# The name argument gives the name of the encoding as specified in +# the encoding declaration. +# +# If the callback can provide information about the encoding, it must +# fill in the XML_Encoding structure, and return XML_STATUS_OK. +# Otherwise it must return XML_STATUS_ERROR. +# +# If info does not describe a suitable encoding, then the parser will +# return an XML_UNKNOWN_ENCODING error. +# + +type + TUnknownEncodingHandler* = proc (encodingHandlerData: pointer, name: cstring, + info: ptr TEncoding): cint{.cdecl.} + +proc SetElementHandler*(parser: PParser, start: TStartElementHandler, + endHandler: TEndElementHandler){.cdecl, + importc: "XML_SetElementHandler", dynlib: expatDll.} +proc SetStartElementHandler*(parser: PParser, handler: TStartElementHandler){. + cdecl, importc: "XML_SetStartElementHandler", dynlib: expatDll.} +proc SetEndElementHandler*(parser: PParser, handler: TEndElementHandler){.cdecl, + importc: "XML_SetEndElementHandler", dynlib: expatDll.} +proc SetCharacterDataHandler*(parser: PParser, handler: TCharacterDataHandler){. + cdecl, importc: "XML_SetCharacterDataHandler", dynlib: expatDll.} +proc SetProcessingInstructionHandler*(parser: PParser, + handler: TProcessingInstructionHandler){. + cdecl, importc: "XML_SetProcessingInstructionHandler", dynlib: expatDll.} +proc SetCommentHandler*(parser: PParser, handler: TCommentHandler){.cdecl, + importc: "XML_SetCommentHandler", dynlib: expatDll.} +proc SetCdataSectionHandler*(parser: PParser, start: TStartCdataSectionHandler, + endHandler: TEndCdataSectionHandler){.cdecl, + importc: "XML_SetCdataSectionHandler", dynlib: expatDll.} +proc SetStartCdataSectionHandler*(parser: PParser, + start: TStartCdataSectionHandler){.cdecl, + importc: "XML_SetStartCdataSectionHandler", dynlib: expatDll.} +proc SetEndCdataSectionHandler*(parser: PParser, + endHandler: TEndCdataSectionHandler){.cdecl, + importc: "XML_SetEndCdataSectionHandler", dynlib: expatDll.} +# This sets the default handler and also inhibits expansion of +# internal entities. These entity references will be passed to the +# default handler, or to the skipped entity handler, if one is set. +# + +proc SetDefaultHandler*(parser: PParser, handler: TDefaultHandler){.cdecl, + importc: "XML_SetDefaultHandler", dynlib: expatDll.} +# This sets the default handler but does not inhibit expansion of +# internal entities. The entity reference will not be passed to the +# default handler. +# + +proc SetDefaultHandlerExpand*(parser: PParser, handler: TDefaultHandler){.cdecl, + importc: "XML_SetDefaultHandlerExpand", dynlib: expatDll.} +proc SetDoctypeDeclHandler*(parser: PParser, start: TStartDoctypeDeclHandler, + endHandler: TEndDoctypeDeclHandler){.cdecl, + importc: "XML_SetDoctypeDeclHandler", dynlib: expatDll.} +proc SetStartDoctypeDeclHandler*(parser: PParser, + start: TStartDoctypeDeclHandler){.cdecl, + importc: "XML_SetStartDoctypeDeclHandler", dynlib: expatDll.} +proc SetEndDoctypeDeclHandler*(parser: PParser, + endHandler: TEndDoctypeDeclHandler){.cdecl, + importc: "XML_SetEndDoctypeDeclHandler", dynlib: expatDll.} +proc SetUnparsedEntityDeclHandler*(parser: PParser, + handler: TUnparsedEntityDeclHandler){.cdecl, + importc: "XML_SetUnparsedEntityDeclHandler", dynlib: expatDll.} +proc SetNotationDeclHandler*(parser: PParser, handler: TNotationDeclHandler){. + cdecl, importc: "XML_SetNotationDeclHandler", dynlib: expatDll.} +proc SetNamespaceDeclHandler*(parser: PParser, + start: TStartNamespaceDeclHandler, + endHandler: TEndNamespaceDeclHandler){.cdecl, + importc: "XML_SetNamespaceDeclHandler", dynlib: expatDll.} +proc SetStartNamespaceDeclHandler*(parser: PParser, + start: TStartNamespaceDeclHandler){.cdecl, + importc: "XML_SetStartNamespaceDeclHandler", dynlib: expatDll.} +proc SetEndNamespaceDeclHandler*(parser: PParser, + endHandler: TEndNamespaceDeclHandler){.cdecl, + importc: "XML_SetEndNamespaceDeclHandler", dynlib: expatDll.} +proc SetNotStandaloneHandler*(parser: PParser, handler: TNotStandaloneHandler){. + cdecl, importc: "XML_SetNotStandaloneHandler", dynlib: expatDll.} +proc SetExternalEntityRefHandler*(parser: PParser, + handler: TExternalEntityRefHandler){.cdecl, + importc: "XML_SetExternalEntityRefHandler", dynlib: expatDll.} +# If a non-NULL value for arg is specified here, then it will be +# passed as the first argument to the external entity ref handler +# instead of the parser object. +# + +proc SetExternalEntityRefHandlerArg*(parser: PParser, arg: pointer){.cdecl, + importc: "XML_SetExternalEntityRefHandlerArg", dynlib: expatDll.} +proc SetSkippedEntityHandler*(parser: PParser, handler: TSkippedEntityHandler){. + cdecl, importc: "XML_SetSkippedEntityHandler", dynlib: expatDll.} +proc SetUnknownEncodingHandler*(parser: PParser, + handler: TUnknownEncodingHandler, + encodingHandlerData: pointer){.cdecl, + importc: "XML_SetUnknownEncodingHandler", dynlib: expatDll.} +# This can be called within a handler for a start element, end +# element, processing instruction or character data. It causes the +# corresponding markup to be passed to the default handler. +# + +proc DefaultCurrent*(parser: PParser){.cdecl, importc: "XML_DefaultCurrent", + dynlib: expatDll.} +# If do_nst is non-zero, and namespace processing is in effect, and +# a name has a prefix (i.e. an explicit namespace qualifier) then +# that name is returned as a triplet in a single string separated by +# the separator character specified when the parser was created: URI +# + sep + local_name + sep + prefix. +# +# If do_nst is zero, then namespace information is returned in the +# default manner (URI + sep + local_name) whether or not the name +# has a prefix. +# +# Note: Calling XML_SetReturnNSTriplet after XML_Parse or +# XML_ParseBuffer has no effect. +# + +proc SetReturnNSTriplet*(parser: PParser, do_nst: cint){.cdecl, + importc: "XML_SetReturnNSTriplet", dynlib: expatDll.} +# This value is passed as the userData argument to callbacks. + +proc SetUserData*(parser: PParser, userData: pointer){.cdecl, + importc: "XML_SetUserData", dynlib: expatDll.} +# Returns the last value set by XML_SetUserData or NULL. + +template GetUserData*(parser: expr): expr = + (cast[ptr pointer]((parser))^ ) + +# This is equivalent to supplying an encoding argument to +# XML_ParserCreate. On success XML_SetEncoding returns non-zero, +# zero otherwise. +# Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer +# has no effect and returns XML_STATUS_ERROR. +# + +proc SetEncoding*(parser: PParser, encoding: cstring): TStatus{.cdecl, + importc: "XML_SetEncoding", dynlib: expatDll.} +# If this function is called, then the parser will be passed as the +# first argument to callbacks instead of userData. The userData will +# still be accessible using XML_GetUserData. +# + +proc UseParserAsHandlerArg*(parser: PParser){.cdecl, + importc: "XML_UseParserAsHandlerArg", dynlib: expatDll.} +# If useDTD == XML_TRUE is passed to this function, then the parser +# will assume that there is an external subset, even if none is +# specified in the document. In such a case the parser will call the +# externalEntityRefHandler with a value of NULL for the systemId +# argument (the publicId and context arguments will be NULL as well). +# Note: For the purpose of checking WFC: Entity Declared, passing +# useDTD == XML_TRUE will make the parser behave as if the document +# had a DTD with an external subset. +# Note: If this function is called, then this must be done before +# the first call to XML_Parse or XML_ParseBuffer, since it will +# have no effect after that. Returns +# XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING. +# Note: If the document does not have a DOCTYPE declaration at all, +# then startDoctypeDeclHandler and endDoctypeDeclHandler will not +# be called, despite an external subset being parsed. +# Note: If XML_DTD is not defined when Expat is compiled, returns +# XML_ERROR_FEATURE_REQUIRES_XML_DTD. +# + +proc UseForeignDTD*(parser: PParser, useDTD: Bool): TError{.cdecl, + importc: "XML_UseForeignDTD", dynlib: expatDll.} +# Sets the base to be used for resolving relative URIs in system +# identifiers in declarations. Resolving relative identifiers is +# left to the application: this value will be passed through as the +# base argument to the XML_ExternalEntityRefHandler, +# XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base +# argument will be copied. Returns XML_STATUS_ERROR if out of memory, +# XML_STATUS_OK otherwise. +# + +proc SetBase*(parser: PParser, base: cstring): TStatus{.cdecl, + importc: "XML_SetBase", dynlib: expatDll.} +proc GetBase*(parser: PParser): cstring{.cdecl, importc: "XML_GetBase", + dynlib: expatDll.} +# Returns the number of the attribute/value pairs passed in last call +# to the XML_StartElementHandler that were specified in the start-tag +# rather than defaulted. Each attribute/value pair counts as 2; thus +# this correspondds to an index into the atts array passed to the +# XML_StartElementHandler. +# + +proc GetSpecifiedAttributeCount*(parser: PParser): cint{.cdecl, + importc: "XML_GetSpecifiedAttributeCount", dynlib: expatDll.} +# Returns the index of the ID attribute passed in the last call to +# XML_StartElementHandler, or -1 if there is no ID attribute. Each +# attribute/value pair counts as 2; thus this correspondds to an +# index into the atts array passed to the XML_StartElementHandler. +# + +proc GetIdAttributeIndex*(parser: PParser): cint{.cdecl, + importc: "XML_GetIdAttributeIndex", dynlib: expatDll.} +# Parses some input. Returns XML_STATUS_ERROR if a fatal error is +# detected. The last call to XML_Parse must have isFinal true; len +# may be zero for this call (or any other). +# +# Though the return values for these functions has always been +# described as a Boolean value, the implementation, at least for the +# 1.95.x series, has always returned exactly one of the XML_Status +# values. +# + +proc Parse*(parser: PParser, s: cstring, len: cint, isFinal: cint): TStatus{. + cdecl, importc: "XML_Parse", dynlib: expatDll.} +proc GetBuffer*(parser: PParser, len: cint): pointer{.cdecl, + importc: "XML_GetBuffer", dynlib: expatDll.} +proc ParseBuffer*(parser: PParser, len: cint, isFinal: cint): TStatus{.cdecl, + importc: "XML_ParseBuffer", dynlib: expatDll.} +# Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return. +# Must be called from within a call-back handler, except when aborting +# (resumable = 0) an already suspended parser. Some call-backs may +# still follow because they would otherwise get lost. Examples: +# - endElementHandler() for empty elements when stopped in +# startElementHandler(), +# - endNameSpaceDeclHandler() when stopped in endElementHandler(), +# and possibly others. +# +# Can be called from most handlers, including DTD related call-backs, +# except when parsing an external parameter entity and resumable != 0. +# Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise. +# Possible error codes: +# - XML_ERROR_SUSPENDED: when suspending an already suspended parser. +# - XML_ERROR_FINISHED: when the parser has already finished. +# - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE. +# +# When resumable != 0 (true) then parsing is suspended, that is, +# XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. +# Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer() +# return XML_STATUS_ERROR with error code XML_ERROR_ABORTED. +# +# Note*: +# This will be applied to the current parser instance only, that is, if +# there is a parent parser then it will continue parsing when the +# externalEntityRefHandler() returns. It is up to the implementation of +# the externalEntityRefHandler() to call XML_StopParser() on the parent +# parser (recursively), if one wants to stop parsing altogether. +# +# When suspended, parsing can be resumed by calling XML_ResumeParser(). +# + +proc StopParser*(parser: PParser, resumable: Bool): TStatus{.cdecl, + importc: "XML_StopParser", dynlib: expatDll.} +# Resumes parsing after it has been suspended with XML_StopParser(). +# Must not be called from within a handler call-back. Returns same +# status codes as XML_Parse() or XML_ParseBuffer(). +# Additional error code XML_ERROR_NOT_SUSPENDED possible. +# +# Note*: +# This must be called on the most deeply nested child parser instance +# first, and on its parent parser only after the child parser has finished, +# to be applied recursively until the document entity's parser is restarted. +# That is, the parent parser will not resume by itself and it is up to the +# application to call XML_ResumeParser() on it at the appropriate moment. +# + +proc ResumeParser*(parser: PParser): TStatus{.cdecl, + importc: "XML_ResumeParser", dynlib: expatDll.} +type + TParsing* = enum + INITIALIZED, PARSING, FINISHED, SUSPENDED + TParsingStatus*{.pure, final.} = object + parsing*: TParsing + finalBuffer*: Bool + + +# Returns status of parser with respect to being initialized, parsing, +# finished, or suspended and processing the final buffer. +# XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus, +# XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED +# + +proc GetParsingStatus*(parser: PParser, status: ptr TParsingStatus){.cdecl, + importc: "XML_GetParsingStatus", dynlib: expatDll.} +# Creates an XML_Parser object that can parse an external general +# entity; context is a '\0'-terminated string specifying the parse +# context; encoding is a '\0'-terminated string giving the name of +# the externally specified encoding, or NULL if there is no +# externally specified encoding. The context string consists of a +# sequence of tokens separated by formfeeds (\f); a token consisting +# of a name specifies that the general entity of the name is open; a +# token of the form prefix=uri specifies the namespace for a +# particular prefix; a token of the form =uri specifies the default +# namespace. This can be called at any point after the first call to +# an ExternalEntityRefHandler so longer as the parser has not yet +# been freed. The new parser is completely independent and may +# safely be used in a separate thread. The handlers and userData are +# initialized from the parser argument. Returns NULL if out of memory. +# Otherwise returns a new XML_Parser object. +# + +proc ExternalEntityParserCreate*(parser: PParser, context: cstring, + encoding: cstring): PParser{.cdecl, + importc: "XML_ExternalEntityParserCreate", dynlib: expatDll.} +type + TParamEntityParsing* = enum + PARAM_ENTITY_PARSING_NEVER, PARAM_ENTITY_PARSING_UNLESS_STANDALONE, + PARAM_ENTITY_PARSING_ALWAYS + +# Controls parsing of parameter entities (including the external DTD +# subset). If parsing of parameter entities is enabled, then +# references to external parameter entities (including the external +# DTD subset) will be passed to the handler set with +# XML_SetExternalEntityRefHandler. The context passed will be 0. +# +# Unlike external general entities, external parameter entities can +# only be parsed synchronously. If the external parameter entity is +# to be parsed, it must be parsed during the call to the external +# entity ref handler: the complete sequence of +# XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and +# XML_ParserFree calls must be made during this call. After +# XML_ExternalEntityParserCreate has been called to create the parser +# for the external parameter entity (context must be 0 for this +# call), it is illegal to make any calls on the old parser until +# XML_ParserFree has been called on the newly created parser. +# If the library has been compiled without support for parameter +# entity parsing (ie without XML_DTD being defined), then +# XML_SetParamEntityParsing will return 0 if parsing of parameter +# entities is requested; otherwise it will return non-zero. +# Note: If XML_SetParamEntityParsing is called after XML_Parse or +# XML_ParseBuffer, then it has no effect and will always return 0. +# + +proc SetParamEntityParsing*(parser: PParser, parsing: TParamEntityParsing): cint{. + cdecl, importc: "XML_SetParamEntityParsing", dynlib: expatDll.} +# If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then +# XML_GetErrorCode returns information about the error. +# + +proc GetErrorCode*(parser: PParser): TError{.cdecl, importc: "XML_GetErrorCode", + dynlib: expatDll.} +# These functions return information about the current parse +# location. They may be called from any callback called to report +# some parse event; in this case the location is the location of the +# first of the sequence of characters that generated the event. When +# called from callbacks generated by declarations in the document +# prologue, the location identified isn't as neatly defined, but will +# be within the relevant markup. When called outside of the callback +# functions, the position indicated will be just past the last parse +# event (regardless of whether there was an associated callback). +# +# They may also be called after returning from a call to XML_Parse +# or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then +# the location is the location of the character at which the error +# was detected; otherwise the location is the location of the last +# parse event, as described above. +# + +proc GetCurrentLineNumber*(parser: PParser): int{.cdecl, + importc: "XML_GetCurrentLineNumber", dynlib: expatDll.} +proc GetCurrentColumnNumber*(parser: PParser): int{.cdecl, + importc: "XML_GetCurrentColumnNumber", dynlib: expatDll.} +proc GetCurrentByteIndex*(parser: PParser): int{.cdecl, + importc: "XML_GetCurrentByteIndex", dynlib: expatDll.} +# Return the number of bytes in the current event. +# Returns 0 if the event is in an internal entity. +# + +proc GetCurrentByteCount*(parser: PParser): cint{.cdecl, + importc: "XML_GetCurrentByteCount", dynlib: expatDll.} +# If XML_CONTEXT_BYTES is defined, returns the input buffer, sets +# the integer pointed to by offset to the offset within this buffer +# of the current parse position, and sets the integer pointed to by size +# to the size of this buffer (the number of input bytes). Otherwise +# returns a NULL pointer. Also returns a NULL pointer if a parse isn't +# active. +# +# NOTE: The character pointer returned should not be used outside +# the handler that makes the call. +# + +proc GetInputContext*(parser: PParser, offset: ptr cint, size: ptr cint): cstring{. + cdecl, importc: "XML_GetInputContext", dynlib: expatDll.} +# Frees the content model passed to the element declaration handler + +proc FreeContentModel*(parser: PParser, model: ptr TContent){.cdecl, + importc: "XML_FreeContentModel", dynlib: expatDll.} +# Exposing the memory handling functions used in Expat + +proc MemMalloc*(parser: PParser, size: int): pointer{.cdecl, + importc: "XML_MemMalloc", dynlib: expatDll.} +proc MemRealloc*(parser: PParser, p: pointer, size: int): pointer{.cdecl, + importc: "XML_MemRealloc", dynlib: expatDll.} +proc MemFree*(parser: PParser, p: pointer){.cdecl, importc: "XML_MemFree", + dynlib: expatDll.} +# Frees memory used by the parser. + +proc ParserFree*(parser: PParser){.cdecl, importc: "XML_ParserFree", + dynlib: expatDll.} +# Returns a string describing the error. + +proc ErrorString*(code: TError): cstring{.cdecl, importc: "XML_ErrorString", + dynlib: expatDll.} +# Return a string containing the version number of this expat + +proc ExpatVersion*(): cstring{.cdecl, importc: "XML_ExpatVersion", + dynlib: expatDll.} +type + TExpat_Version*{.pure, final.} = object + major*: cint + minor*: cint + micro*: cint + + +# Return an XML_Expat_Version structure containing numeric version +# number information for this version of expat. +# + +proc ExpatVersionInfo*(): TExpat_Version{.cdecl, + importc: "XML_ExpatVersionInfo", dynlib: expatDll.} +# Added in Expat 1.95.5. + +type + TFeatureEnum* = enum + FEATURE_END = 0, FEATURE_UNICODE, FEATURE_UNICODE_WCHAR_T, FEATURE_DTD, + FEATURE_CONTEXT_BYTES, FEATURE_MIN_SIZE, FEATURE_SIZEOF_XML_CHAR, + FEATURE_SIZEOF_XML_LCHAR, FEATURE_NS, FEATURE_LARGE_SIZE # Additional features must be added to the end of this enum. + TFeature*{.pure, final.} = object + feature*: TFeatureEnum + name*: cstring + value*: int + + +proc GetFeatureList*(): ptr TFeature{.cdecl, importc: "XML_GetFeatureList", + dynlib: expatDll.} +# Expat follows the GNU/Linux convention of odd number minor version for +# beta/development releases and even number minor version for stable +# releases. Micro is bumped with each release, and set to 0 with each +# change to major or minor version. +# + +const + MAJOR_VERSION* = 2 + MINOR_VERSION* = 0 + MICRO_VERSION* = 1 diff --git a/rod/astalgo.nim b/rod/astalgo.nim index f3e573d84..596531d0c 100755 --- a/rod/astalgo.nim +++ b/rod/astalgo.nim @@ -739,7 +739,6 @@ proc IdTablePut(t: var TIdTable, key: PIdObj, val: PObject) = inc(t.counter) proc writeIdNodeTable(t: TIdNodeTable) = - var h: THash nil proc IdNodeTableRawGet(t: TIdNodeTable, key: PIdObj): int = diff --git a/rod/c2nim/c2nim.nim b/rod/c2nim/c2nim.nim index fd1e227df..f1cb05920 100755 --- a/rod/c2nim/c2nim.nim +++ b/rod/c2nim/c2nim.nim @@ -12,7 +12,7 @@ import clex, cparse const - Version = "0.8.10" + Version = NimrodVersion Usage = """ c2nim - C to Nimrod source converter (c) 2010 Andreas Rumpf @@ -29,6 +29,8 @@ Options: --suffix:SUFFIX strip suffix for the generated Nimrod identifiers (multiple --suffix options are supported) --skipinclude do not convert ``#include`` to ``import`` + --typeprefixes generate ``T`` and ``P`` type prefixes + --skipcomments do not copy comments -v, --version write c2nim's version -h, --help show this help """ diff --git a/rod/c2nim/cparse.nim b/rod/c2nim/cparse.nim index 28cad2805..de2355bba 100755 --- a/rod/c2nim/cparse.nim +++ b/rod/c2nim/cparse.nim @@ -11,7 +11,7 @@ ## It translates a C source file into a Nimrod AST. Then the renderer can be ## used to convert the AST to its text representation. -## XXX cleanup of declaration handling. Standalone enums. +# XXX cleanup of declaration handling. import os, llstream, rnimsyn, clex, idents, strutils, pegs, ast, astalgo, msgs, @@ -22,7 +22,9 @@ type pfRefs, ## use "ref" instead of "ptr" for C's typ* pfCDecl, ## annotate procs with cdecl pfStdCall, ## annotate procs with stdcall - pfSkipInclude ## skip all ``#include`` + pfSkipInclude, ## skip all ``#include`` + pfTypePrefixes, ## all generated types start with 'T' or 'P' + pfSkipComments ## do not generate comments TMacro {.final.} = object name: string @@ -33,8 +35,10 @@ type flags: set[TParserFlag] prefixes, suffixes: seq[string] mangleRules: seq[tuple[pattern: TPeg, frmt: string]] + privateRules: seq[TPeg] dynlibSym, header: string macros: seq[TMacro] + toMangle: PStringTable PParserOptions* = ref TParserOptions TParser* {.final.} = object @@ -53,9 +57,11 @@ proc newParserOptions*(): PParserOptions = result.suffixes = @[] result.macros = @[] result.mangleRules = @[] + result.privateRules = @[] result.flags = {} result.dynlibSym = "" result.header = "" + result.toMangle = newStringTable() proc setOption*(parserOptions: PParserOptions, key: string, val=""): bool = result = true @@ -68,6 +74,8 @@ proc setOption*(parserOptions: PParserOptions, key: string, val=""): bool = of "prefix": parserOptions.prefixes.add(val) of "suffix": parserOptions.suffixes.add(val) of "skipinclude": incl(parserOptions.flags, pfSkipInclude) + of "typeprefixes": incl(parserOptions.flags, pfTypePrefixes) + of "skipcomments": incl(parserOptions.flags, pfSkipComments) else: result = false proc ParseUnit*(p: var TParser): PNode @@ -190,8 +198,9 @@ proc parLineInfo(p: TParser): TLineInfo = proc skipComAux(p: var TParser, n: PNode) = if (n != nil): - if n.comment == nil: n.comment = p.tok.s - else: add(n.comment, "\n" & p.tok.s) + if pfSkipComments notin p.options.flags: + if n.comment == nil: n.comment = p.tok.s + else: add(n.comment, "\n" & p.tok.s) else: parMessage(p, warnCommentXIgnored, p.tok.s) getTok(p) @@ -257,20 +266,31 @@ proc newIdentNodeP(ident: PIdent, p: TParser): PNode = proc newIdentNodeP(ident: string, p: TParser): PNode = result = newIdentNodeP(getIdent(ident), p) +proc mangleRules(s: string, p: TParser): string = + block mangle: + for pattern, frmt in items(p.options.mangleRules): + if s.match(pattern): + result = s.replace(pattern, frmt) + break mangle + block prefixes: + for prefix in items(p.options.prefixes): + if s.startsWith(prefix): + result = s.copy(prefix.len) + break prefixes + result = s + block suffixes: + for suffix in items(p.options.suffixes): + if result.endsWith(suffix): + setLen(result, result.len - suffix.len) + break suffixes + proc mangleName(s: string, p: TParser): string = - for pattern, frmt in items(p.options.mangleRules): - if s.match(pattern): - return s.replace(pattern, frmt) - block prefixes: - for prefix in items(p.options.prefixes): - if s.startsWith(prefix): - result = s.copy(prefix.len) - break prefixes - result = s - for suffix in items(p.options.suffixes): - if result.endsWith(suffix): - setLen(result, result.len - suffix.len) - break + if p.options.toMangle.hasKey(s): result = p.options.toMangle[s] + else: result = mangleRules(s, p) + +proc isPrivate(s: string, p: TParser): bool = + for pattern in items(p.options.privateRules): + if s.match(pattern): return true proc mangledIdent(ident: string, p: TParser): PNode = result = newNodeP(nkIdent, p) @@ -293,16 +313,16 @@ proc addImportToPragma(pragmas: PNode, ident: string, p: TParser) = else: addSon(pragmas, newIdentStrLitPair("header", p.options.header, p)) -proc exportSym(p: TParser, i: PNode): PNode = +proc exportSym(p: TParser, i: PNode, origName: string): PNode = assert i.kind == nkIdent - if p.scopeCounter == 0: + if p.scopeCounter == 0 and not isPrivate(origName, p): result = newNodeI(nkPostfix, i.info) addSon(result, newIdentNode(getIdent("*"), i.info), i) else: result = i proc varIdent(ident: string, p: TParser): PNode = - result = exportSym(p, mangledIdent(ident, p)) + result = exportSym(p, mangledIdent(ident, p), ident) if p.scopeCounter > 0: return if p.options.dynlibSym.len > 0 or p.options.header.len > 0: var a = result @@ -313,7 +333,7 @@ proc varIdent(ident: string, p: TParser): PNode = addImportToPragma(pragmas, ident, p) proc fieldIdent(ident: string, p: TParser): PNode = - result = exportSym(p, mangledIdent(ident, p)) + result = exportSym(p, mangledIdent(ident, p), ident) if p.scopeCounter > 0: return if p.options.header.len > 0: var a = result @@ -340,8 +360,30 @@ proc skipIdent(p: var TParser): PNode = proc skipIdentExport(p: var TParser): PNode = expectIdent(p) - result = exportSym(p, mangledIdent(p.tok.s, p)) + result = exportSym(p, mangledIdent(p.tok.s, p), p.tok.s) getTok(p, result) + +proc skipTypeIdentExport(p: var TParser, prefix='T'): PNode = + expectIdent(p) + var n = prefix & mangleName(p.tok.s, p) + p.options.toMangle[p.tok.s] = n + var i = newNodeP(nkIdent, p) + i.ident = getIdent(n) + result = exportSym(p, i, p.tok.s) + getTok(p, result) + +proc markTypeIdent(p: var TParser, typ: PNode) = + if pfTypePrefixes in p.options.flags: + var prefix = "" + if typ == nil: + prefix = "T" + else: + var t = typ + while t != nil and t.kind in {nkVarTy, nkPtrTy, nkRefTy}: + prefix.add('P') + t = t.sons[0] + expectIdent(p) + p.options.toMangle[p.tok.s] = prefix & mangleRules(p.tok.s, p) # --------------- parser ----------------------------------------------------- # We use this parsing rule: If it looks like a declaration, it is one. This @@ -394,12 +436,13 @@ proc typeAtom(p: var TParser): PNode = elif isIntType(p.tok.s): var x = "c" & p.tok.s getTok(p, nil) - while p.tok.xkind == pxSymbol and (isIntType(p.tok.s) or p.tok.s == "char"): + while p.tok.xkind == pxSymbol and + (isIntType(p.tok.s) or p.tok.s == "char"): add(x, p.tok.s) getTok(p, nil) - result = newIdentNodeP(x, p) + result = mangledIdent(x, p) else: - result = newIdentNodeP(p.tok.s, p) + result = mangledIdent(p.tok.s, p) getTok(p, result) proc newPointerTy(p: TParser, typ: PNode): PNode = @@ -528,7 +571,7 @@ proc parseStructBody(p: var TParser, isUnion: bool, proc structPragmas(p: TParser, name: PNode, origName: string): PNode = assert name.kind == nkIdent result = newNodeP(nkPragmaExpr, p) - addson(result, exportSym(p, name)) + addson(result, exportSym(p, name, origName)) var pragmas = newNodep(nkPragma, p) addSon(pragmas, newIdentNodeP("pure", p), newIdentNodeP("final", p)) if p.options.header.len > 0: @@ -541,7 +584,8 @@ proc enumPragmas(p: TParser, name: PNode): PNode = addson(result, name) var pragmas = newNodep(nkPragma, p) var e = newNodeP(nkExprColonExpr, p) - addSon(e, newIdentNodeP("size", p), newIntNodeP(nkIntLit, 4, p)) + # HACK: sizeof(cint) should be constructed as AST + addSon(e, newIdentNodeP("size", p), newIdentNodeP("sizeof(cint)", p)) addSon(pragmas, e) addSon(result, pragmas) @@ -608,6 +652,7 @@ proc parseFunctionPointerDecl(p: var TParser, rettyp: PNode): PNode = parseCallConv(p, pragmas) if p.tok.xkind == pxStar: getTok(p, params) else: parMessage(p, errTokenExpected, "*") + if p.inTypeDef > 0: markTypeIdent(p, nil) var name = skipIdentExport(p) eat(p, pxParRi, name) parseFormalParams(p, params, pragmas) @@ -633,17 +678,18 @@ proc otherTypeDef(p: var TParser, section, typ: PNode) = case p.tok.xkind of pxParLe: # function pointer: typedef typ (*name)(); - getTok(p, nil) var x = parseFunctionPointerDecl(p, typ) name = x[0] t = x[2] of pxStar: # typedef typ *b; t = pointer(p, typ) + markTypeIdent(p, t) name = skipIdentExport(p) else: # typedef typ name; t = typ + markTypeIdent(p, t) name = skipIdentExport(p) t = parseTypeSuffix(p, t) addTypeDef(section, name, t) @@ -652,6 +698,7 @@ proc parseTrailingDefinedTypes(p: var TParser, section, typ: PNode) = while p.tok.xkind == pxComma: getTok(p, nil) var newTyp = pointer(p, typ) + markTypeIdent(p, newTyp) var newName = skipIdentExport(p) newTyp = parseTypeSuffix(p, newTyp) addTypeDef(section, newName, newTyp) @@ -678,11 +725,13 @@ proc parseTypedefStruct(p: var TParser, result: PNode, isUnion: bool) = if p.tok.xkind == pxCurlyLe: var t = parseStruct(p, isUnion) var origName = p.tok.s + markTypeIdent(p, nil) var name = skipIdent(p) addTypeDef(result, structPragmas(p, name, origName), t) parseTrailingDefinedTypes(p, result, name) elif p.tok.xkind == pxSymbol: # name to be defined or type "struct a", we don't know yet: + markTypeIdent(p, nil) var origName = p.tok.s var nameOrType = skipIdent(p) case p.tok.xkind @@ -691,6 +740,7 @@ proc parseTypedefStruct(p: var TParser, result: PNode, isUnion: bool) = if p.tok.xkind == pxSymbol: # typedef struct tagABC {} abc, *pabc; # --> abc is a better type name than tagABC! + markTypeIdent(p, nil) var origName = p.tok.s var name = skipIdent(p) addTypeDef(result, structPragmas(p, name, origName), t) @@ -716,11 +766,15 @@ proc parseTypedefEnum(p: var TParser, result: PNode) = getTok(p, result) var t = enumFields(p) eat(p, pxCurlyRi, t) + var origName = p.tok.s + markTypeIdent(p, nil) var name = skipIdent(p) - addTypeDef(result, enumPragmas(p, exportSym(p, name)), t) + addTypeDef(result, enumPragmas(p, exportSym(p, name, origName)), t) parseTrailingDefinedTypes(p, result, name) elif p.tok.xkind == pxSymbol: # name to be defined or type "enum a", we don't know yet: + markTypeIdent(p, nil) + var origName = p.tok.s var nameOrType = skipIdent(p) case p.tok.xkind of pxCurlyLe: @@ -730,11 +784,14 @@ proc parseTypedefEnum(p: var TParser, result: PNode) = if p.tok.xkind == pxSymbol: # typedef enum tagABC {} abc, *pabc; # --> abc is a better type name than tagABC! + markTypeIdent(p, nil) + var origName = p.tok.s var name = skipIdent(p) - addTypeDef(result, enumPragmas(p, exportSym(p, name)), t) + addTypeDef(result, enumPragmas(p, exportSym(p, name, origName)), t) parseTrailingDefinedTypes(p, result, name) else: - addTypeDef(result, enumPragmas(p, exportSym(p, nameOrType)), t) + addTypeDef(result, + enumPragmas(p, exportSym(p, nameOrType, origName)), t) of pxSymbol: # typedef enum a a? if mangleName(p.tok.s, p) == nameOrType.ident.s: @@ -862,7 +919,7 @@ proc declaration(p: var TParser): PNode = addSon(pragmas, newIdentNodeP("cdecl", p)) elif pfStdcall in p.options.flags: addSon(pragmas, newIdentNodeP("stdcall", p)) - addSon(result, exportSym(p, name), nil) # no generics + addSon(result, exportSym(p, name, origName), nil) # no generics addSon(result, params, pragmas) case p.tok.xkind of pxSemicolon: @@ -884,9 +941,11 @@ proc createConst(name, typ, val: PNode, p: TParser): PNode = addSon(result, name, typ, val) proc enumSpecifier(p: var TParser): PNode = + saveContext(p) getTok(p, nil) # skip "enum" case p.tok.xkind of pxCurlyLe: + closeContext(p) # make a const section out of it: result = newNodeP(nkConstSection, p) getTok(p, result) @@ -909,17 +968,31 @@ proc enumSpecifier(p: var TParser): PNode = eat(p, pxCurlyRi, result) eat(p, pxSemicolon) of pxSymbol: + var origName = p.tok.s + markTypeIdent(p, nil) result = skipIdent(p) - if p.tok.xkind == pxCurlyLe: + case p.tok.xkind + of pxCurlyLe: + closeContext(p) var name = result # create a type section containing the enum result = newNodeP(nkTypeSection, p) var t = newNodeP(nkTypeDef, p) getTok(p, t) var e = enumFields(p) - addSon(t, exportSym(p, name), nil, e) # nil for generic params + addSon(t, exportSym(p, name, origName), nil, e) # nil for generic params addSon(result, t) + eat(p, pxCurlyRi, result) + eat(p, pxSemicolon) + of pxSemicolon: + # just ignore ``enum X;`` for now. + closeContext(p) + getTok(p, nil) + else: + backtrackContext(p) + result = declaration(p) else: + closeContext(p) parMessage(p, errTokenExpected, "{") # Expressions @@ -1415,9 +1488,10 @@ proc parseStandaloneStruct(p: var TParser, isUnion: bool): PNode = getTok(p, result) # skip "struct" or "union" var origName = "" if p.tok.xkind == pxSymbol: + markTypeIdent(p, nil) origName = p.tok.s getTok(p, result) - if p.tok.xkind == pxCurlyLe: + if p.tok.xkind in {pxCurlyLe, pxSemiColon}: if origName.len > 0: var name = mangledIdent(origName, p) var t = parseStruct(p, isUnion) diff --git a/rod/c2nim/cpp.nim b/rod/c2nim/cpp.nim index dc4e7249e..5f304e1f8 100755 --- a/rod/c2nim/cpp.nim +++ b/rod/c2nim/cpp.nim @@ -25,7 +25,8 @@ proc skipLine(p: var TParser) = proc parseDefineBody(p: var TParser, tmplDef: PNode): string = if p.tok.xkind == pxCurlyLe or - (p.tok.xkind == pxSymbol and (declKeyword(p.tok.s) or stmtKeyword(p.tok.s))): + (p.tok.xkind == pxSymbol and ( + declKeyword(p.tok.s) or stmtKeyword(p.tok.s))): addSon(tmplDef, statement(p)) result = "stmt" elif p.tok.xkind in {pxLineComment, pxNewLine}: @@ -272,22 +273,25 @@ proc parseIfDir(p: var TParser): PNode = eatNewLine(p, nil) parseIfDirAux(p, result) -proc parseMangleDir(p: var TParser) = +proc parsePegLit(p: var TParser): TPeg = var col = getColumn(p.lex) + 2 getTok(p) if p.tok.xkind != pxStrLit: ExpectIdent(p) try: - var pattern = parsePeg( - input = p.tok.s, + result = parsePeg( + input = if p.tok.xkind == pxStrLit: p.tok.s else: escapePeg(p.tok.s), filename = p.lex.filename, line = p.lex.linenumber, col = col) getTok(p) - if p.tok.xkind != pxStrLit: ExpectIdent(p) - p.options.mangleRules.add((pattern, p.tok.s)) - getTok(p) except EInvalidPeg: parMessage(p, errUser, getCurrentExceptionMsg()) + +proc parseMangleDir(p: var TParser) = + var pattern = parsePegLit(p) + if p.tok.xkind != pxStrLit: ExpectIdent(p) + p.options.mangleRules.add((pattern, p.tok.s)) + getTok(p) eatNewLine(p, nil) proc parseDir(p: var TParser): PNode = @@ -298,7 +302,7 @@ proc parseDir(p: var TParser): PNode = of "ifdef": result = parseIfdef(p) of "ifndef": result = parseIfndef(p) of "if": result = parseIfDir(p) - of "cdecl", "stdcall", "ref", "skipinclude": + of "cdecl", "stdcall", "ref", "skipinclude", "typeprefixes", "skipcomments": discard setOption(p.options, p.tok.s) getTok(p) eatNewLine(p, nil) @@ -315,6 +319,10 @@ proc parseDir(p: var TParser): PNode = var L = p.options.macros.len setLen(p.options.macros, L+1) parseDef(p, p.options.macros[L]) + of "private": + var pattern = parsePegLit(p) + p.options.privateRules.add(pattern) + eatNewLine(p, nil) else: # ignore unimportant/unknown directive ("undef", "pragma", "error") skipLine(p) diff --git a/rod/c2nim/manual.txt b/rod/c2nim/manual.txt index bb89c9567..7aa8b557b 100755 --- a/rod/c2nim/manual.txt +++ b/rod/c2nim/manual.txt @@ -1,9 +1,9 @@ ================================= c2nim User's manual ================================= - -:Author: Andreas Rumpf -:Version: 0.8.10 + +:Author: Andreas Rumpf +:Version: |nimrodversion| .. contents:: @@ -211,6 +211,47 @@ identifier should be converted: .. code-block:: C #mangle "'GTK_'{.*}" "TGtk$1" +For convenience the PEG pattern and the replacement can be a single identifiers +too, there is no need to quote them: + +.. code-block:: C + #mangle ssize_t int + // is short for: + #mangle "'ssize_t'" "int" + + +``#private`` directive +---------------------- + +By default c2nim marks every top level identifier (proc name, variable, etc.) +as exported (the export marker is ``*`` in Nimrod). With the ``#private`` +directive identifiers can be marked as private so that the resulting Nimrod +module does not export them. The ``#private`` directive takes a PEG pattern: + +.. code-block:: C + #private "@('_'!.)" // all identifiers ending in '_' are private + +Note: The pattern refers to the original C identifiers, not to the resulting +identifiers after mangling! + + +``#skipcomments`` directive +--------------------------- +**Note**: There is also a ``--skipcomments`` command line option that can be +used for the same purpose. + +The ``#skipcomments`` directive can be put into the C code to make c2nim +ignore comments and not copy them into the generated Nimrod file. + + +``#typeprefixes`` directive +--------------------------- +**Note**: There is also a ``--typeprefixes`` command line option that can be +used for the same purpose. + +The ``#typeprefixes`` directive can be put into the C code to make c2nim +generate the ``T`` or ``P`` prefix for every defined type. + ``#def`` directive ------------------ diff --git a/rod/c2nim/tests/systest.c b/rod/c2nim/tests/systest.c index b2b7646bb..7f689c002 100755 --- a/rod/c2nim/tests/systest.c +++ b/rod/c2nim/tests/systest.c @@ -9,32 +9,64 @@ extern "C" { # endif #endif +#private expatDll + +#if !defined(expatDll) +# if defined(windows) +# define expatDll "expat.dll" +# elif defined(macosx) +# define expatDll "libexpat.dynlib" +# else +# define expatDll "libexpat.so(.1|)" +# endif +#endif + +#mangle "'XML_'{.*}" "$1" +#private "'XML_ParserStruct'" + +#mangle cunsignedint cint + +unsigned int uiVar; + +#private "@('_'!.)" +unsigned int myPrivateVar__; + + +struct XML_ParserStruct; + +#def XMLCALL __cdecl + +typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData, + const XML_Char *name, + XML_Content *model); + + void* x; void* fn(void); void (*fn)(void); void* (*fn)(void); void* (*fn)(void*); -/* - * Very ugly real world code ahead: - */ +/* + * Very ugly real world code ahead: + */ #def JMETHOD(rettype, name, params) rettype (*name) params - -typedef struct cjpeg_source_struct * cjpeg_source_ptr; - -struct cjpeg_source_struct { - JMETHOD(void, start_input, (j_compress_ptr cinfo, - cjpeg_source_ptr sinfo)); - JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo, - cjpeg_source_ptr sinfo)); - JMETHOD(void, finish_input, (j_compress_ptr cinfo, - cjpeg_source_ptr sinfo)); - - FILE *input_file; - - JSAMPARRAY buffer; - JDIMENSION buffer_height; + +typedef struct cjpeg_source_struct * cjpeg_source_ptr; + +struct cjpeg_source_struct { + JMETHOD(void, start_input, (j_compress_ptr cinfo, + cjpeg_source_ptr sinfo)); + JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo, + cjpeg_source_ptr sinfo)); + JMETHOD(void, finish_input, (j_compress_ptr cinfo, + cjpeg_source_ptr sinfo)); + + FILE *input_file; + + JSAMPARRAY buffer; + JDIMENSION buffer_height; }; // Test standalone structs: diff --git a/todo.txt b/todo.txt index 19a6a7d06..e0036e171 100755 --- a/todo.txt +++ b/todo.txt @@ -1,6 +1,7 @@ For version 0.8.10 ================== +- accurate file/line information - exception propagation across DLLs - fix exception handling - fix implicit generic routines @@ -21,7 +22,6 @@ Bugs counting is wrong; try to reproduce this in the GC test - the parser allows empty object case branches - SDL event handling -- accurate file/line information To implement diff --git a/web/news.txt b/web/news.txt index b625ba209..ec136b66f 100755 --- a/web/news.txt +++ b/web/news.txt @@ -60,6 +60,7 @@ Additions for user defined pragmas. - The standard library can be built as a DLL. Generating DLLs has been improved. +- Added ``expat`` module. 2010-03-14 Version 0.8.8 released diff --git a/web/nimrod.ini b/web/nimrod.ini index 80080107e..059e6e38c 100755 --- a/web/nimrod.ini +++ b/web/nimrod.ini @@ -36,7 +36,8 @@ srcdoc: "pure/ropes;pure/unidecode/unidecode;pure/xmldom;pure/xmldomparser" srcdoc: "pure/xmlparser;pure/htmlparser;pure/xmltree;pure/colors;impure/graphics" webdoc: "wrappers/libcurl;pure/md5;wrappers/mysql;wrappers/iup" -webdoc: "wrappers/sqlite3;wrappers/python;wrappers/tcl" +webdoc: "wrappers/sqlite3;wrappers/postgres;wrappers/tinyc" +webdoc: "wrappers/python;wrappers/tcl" webdoc: "posix/posix;wrappers/odbcsql;impure/dialogs" webdoc: "wrappers/zip/zlib;wrappers/zip/libzip" |