mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-04-18 21:40:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

c2nim: new features & bugfixes

Browse Source
This commit is contained in:
Andreas Rumpf
2010-08-11 23:13:11 +02:00
parent 040c57f0a5
commit afbff2d504
12 changed files with 1262 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

260
doc/lib.txt
View File

@@ -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.
Regular expressions
-------------------
* `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.
* `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,96 +256,28 @@ 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.
* `cairo <cairo.html>`_
Wrapper for the cairo library.
* `cairoft <cairoft.html>`_
Wrapper for the cairoft library.
* `cairowin32 <cairowin32.html>`_
Wrapper for the cairowin32 library.
* `cairoxlib <cairoxlib.html>`_
Wrapper for the cairoxlib library.
* `atk <atk.html>`_
Wrapper for the atk library.
* `gdk2 <gdk2.html>`_
Wrapper for the gdk2 library.
* `gdk2pixbuf <gdk2pixbuf.html>`_
Wrapper for the gdk2pixbuf library.
* `gdkglext <gdkglext.html>`_
Wrapper for the gdkglext library.
* `glib2 <glib2.html>`_
Wrapper for the glib2 library.
* `gtk2 <gtk2.html>`_
Wrapper for the gtk2 library.
* `gtkglext <gtkglext.html>`_
Wrapper for the gtkglext library.
* `gtkhtml <gtkhtml.html>`_
Wrapper for the gtkhtml library.
* `libglade2 <libglade2.html>`_
Wrapper for the libglade2 library.
* `pango <pango.html>`_
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.
* `lua <lua.html>`_
Part of the wrapper for Lua.
* `lualib <lualib.html>`_
Part of the wrapper for Lua.
* `lauxlib <lauxlib.html>`_
Part of the wrapper for Lua.
* `tcl <tcl.html>`_
Wrapper for the TCL programming language.
* `python <python.html>`_
Wrapper for the Python programming language.
* `odbcsql <odbcsql.html>`_
interface to the ODBC driver.
* `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.
UNIX specific
-------------
* `posix <posix.html>`_
Contains a wrapper for the POSIX standard.
* `cursorfont <cursorfont.html>`_
Part of the wrapper for X11.
* `keysym <keysym.html>`_
@@ -377,9 +316,126 @@ not contained in the distribution. You can then find them on the website.
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.
Graphics libraries
------------------
* `cairo <cairo.html>`_
Wrapper for the cairo library.
* `cairoft <cairoft.html>`_
Wrapper for the cairoft library.
* `cairowin32 <cairowin32.html>`_
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>`_
Wrapper for the gdk2 library.
* `gdk2pixbuf <gdk2pixbuf.html>`_
Wrapper for the gdk2pixbuf library.
* `gdkglext <gdkglext.html>`_
Wrapper for the gdkglext library.
* `glib2 <glib2.html>`_
Wrapper for the glib2 library.
* `gtk2 <gtk2.html>`_
Wrapper for the gtk2 library.
* `gtkglext <gtkglext.html>`_
Wrapper for the gtkglext library.
* `gtkhtml <gtkhtml.html>`_
Wrapper for the gtkhtml library.
* `libglade2 <libglade2.html>`_
Wrapper for the libglade2 library.
* `pango <pango.html>`_
Wrapper for the pango library.
* `pangoutils <pangoutils.html>`_
Wrapper for the pangoutils library.
* `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>`_
Part of the wrapper for Lua.
* `lauxlib <lauxlib.html>`_
Part of the wrapper for Lua.
* `tcl <tcl.html>`_
Wrapper for the TCL programming language.
* `python <python.html>`_
Wrapper for the Python programming language.
Data Compression and Archiving
------------------------------
* `zlib <zlib.html>`_
Wrapper for the zlib library.
* `libzip <libzip.html>`_
Interface to the `lib zip <http://www.nih.at/libzip/index.html>`_ library by
Dieter Baron and Thomas Klausner.

2
lib/system.nim
View File

@@ -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

877
lib/wrappers/expat.nim Normal file
View File

@@ -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

1
rod/astalgo.nim
View File

@@ -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 =

4
rod/c2nim/c2nim.nim
View File

@@ -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
"""

144
rod/c2nim/cparse.nim
View File

@@ -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)

24
rod/c2nim/cpp.nim
View File

@@ -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)

47
rod/c2nim/manual.txt
View File

@@ -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
------------------

68
rod/c2nim/tests/systest.c
View File

@@ -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:

2
todo.txt
View File

@@ -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

1
web/news.txt
View File

@@ -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

3
web/nimrod.ini
View File

@@ -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"