{
- description = "The ecere module contains the 2D Graphics, 3D Graphics, Graphical User Interface, Network and extended System APIs."
+ description = "The Ecere Runtime Library with support for 2D Graphics, 3D Graphics, Graphical User Interfaces, Networking and Platform Independence."
}
{
name = "ecere",
- description = "The ecere namespace is for Ecere APIs in general."
+ description = "Top level namespace for the Ecere library",
+ functions = [
+ {
+ "GetTranslatedString",
+ {
+ description = "Internationalization Suport (GNU gettext() equivalent)",
+ remarks = "Internationalizable strings in eC source code should be prefixed by a dollar sign e.g.: $\"Hello, World\".<br>These strings will automatically be collected into a translation template (.pot) which can be used with GNU gettext compatible tools.<br><br>The call to GetTranslatedString() is then done automatically by the compiler.",
+ parameters = [
+ {
+ "name",
+ {
+ description = "Module for which to load string",
+ position = 1
+ }
+ },
+ {
+ "string",
+ {
+ description = "String which should be looked up. This string will be returned if no matching translation is found.",
+ position = 2
+ }
+ },
+ {
+ "stringAndContext",
+ {
+ description = "String which should be looked up including a context, or null",
+ position = 3
+ }
+ }
+ ]
+ }
+ },
+ {
+ "LoadTranslatedStrings",
+ {
+ description = "Load Internationalized Strings for specific module",
+ remarks = "The call to LoadTranslatedString() is generated automatically by the symbol loader generator (ecs).",
+ parameters = [
+ {
+ "moduleName",
+ {
+ description = "Name of the module from which to load embedded translation strings (e.g. dynamic library); null for the application executable",
+ position = 1
+ }
+ },
+ {
+ "name",
+ {
+ description = "Name of the module for which to load translation strings",
+ position = 2
+ }
+ }
+ ]
+ }
+ },
+ {
+ "UnloadTranslatedStrings",
+ {
+ description = "Unload Internationalized Strings for specific module",
+ remarks = "The call to UnloadTranslatedString() is generated automatically by the symbol loader generator (ecs).",
+ parameters = [
+ {
+ "name",
+ {
+ description = "Name of the module whose translation strings should be freed",
+ position = 1
+ }
+ }
+ ]
+ }
+ }
+ ]
}
--- /dev/null
+{
+ description = "Structure to hold individual nodes stored within CustomAVLTree"
+}
--- /dev/null
+{
+ description = "Self-Balancing AVL Binary Tree template automatically wrapping keys of a given type within nodes (e.g. for key only dictionary)"
+}
--- /dev/null
+{
+ description = "Enumeration type describing access mode (e.g. public, private, static)"
+}
--- /dev/null
+{
+ description = "Base data type representing the measure of an angle, default unit is Radians"
+}
--- /dev/null
+{
+ description = "Node with both a name and a valu for used with deprecated BinaryTree AVL Tree implmentation"
+}
--- /dev/null
+{
+ description = "First class type represnting members of bit classes"
+}
--- /dev/null
+{
+ description = "Internal special container template to represent C arrays as eC Container"
+}
--- /dev/null
+{
+ description = "First class type representing data type objects (classes, structs, enums, bit classes, system data types, unit classes)"
+}
--- /dev/null
+{
+ description = "Base class for a library providing a plug-in for a particular class into the Ecere IDE's Object Designer"
+}
--- /dev/null
+{
+ description = "First class type representing a class-wide property"
+}
--- /dev/null
+{
+ description = "Implementation of a specific argument for templatization",
+ fields = [
+ {
+ "dataTypeClass",
+ {
+ description = "(For type parameters)"
+ }
+ },
+ {
+ "dataTypeString",
+ {
+ description = "(For type parameters)"
+ }
+ },
+ {
+ "expression",
+ {
+ description = "(For expression parameters)"
+ }
+ },
+ {
+ "member",
+ {
+ description = "(For member identifier parameters)"
+ }
+ },
+ {
+ "memberString",
+ {
+ description = "(For identifier parameters)"
+ }
+ },
+ {
+ "method",
+ {
+ description = "(For method identifier parameters)"
+ }
+ },
+ {
+ "prop",
+ {
+ description = "(For property identifier parameters)"
+ }
+ }
+ ]
+}
--- /dev/null
+{
+ description = "Definition of a parameter for class templates",
+ fields = [
+ {
+ "dataTypeString",
+ {
+ description = "(For type parameters)"
+ }
+ },
+ {
+ "defaultArg",
+ {
+ description = "Default argument value for this parameter"
+ }
+ },
+ {
+ "memberType",
+ {
+ description = "(For identifier parameters)"
+ }
+ },
+ {
+ "name",
+ {
+ description = "Name for this parameter"
+ }
+ },
+ {
+ "next",
+ {
+ description = "(link within parameters list)"
+ }
+ },
+ {
+ "prev",
+ {
+ description = "(link within parameters list)"
+ }
+ },
+ {
+ "type",
+ {
+ description = "Type for this parameter"
+ }
+ }
+ ]
+}
--- /dev/null
+{
+ description = "Enumeration type identifying the particular kind of data type a class consists in"
+}
--- /dev/null
+{
+ description = "Base Container template class"
+}
--- /dev/null
+{
+ description = "Self-Balancing AVL Binary Tree template allowing to specify custom nodes (e.g to directly store data within them)"
+}
--- /dev/null
+{
+ description = "First class type representing members of structs and classes"
+}
--- /dev/null
+{
+ description = "Enumeration type to identify the type of a DataMember (regular, inner union or inner struct)"
+}
--- /dev/null
+{
+ description = "Data type to hold any core C/eC data type from 8 to 64 bit"
+}
--- /dev/null
+{
+ description = "First class type representing a global definition (expression)"
+}
--- /dev/null
+{
+ description = "Base class of the Ecere IDE's Object Designer class"
+}
--- /dev/null
+{
+ description = "Internal type to store enumeration type values"
+}
--- /dev/null
+{
+ description = "First class type representing global functions (functions outside of structs/classes)"
+}
--- /dev/null
+{
+ description = "Data type representing Input/Output channels with ability to read and write data. Used for (de)serialization and a base class of File."
+}
--- /dev/null
+{
+ description = "Internal enumeration type to identify type of import"
+}
--- /dev/null
+{
+ description = "Iterator template to iterate within containers (except Map)"
+}
--- /dev/null
+{
+ description = "Generic type to represent an iterator's state (implementation is specific to container type)"
+}
--- /dev/null
+{
+ description = "Linkable element for use within a LinkList with an extra 64-bit data storage"
+}
--- /dev/null
+{
+ description = "Pair of previous and next links for use with a custom linkable type for LinkList"
+}
--- /dev/null
+{
+ description = "Doubly linked list templates allowing to specify custom nodes (e.g. to directly store data within them)"
+}
--- /dev/null
+{
+ description = "Doubly linked list template automatically wrapping elements of a given type within Link nodes"
+}
--- /dev/null
+{
+ description = "Linkable element for use within a LinkList"
+}
--- /dev/null
+{
+ description = "Associative array template implemented as an AVL tree of keys and value storage"
+}
--- /dev/null
+{
+ description = "Iterator template to iterate within a Map"
+}
--- /dev/null
+{
+ description = "Internal custom AVLNode type used by Map"
+}
--- /dev/null
+{
+ description = "First class type representing type methods"
+}
--- /dev/null
+{
+ description = "Enumeration type to identify virtual/non-virtual methods"
+}
--- /dev/null
+{
+ description = "First class type representing name space"
+}
--- /dev/null
+{
+ description = "Information about instance being edited / visualized in the Ecere IDE's Object Designer"
+}
--- /dev/null
+{
+ description = "Enumeration to identify a platform (Windows, Linux, Mac)"
+}
--- /dev/null
+{
+ description = "First class type representing property"
+}
--- /dev/null
+{
+ description = "Data type derived from IOChannel used for (de)serialization"
+}
--- /dev/null
+{
+ description = "Internal String data type used by Distributed Objects to (de)serialize String parameters"
+}
--- /dev/null
+{
+ description = "Linkable type to hold a list of sub-module handles"
+}
--- /dev/null
+{
+ description = "Enumeration identifying a type of member an indentifier templat parameter refer to (member, method or property)"
+}
--- /dev/null
+{
+ description = "Enumeration identifying the type of template parameter",
+ values = [
+ {
+ "expression",
+ {
+ description = "Parameter is an expression (e.g. LinkList::circ which can be true or false)"
+ }
+ },
+ {
+ "identifier",
+ {
+ description = "Parameter is an identifier representing a member of a class (e.g. LinkList::link)"
+ }
+ },
+ {
+ "type",
+ {
+ description = "Parameter is a type (most common)"
+ }
+ }
+ ]
+}
{
- name = "com"
+ name = "com",
+ functions = [
+ {
+ "CheckConsistency",
+ {
+ description = "Check consistency of MemoryGuard's memory blocks"
+ }
+ },
+ {
+ "CheckMemory",
+ {
+ description = "Run MemoryGuard checks (typically called on exit)"
+ }
+ }
+ ]
}
{
name = "Bitmap",
- description = "Provides access to an image added as a Resource to the Project.",
+ description = "Class reprsenting a rasterized 2D image in a number of formats. Once made device-dependent, the data is stored as a texture on the GPU for hardware- accelerated drivers.",
fields = [
{
"height",
{
name = "BitmapResource",
- description = "Handles the storage of a Bitmap, as well as many of the technical aspects, such as the DisplaySystem, loading and reloading the image as necessary, and changes in Resolution. BitmapResource associates the image to a particular window.",
+ description = "A class to automatically manag loading and unloading Bitmap objects",
usage = "Originally defined in the declaration section of code, typically within the class that will be using this resource.",
example = "class Form1 : Window<br>{<br> text = \"Form1\";<br> background = activeBorder;<br> borderStyle = fixed;<br> hasClose = true;<br> size = {640, 480};<br> BitmapResource image { \":image.png\", window = this };<br> void OnRedraw(Surface surface)<br> {<br> surface.Blit( image.bitmap, 0, 0, 0, 0, 20, 20 );<br> }<br>}",
remarks = "Very similar to the Bitmap class. In fact Bitmap could be said to be low level, while BitmapResource could be said to be a high level object.",
{
name = "Color",
- description = "Contains the three RGB values that make up a pixel of color.",
+ description = "A 32 bit bit class representing Red, Green and Blue from 0..255, with Blue stored in LSB.",
usage = "Used in the declaration section of code.",
example = "Color red = { r = 255 }; // High intensity red.\n"
"Color yellow = { 0xFFFF00 }; // High intensity yellow. r = 0xFF(255), g = 0xFF(255), b = 0x00(0)",
--- /dev/null
+{
+ description = "A 16 bit color bit class with 4 bits for each of Red, Green and Blue"
+}
--- /dev/null
+{
+ description = "A 16 bit color bit class with 5 bits for each of Red, Green and Blue"
+}
--- /dev/null
+{
+ description = "A 16 bit color bit class with 5 bits for Red, 6 bits for Green and 5 bits for Blue"
+}
--- /dev/null
+{
+ description = "A 32 bit bit class representing Alpha, Red, Green and Blue from 0..255, with Blue stored in LSB."
+}
--- /dev/null
+{
+ description = "A struct representing the Cyan, Magenta, Yellow, Black model such as used for printing"
+}
--- /dev/null
+{
+ description = "A struct representing the Hue, Saturation, Value model"
+}
--- /dev/null
+{
+ description = "A struct defining a color key to use for gradients"
+}
--- /dev/null
+{
+ description = "A struct represneting the Lab Color Model which is accurately reflects the human eye's color sensitivity"
+}
--- /dev/null
+{
+ description = "A floating point struct for storing Red, Green and Blue, typically ranging from 0.0f..1.0f"
+}
--- /dev/null
+{
+ description = "32 bit storage of Red, Green, Blue and Alpha as an array of 4 bytes (r,g,b,a)."
+}
--- /dev/null
+{
+ description = "A floating point struct for storing Red, Green and Blue and Alpha, typically ranging from 0.0f..1.0f"
+}
--- /dev/null
+{
+ description = "A collection of 6 images organized as a sky box for use with SkyBox and Environment Mapping."
+}
--- /dev/null
+{
+ description = "An enumeration of named colors"
+}
{
name = "Display",
+ description = "A class representing 2D and 3D video graphics output such as a top-level window",
methods = [
{
"Grab",
--- /dev/null
+{
+ description = "Base class for graphics drivers to implement Display and Surface capabilities"
+}
--- /dev/null
+{
+ description = "A class representing a display system provided by a graphics driver which can be shared among multiple Display"
+}
--- /dev/null
+{
+ description = "A driver-specific Font object implementation"
+}
{
name = "FontResource",
- description = "Used to store a Font resource to display text with.",
+ description = "A class to automatically manag loading and unloading Font objects",
properties = [
{
"bold",
--- /dev/null
+{
+ description = "Base class for automatically managing graphics resources such as bitmap and fonts"
+}
{
name = "Surface",
+ description = "The core graphics API class implementing immediate mode draw calls",
methods = [
{
"Blit",
{
name = "gfx",
- description = "The ecere::gfx namespace is for the 2D Graphics API."
+ description = "2D Graphics API: Text, Bitmaps, etc."
}
{
name = "drivers",
- description = "The ecere::gfx::drivers namespase if for what?"
+ description = "Namespace for graphics drivers implementing the DisplayDriver interface"
}
{
name = "gfx3D",
- description = "The ecere::gfx3D namespace is for the 3D Graphics API."
+ description = "3D Graphics API"
}
--- /dev/null
+{
+ description = "Collection of pre-defined 3D shapes"
+}
{
name = "Window",
- description = "The base class for any Window, and many Controls aswell. Contains many methods and properties that are inherited and used by these other Windows and Classes.",
+ description = "Base class for all GUI elements (controls, dialogs and forms)",
fields = [
{
"sbh",
{
"alphaBlend",
{
- description = "When true, applies Alpha Blending to the background of the Window. Used for transparency effects."
+ description = "Set to true to blend with the desktop environment's. Support & performance varies."
}
},
{
{
"background",
{
- description = "The Color of the Client Area.\n"
- "Example: background = { r = 53, g = 100, b = 203 };"
+ description = "Color the client area is filled with"
}
},
{
}
},
{
+ "caption",
+ {
+ description = "The text which should appear in the caption of this window. For forms/dialogs with title bars, this will appear in the title bar. For controls, this is typically the text which should appear in the label associated with th control through the 'labeledWindow' property."
+ }
+ },
+ {
"clickThrough",
{
description = "When true, this Window/Control redirects mouse clicks to its parent rather than processing the mouse clicks itself. Essentially, the mouse becomes invisible to this item."
{
"font",
{
-
+ description = "Default font used for rendering the text within this Window and its controls.."
}
},
{
}
},
{
+ "id",
+ {
+ description = "An integer id to uniquely identify the window (e.g. when sharing method implementations among multiple controls), or for storing arbitrary user data."
+ }
+ },
+ {
"isDocument",
{
description = "When true, this Window/Control would be treated as a document, enabling things like having the path show up in the Title Bar. \n"
{
"master",
{
- description = "Typically, the Master is the Controlling Window of the application. The Master receives all the messages.\n"
- "Example: master = this;"
+ description = "The owner of this Window which should receive notifications (e.g. if this Window is a control)."
}
},
{
{
"name",
{
- description = "This is the name of the instantiation. Typically this is only adjusted in the property editor.\n"
- "Example: name = \"editBox1\";\n"
- "or: EditBox editBox1;"
+ description = "(internal field for the Ecere IDE's Object Designer which matches the instance or class name)"
}
},
{
{
"opacity",
{
- description = "A real number between 0 and 1, setting how translucent a control is. 0 is completely transparent, and 1 is completely opaque.\n"
- "Example: opacity = 0.45;"
+ description = "A value between 0.0f and 1.0f specifying the opacity which wthich the client area's background will be filled using the background color."
}
},
{
"parent",
{
- description = "The Window which the current Window/Control belongs to.\n"
- "Example: parent = this;"
+ description = "The Window within whose client area this window is constrained."
}
},
{
{
"tabCycle",
{
- description = "When true, then it becomes possible to use the tab key to cycle through all of the children of this Window/Control. The order of cycling is determined by the order of instantiation.\n"
- "Note: If tabCycle is not true on the parent, then children with hotKeys set, will not be activated by pressing the hotKey, unless the parent is currently active."
+ description = "When true, then it becomes possible to use the tab key to cycle through all of the children of this Window/Control. The order of cycling is determined by the order of instantiation. Note: If tabCycle is not true on the parent, then children with hotKeys set, will not be activated by pressing the hotKey, unless the parent is currently active."
}
},
{
"text",
{
- description = "The title bar text for the Window. For other controls such as a Label or a Button, text is the descriptive text that the user sees.\n"
- "Example: text = \"This is a Window\";"
+ description = "Deprecated. Use 'caption'."
}
},
{
{
name = "gui",
- description = "The ecere::gui namespace is for the Graphical User Interface API."
+ description = "Graphical User Interface API"
}
{
name = "controls",
- description = "The ecere::gui::controls namespace is for GUI controls like Button or EditBox."
+ description = "Common Controls (Button, EditBox, ListBox...)"
}
{
name = "dialogs",
- description = "The ecere::gui::dialogs namespace is for GUI dialogs like MessageBox or FileDialog."
+ description = "Commong Dialogs (MessageBox, FileDialog...)"
}
{
name = "skins",
- description = "The ecere::gui::skins namespace is for skins that implement the look of the GUI."
+ description = "Skins defining and customizing the look & feel of the GUI"
}
--- /dev/null
+{
+ description = "Class used by Distributed Objects when instantiating a remote class"
+}
--- /dev/null
+{
+ description = "Class used by Distributed Objects to create remote objects on the server"
+}
--- /dev/null
+{
+ description = "Class used by Distributed Objects to handle communication on the server"
+}
--- /dev/null
+{
+ description = "Class instantiated by the user to host a Distributed Object Server"
+}
--- /dev/null
+{
+ description = "File Server implementation to which a client can connect with ConnectToFileServer()"
+}
--- /dev/null
+{
+ description = "Implementing an HTTP client as a File class"
+}
--- /dev/null
+{
+ description = "Network client file handle returned by ConnectToFileServer()"
+}
--- /dev/null
+{
+ description = "A base Packet class from which custom packet types can inherit"
+}
--- /dev/null
+{
+ description = "Socket class with Secure Sockets Layer Support"
+}
--- /dev/null
+{
+ description = "Class to host a TCP/IP service to which a Socket can connect"
+}
--- /dev/null
+{
+ description = "Main Class for Socket API (TCP/IP and UDP)"
+}
{
name = "net",
- description = "The ecere::net namespace is for the Network API."
+ description = "Networking API"
}
--- /dev/null
+{
+ description = "Directory Lister",
+ fields = [
+ {
+ "directory",
+ {
+ description = "Parent directory within which to list files"
+ }
+ },
+ {
+ "extensions",
+ {
+ description = "Extensions to include in results or null for all files"
+ }
+ }
+ ],
+ properties = [
+ {
+ "name",
+ {
+ description = "Name of current result"
+ }
+ },
+ {
+ "path",
+ {
+ description = "Path of current result"
+ }
+ },
+ {
+ "stats",
+ {
+ description = "Statistics of current result"
+ }
+ }
+ ],
+ methods = [
+ {
+ "Find",
+ {
+ description = "Find next directory ntry"
+ }
+ },
+ {
+ "Stop",
+ {
+ description = "Call if you interrupt the listing before Find() returns false"
+ }
+ }
+ ]
+}
{
name = "Point",
- description = "An x, y coordinate on the Cartesian plane.\n"
- "\n"
- "Most frequently a Point type is used in graphical application to refer to a pixel coordinate on the screen.",
+ description = "A struct with integer x, y components. Often used for screen coordinates (top-left corner represented as 0,0).",
usage = "Used in the declaration section of code.",
example = "Point coord = { 10, 30 } // equivalent to coord.x = 10, coord.y = 30",
also = "GeoPoint, Pointf, PolarPoint, Vector3D, Vector3Df",
--- /dev/null
+{
+ description = "A struct with floating-point x y components."
+}
{
name = "sys",
- description = "The ecere::sys namespace is for the extended System API.",
+ description = "Platform independent System API (Files, Multithreading, Unicode, ...)",
+ defines = [
+ {
+ "Pi",
+ {
+ description = "Ratio of a circle's circumference to its diameter; Measure of a half-circle angle in radians (180°)"
+ }
+ }
+ ],
functions = [
{
"GetRandom",
--- /dev/null
+{
+ description = "32 bit integer meant to hold Unicode code points ( 0x000000 - 0x10FFFF)"
+}
--- /dev/null
+{
+ description = "Rudimentary string type (resolved to a C 'char *') meant to hold a null-terminated string of characters. Ecere APIs taking a String or char * representing text expect UTF-8 encoding."
+}
--- /dev/null
+{
+ description = "The core eC runtime, either bundled within libecere or built as a library on its own",
+ defines = [
+ {
+ "fstrcmp",
+ {
+ description = "String comparison with run-time platform specific case sensitivity (case insensitive on Windows, sensitive otherwise)"
+ }
+ },
+ {
+ "strcmpi",
+ {
+ description = "Case insensitive string comparison"
+ }
+ },
+ {
+ "strnicmp",
+ {
+ description = "Case insensitive string comparison with maximum number of characters compared"
+ }
+ }
+ ],
+ functions = [
+ {
+ "acos",
+ {
+ description = "Arc Cosine"
+ }
+ },
+ {
+ "acosh",
+ {
+ description = "Hyperbolic Arc Cosine"
+ }
+ },
+ {
+ "asin",
+ {
+ description = "Arc Sine"
+ }
+ },
+ {
+ "asinh",
+ {
+ description = "Hyperbolic Arc Sine"
+ }
+ },
+ {
+ "atan",
+ {
+ description = "Arc Tangent"
+ }
+ },
+ {
+ "atan2",
+ {
+ description = "Arc Tangent from y, x components"
+ }
+ },
+ {
+ "atanh",
+ {
+ description = "Hyperbolic Arc Tangent"
+ }
+ },
+ {
+ "atof",
+ {
+ description = "Alphabetical to Float"
+ }
+ },
+ {
+ "atoi",
+ {
+ description = "Alphabetical to Int"
+ }
+ },
+ {
+ "ceil",
+ {
+ description = "Ceiling function (Smallest integral number greater or equal to)"
+ }
+ },
+ {
+ "cos",
+ {
+ description = "Cosine"
+ }
+ },
+ {
+ "cosh",
+ {
+ description = "Hyperbolic Cosine"
+ }
+ },
+ {
+ "exp",
+ {
+ description = "Exponential function (e^x where e = 2.71828...)"
+ }
+ },
+ {
+ "fabs",
+ {
+ description = "Absolute Value"
+ }
+ },
+ {
+ "floor",
+ {
+ description = "Flooring function (Greatest integral number smaller or equal to)"
+ }
+ },
+ {
+ "fmod",
+ {
+ description = "Modulo"
+ }
+ },
+ {
+ "fputs",
+ {
+ description = "Output string to a file (does not add a new line)"
+ }
+ },
+ {
+ "getenv",
+ {
+ description = "Return environment variable"
+ }
+ },
+ {
+ "isalnum",
+ {
+ description = "Is character alphanumeric?"
+ }
+ },
+ {
+ "isalpha",
+ {
+ description = "Is character alphabetical?"
+ }
+ },
+ {
+ "isblank",
+ {
+ description = "Is character blank?"
+ }
+ },
+ {
+ "isdigit",
+ {
+ description = "Is character digit?"
+ }
+ },
+ {
+ "islower",
+ {
+ description = "Is character lowercase?"
+ }
+ },
+ {
+ "isprint",
+ {
+ description = "Is character printable?"
+ }
+ },
+ {
+ "isspace",
+ {
+ description = "Is character a space?"
+ }
+ },
+ {
+ "isupper",
+ {
+ description = "Is character uppercase?"
+ }
+ },
+ {
+ "isxdigit",
+ {
+ description = "Is character an hexadecimal digit?"
+ }
+ },
+ {
+ "log",
+ {
+ description = "Natural logarithm"
+ }
+ },
+ {
+ "log10",
+ {
+ description = "Base-10 logarithm"
+ }
+ },
+ {
+ "memcmp",
+ {
+ description = "Compare memory"
+ }
+ },
+ {
+ "memcpy",
+ {
+ description = "Copy memory (cannot overlap)"
+ }
+ },
+ {
+ "memmove",
+ {
+ description = "Copy memory with potential overlap"
+ }
+ },
+ {
+ "memset",
+ {
+ description = "Fill memory with a repeated byte value"
+ }
+ },
+ {
+ "pow",
+ {
+ description = "Raise number to a power"
+ }
+ },
+ {
+ "printf",
+ {
+ description = "Classic C formatted output"
+ }
+ },
+ {
+ "puts",
+ {
+ description = "Output string to stdout (adds a new line)"
+ }
+ },
+ {
+ "qsort",
+ {
+ description = "Quick Sort algorithm for a C array, taking a comparison function"
+ }
+ },
+ {
+ "rename",
+ {
+ description = "Rename a file"
+ }
+ },
+ {
+ "sin",
+ {
+ description = "Sine"
+ }
+ },
+ {
+ "sinh",
+ {
+ description = "Hyperbolic Sine"
+ }
+ },
+ {
+ "snprintf",
+ {
+ description = "Formatted output to a string with maximum number of characters"
+ }
+ },
+ {
+ "sprintf",
+ {
+ description = "Formatted output to a string"
+ }
+ },
+ {
+ "sqrt",
+ {
+ description = "Square Root"
+ }
+ },
+ {
+ "strcasecmp",
+ {
+ description = "Case insensitive string comparison (System specific - use strcmpi() instead)"
+ }
+ },
+ {
+ "strcat",
+ {
+ description = "Concatenate a string to another"
+ }
+ },
+ {
+ "strchr",
+ {
+ description = "Search for a character in a string"
+ }
+ },
+ {
+ "strcmp",
+ {
+ description = "Case sensitive comparison of strings"
+ }
+ },
+ {
+ "strcpy",
+ {
+ description = "Copy a string to pre-allocated memory"
+ }
+ },
+ {
+ "strlen",
+ {
+ description = "Returns length of null-terminatd string"
+ }
+ },
+ {
+ "strlwr",
+ {
+ description = "Turn a string lowercase"
+ }
+ },
+ {
+ "strncasecmp",
+ {
+ description = "Case insensitive string comparison (System specific - use strnicmp() instead)"
+ }
+ },
+ {
+ "strncat",
+ {
+ description = "Concatenate a string to another with maximum number of characters"
+ }
+ },
+ {
+ "strncmp",
+ {
+ description = "Case sensitive comparison of strings with a maximum number of characters"
+ }
+ },
+ {
+ "strncpy",
+ {
+ description = "Copy a string to pre-allocated memory with a maximum number of characters"
+ }
+ },
+ {
+ "strstr",
+ {
+ description = "Search for the occurence of a string in another (case sensitive, see SearchString() for case insensitive)"
+ }
+ },
+ {
+ "strtod",
+ {
+ description = "Convert string to double"
+ }
+ },
+ {
+ "strtol",
+ {
+ description = "Convert string to long"
+ }
+ },
+ {
+ "strtoll",
+ {
+ description = "Convert string to long long"
+ }
+ },
+ {
+ "strtoul",
+ {
+ description = "Convert string to unsigned long"
+ }
+ },
+ {
+ "strtoull",
+ {
+ description = "Convert string to unsigned long long"
+ }
+ },
+ {
+ "strupr",
+ {
+ description = "Turn a string uppercase"
+ }
+ },
+ {
+ "system",
+ {
+ description = "Make a system call using the shell"
+ }
+ },
+ {
+ "tan",
+ {
+ description = "Tangent"
+ }
+ },
+ {
+ "tanh",
+ {
+ description = "Hyperbolic Tangent"
+ }
+ },
+ {
+ "tolower",
+ {
+ description = "Convert a character to lowercase"
+ }
+ },
+ {
+ "toupper",
+ {
+ description = "Convert a character to uppercase"
+ }
+ },
+ {
+ "vsnprintf",
+ {
+ description = "Output to a string variable arguments with a maximum number of characters"
+ }
+ },
+ {
+ "vsprintf",
+ {
+ description = "Output to a string variable arguments"
+ }
+ }
+ ]
+}
{
name = "bool",
- description = "An enumeration type, capable of storing only two values: true and false.\n"
- "\n"
- "Memory occupied: 32 bits(or 4 bytes)\n"
- "\n"
- "A bool variable is used for logical purposes, and is used almost exclusively for comparison operations. Ie) Is this statement true? Or is it false?",
+ description = "Boolean value (true or false) stored as a 32 bit unsigned integer",
usage = "Used in the declaration section of code, which is before any statements.",
example = "bool thisBool; // A stand alone declaration of a bool.\n"
"bool a, b; // Declaring two bools at the same time.\n"
{
name = "byte",
- description = "A byte type, is exactly what it's name implies, a data type which stores a single byte of information.\n"
- "\n"
- "Memory occupied: 8 bits(or 1 byte)\n"
- "\n"
- "Numerically, a byte will hold a decimal number between 0 and 255. A byte is frequently used in conjunction with bitwise operators(AND(&), OR(|), XOR(^) and NOT(~)) or bit collection classes.",
+ description = "An unsigned integer data type representing a single byte of data (equivalent to C 'unsigned char' and expected to be equivalent to C99 'uint8_t'). A byte can range from 0 to 255. Often used to allocate and address memory.",
usage = "Used in the declaration section of code, which is before any statements.",
example = "byte a = 3; // binary form: 00000011\n"
"byte b = 6; // binary form: 00000110\n"
{
name = "char *",
- description = "A pointer type to an array of chars.\n"
- "\n"
- "Memory Occupied: 8 bits (or 1 byte) per character.\n"
- "\n"
- "A char * will store any literal string of ASCII characters or UTF-8 characters, as well as any escape sequences.",
+ description = "Core C 'char *' data type, mostly equivalent to the String data type. Ecere APIs taking a String or char * representing text expect UTF-8 encoding.",
usage = "Used in the declaration section of code, which is before any statements. \n"
"\n"
"A variable declared as being a char * can be assigned any literal string which is enclosed between double quotation marks (\" \").\n"
{
name = "char",
- description = "Stores a single ASCII character.\n"
- "\n"
- "Memory occupied: 8 bits(or 1 byte)\n"
- "\n"
- "A char data type holds a decimal value between the range of -128 and 127. These integer values are used to refer to a particular alphanumeric character in the ASCII set.",
+ description = "Core C data type representing a single ASCII character (equivalent to C 'char' and expected to be signed and occupy 8 bits / 1 byte). A signed char can range from -127 to 127. On some platforms -128 is a valid value.",
usage = "Used in the declaration section of code, which is before any statements.\n"
"\n"
"A variable declared as being a char can be assigned any single character enclosed between two single quotes (' '), or an integer which is then translated to the ASCII character corresponding to that value, at output.",
--- /dev/null
+{
+ description = "Basic eC object type construct featuring a virtual method table, reference counting and runtime type information (unless inheriting from 'struct'). Class instances are always individually allocated on the heap."
+}
{
name = "double",
- description = "A double precision float data type.\n"
- "\n"
- "Memory occupied: 64 bits(or 8 bytes)\n"
- "\n"
- "A double data type holds a real number including the portion which follows the decimal point. The minimum precision for a double is 10 decimal digits. A doubles range is from 2.2250738585072014e-308 to 1.7976931348623158e+308.",
+ description = "Core C double precision floating-point real number data type. A double ranges from 2.2250738585072014e-308 to 1.7976931348623158e+308.",
usage = "Used in the declaration section of code, which is before any statements.",
example = "double aDouble; // A stand alone declaration of a double.\n"
"double a, b; // Declaring two doubles at the same time.\n"
--- /dev/null
+{
+ description = "Top level namespace for the Ecere library"
+}
--- /dev/null
+{
+ description = "The Application class. Can be inherited from to customize execution entry point",
+ remarks = "The Application class (or any of its derived class) should not be instantiated. A specific module (e.g. application or library) should derive at most one class from Application."
+}
--- /dev/null
+{
+ description = "Base class for 'class' data types containing virtual method table, runtime type information and reference count"
+}
--- /dev/null
+{
+ description = "First class type representing application or shared library module"
+}
--- /dev/null
+{
+ description = "Core eC Runtime Library (component object model enabling reflection in eC)"
+}
--- /dev/null
+{
+ description = "Platform independent System API (Files, Multithreading, Unicode, ...)"
+}
--- /dev/null
+{
+ description = "Core C and eC enumeration data type construct. eC enumeration values are context-sensitive, can be extended through inheritance, contain methods and properties, and are also a type without needing a 'typedef'."
+}
{
name = "float",
- description = "A float data type.\n"
- "\n"
- "Memory occupied: 32 bits(or 4 bytes)\n"
- "\n"
- "A float data type holds a real number including the portion which follows the decimal point. The minimum precision for a float is 6 decimal digits. A floats range is from 1.17549435082228750e-38 to 3.40282346638528860e+38.",
+ description = "Core C single precision floating-point real number data type. A float ranges from 1.17549435082228750e-38 to 3.40282346638528860e+38.",
usage = "Used in the declaration section of code, which is before any statements.",
example = "float aFloat; // A stand alone declaration of a float.\n"
"float a, b; // Declaring two floats at the same time.\n"
{
name = "int",
- description = "An integer data type. \n"
- "\n"
- "Memory occupied: 32 bits(or 4 bytes)\n"
- "\n"
- "An int data type holds a decimal value between the range of -2 exp 31 and 2 exp 31-1 (or -2,147,483,648 and 2,147,483,647).",
+ description = "Core C signed integer data type (expected to be equivalent to C99 'int32_t'). A signed 32 bit integer ranges from (-2,147,483,647 to 2,147,483,647. One some platform a negative value one less is valid.",
usage = "Used in the declaration section of code, which is before any statements.",
example = "int thisInt; // A stand alone declaration of an int.\n"
"int a, b; // Declaring two ints at the same time.\n"
{
name = "int64",
- description = "An integer data type.\n"
- "\n"
- "Memory occupied: 64 bits(or 8 bytes)\n"
- "\n"
- "An int64 data type holds a decimal value between the range of -2 exp 63 and 2 exp 63-1 (or -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807).",
+ description = "64 bit signed integer data type (equivalent of C99 'int64_t'). A 64 bit signed integer can range from - 2^63-1 to 2^63-1 (-9,223,372,036,854,775,807 to 9,223,372,036,854,775,807). On some platform a negative value on less is valid.",
usage = "Used in the declaration section of code, which is before any statements.",
example = "int64 thisInt; // A stand alone declaration of an int64.\n"
"int64 a, b; // Declaring two int64s at the same time.\n"
--- /dev/null
+{
+ description = "Signed integral type guaranteed to be the size of pointers (equivalent of intptr_t)"
+}
--- /dev/null
+{
+ description = "Signed integral type guaranteed to be the size of C 'ssize_t'"
+}
--- /dev/null
+{
+ description = "Signed integral type (expected to be equivalent to C ' int16_t'). A 16 bit signed integer can range from -32,767 to 32,767. On some platforms -32,768 is a valid value."
+}
{
- name = "struct"
+ name = "struct",
+ description = "Basic C and eC object type construct which can specify data members (a.k.a. 'fields' or 'records'). eC structs can contain methods and properties, can be extended through inheritance, and are also a type without needing a 'typedef'."
}
{
name = "uint",
- description = "An unsigned integer data type.\n"
- "\n"
- "Memory occupied: 32 bits(or 4 bytes)\n"
- "\n"
- "A uint data type holds a decimal value between the range of 0 to 2 exp 32-1 (or 0 to 4,294,967,295).",
+ description = "Unsigned integer data type (expected to be equivalent to C99 'uint32_t'). A 32 bit unsigned itger can range from 0 to 0xFFFFFFFF (4,294,967,295).",
usage = "Used in the declaration section of code, which is before any statements.",
example = "uint aUint; // A stand alone declaration of a uint.\n"
"uint a, b; // Declaring two uints at the same time.\n"
{
name = "uint16",
- description = "An unsigned integer data type.\n"
- "\n"
- "Memory occupied: 16 bits(or 2 bytes)\n"
- "\n"
- "A uint16 data type holds a decimal value between the range of 0 and 65,535.",
+ description = "16 bit unsigned integer data type (equivalent of C99 'uint16_t'). A 16 bit unsigned integer can range from 0 to 0xFFFF (65,535).",
usage = "Used in the declaration section of code, which is before any statements.",
example = "uint16 aUint16; // A standalone declaration of a uint16\n"
"uint16 a, b; // Declaring two uint16s at the same time.\n"
{
name = "uint32",
- description = "An unsigned integer data type.\n"
- "\n"
- "Memory occupied: 32 bits(or 4 bytes)\n"
- "\n"
- "A uint32 data type holds a decimal value between the range of 0 to 2 exp 32-1 (or 0 to 4,294,967,295).",
+ description = "32 bit unsigned integer data type (equivalent of C99 'uint32_t'). A 32 bit unsigned integer can range from 0 to 0xFFFFFFFF (4,294,967,295).",
usage = "Used in the declaration section of code, which is before any statements.",
example = "uint32 aUint32; // A stand alone declaration of a uint32.\n"
"uint32 a, b; // Declaring two uint32s at the same time.\n"
{
name = "uint64",
- description = "An unsigned integer data type.\n"
- "\n"
- "Memory occupied: 64 bits(or 8 bytes)\n"
- "\n"
- "A uint64 data type holds a decimal value between the range of 0 and 2 exp 64-1 (or 0 to 18,446,744,073,709,551,615).",
+ description = "64 bit unsigned integer data type (equivalent of C99 'uint64_t'). A 64 bit unsigned integer can range from 0 to 0xFFFFFFFFFFFFFFFF (18,446,744,073,709,551,615).",
usage = "Used in the declaration section of code, which is before any statements.",
example = "uint64 aUint64; // A stand alone declaration of a uint64.\n"
"uint64 a, b; // Declaring two uint64s at the same time.\n"
--- /dev/null
+{
+ description = "Unsigned integral type guaranteed to be the size of pointers (equivalent of uintptr_t)"
+}
--- /dev/null
+{
+ description = "Unsigned integral type guaranteed to be the size of C 'size_t'"
+}
{
name = "unsigned int",
- description = "An unsigned integer data type.\n"
- "\n"
- "Memory occupied: 32 bits(or 4 bytes)\n"
- "\n"
- "An unsigned int data type holds a decimal value between the range of 0 to 2 exp 32-1 (or 0 to 4,294,967,295).",
+ description = "Core C unsigned integer data type (expected to be equivalent to C99 'uint32_t'). A 32 bit unsigned intger can range from 0 to 0xFFFFFFFF (4,294,967,295).",
usage = "Used in the declaration section of code, which is before any statements.\n"
"\n"
"Declared as a standard int, but with the unsigned keyword in front to denote an unsigned integer value.",
Ecere Software / sdk / commitdiff