RAD Studio
Contents
Concepts
Debugging C++ Applications with CodeGuard Error Reporting
CodeGuard Errors
Access Errors
Exception Errors
Function Failure Errors
Resource Errors
CodeGuard Overview
CodeGuard Warnings
Memory Block Comparison Warnings
Pathname Merging and Splitting Warnings
String Comparison Warnings
Developing Database Applications for the Win32 Platform
dbGo Overview
BDE Overview
dbExpress Components
Getting Started with InterBase Express
dbExpress 4 New Feature Overview
Developing Interoperable Applications
Developing COM Applications
Developing Reports for Your Win32 Applications
Using Rave Reports in RAD Studio
Developing Applications with VCL Components
VCL Overview
Developing Web Applications with WebSnap
Win32 Web Applications Overview
Developing Web Services with Win32 Applications
Web Services Overview
Developing Windows Applications
Windows Overview
Procedures
CodeGuard Procedures
Using CodeGuard
Database Procedures
Accessing Schema Information
Configuring TSQL Connection
Connecting to the Application Server using DataSnap Components
Debugging dbExpress Applications using TSQLMonitor
Executing the Commands using TSQLDataSet
Fetching the Data using TSQLDataSet
Specifying the Data to Display using TSQLDataSet
Specifying the Provider using TLocalConnection or TConnectionBroker
Using BDE
Using DataSnap
Using TBatchMove
Connecting to Databases with TDatabase
Using TQuery
Using TSQLQuery
Using TSQLStoredProc
Using TSQLTable
Managing Database Sessions Using TSession
Using TSimpleDataSet
Using TSimpleObjectBroker
Using TStoredProc
Using TTable
Using TUpdateSQL to Update a Dataset
Using dbExpress
Using Data Explorer to Obtain Connection Information
Interoperable Applications Procedures
Using COM Wizards
Reporting Procedures
Adding Rave Reports to RAD Studio
VCL Procedures
Building a Windows "Hello World" Console Application
Developing a Windows Application
Building Application Menus
Building a VCL Forms Application with Decision Support Components
Building VCL Forms Applications With Graphics
Building a VCL Forms MDI Application Using a Wizard
Building a VCL Forms MDI Application Without Using a Wizard
Building a VCL Forms SDI Application
Creating a New VCL Component
Building a VCL Forms ADO Database Application
Building a VCL Forms Application
Creating Actions in a VCL Forms Application
Building a VCL Forms "Hello World" Application
Using ActionManager to Create Actions in a VCL Forms Application
Building a VCL Forms dbExpress Database Application
Building an Application with XML Components
Copying Data From One Stream To Another
Copying a Complete String List
Creating Strings
Creating a VCL Form Instance Using a Local Variable
Deleting Strings
Displaying an Auto-Created VCL Form
Displaying a Bitmap Image in a VCL Forms Application
Displaying a Full View Bitmap Image in a VCL Forms Application
Drawing a Polygon in a VCL Forms Application
Drawing Rectangles and Ellipses in a VCL Forms Application
Drawing a Rounded Rectangle in a VCL Forms Application
Drawing Straight Lines In a VCL Forms Application
Dynamically Creating a VCL Modal Form
Dynamically Creating a VCL Modeless Form
Iterating Through Strings in a List
Building a Multithreaded Application
Writing Cleanup Code
Avoiding Simultaneous Thread Access to the Same Memory
Defining the Thread Object
Handling Exceptions
Initializing a Thread
Using the Main VCL Thread
Waiting for Threads
Writing the Thread Function
Placing A Bitmap Image in a Control in a VCL Forms Application
Reading a String and Writing It To a File
Renaming Files
Adding and Sorting Strings
Creating a VCL Forms ActiveX Button
Creating a VCL Forms ActiveX Active Form
Building a VCL Forms Web Browser Application
WebSnap Procedures
Building a WebSnap Application
Building a WebSnap "Hello World" Application
Debugging a WebSnap Application using the Web Application Debugger
Web Services Procedures
Building a "Hello World" Web Services Application
Accessing an ASP.NET "HelloWorld" Web Services Application
Building an ASP.NET "Hello World" Web Services Application
Reference
C++ Reference
Command Line Utilities
BCC32, the C++ Command-Line Compiler
BRC32, the Resource Shell
BRCC32.EXE, the Resource Compiler
COFF2OMF.EXE, the Import Library Conversion Tool
CPP32.EXE, the C Compiler Preprocessor
DCC32.EXE, the Delphi Command Line Compiler
DCCIL.EXE, the Delphi for .NET Command Line Compiler
GREP.EXE, the text search utility
ILINK32.EXE, the Incremental Linker
IMPDEF.EXE, the Module Definition Manager
IMPLIB.EXE, the Import Library Tool
Using Include Files
MAKE
MAKE Directives
MAKE Macros
MAKE Rules (Explicit and Implicit) and Commands
Message Options
Module Definition Files
Using Precompiled Header Files
RLINK32.DLL, the Resource Linker (C++)
TDUMP.EXE, the File Dumping Utility
TLIB.EXE, the Library Manager
Using TOUCH.EXE
TRIGRAPH
List Of All C++ Compiler Errors And Warnings
E2066: Invalid MOM inheritance
E2525: You must define _PCH_STATIC_CONST before including xstring to use this feature
E2526: Property 'name' uses another property as getter/setter; Not allowed
E2008: Published property access functions must use __fastcall calling convention
E2122: Function call terminated by unhandled exception 'value' at address 'addr'
E2506: Explicit specialization of 'specifier' is ambiguous: must specify template arguments
E2483: Array dimension 'specifier' could not be determined
E2509: Value out of range
E2510: Operand size mismatch
E2050: __declspec(delphireturn) class 'class' must have exactly one data member
E2530: Unrecognized option, or no help available
E2527: Option 'name' cannot be set via 'name'
E2528: Option 'name' must be set before compilation begins
E2074: Value after -g or -j should be between 0 and 255 inclusive
E2492: Properties may only be assigned using a simple statement, e.g. \"prop = value;\"
E2505: Explicit instantiation requires an elaborated type specifier (i.e.,"class foo<int>")
E2100: Invalid template declarator list
E2102: Cannot use template 'template' without specifying specialization parameters
E2107: Invalid use of template 'template'
E2105: 'template' qualifier must specify a member template name
E2066: Information not available
E2471: pragma checkoption failed: options are not as expected
E2504: 'dynamic' can only be used with non-template member functions
E2191: '__far16' may only be used with '__pascal' or '__cdecl'
E2199: Template friend function 'function' must be previously declared
E2502: Error resolving #import: problem
E2501: Unable to open import file 'filename'
E2494: Unrecognized __declspec modifier
E2493: Invalid GUID string
E2499: Invalid __declspec(uuid(GuidString)) format
E2496: Invalid call to uuidof(struct type|variable)
E2511: Unterminated macro argument
E2489: Maximum option context replay depth exceeded; check for recursion
E2488: Maximum token reply depth exceeded; check for recursion
E2491: Maximum VIRDEF count exceeded; check for recursion
E2230: In-line data member initialization requires an integral constant expression
E2241: VCL style classes need virtual destructors
E2524: Anonymous structs/unions not allowed to have anonymous members in C++
E2246: x is not abstract public single inheritance class hierarchy with no data
E2249: = expected
E2267: First base must be VCL class
E2472: Cannot declare a member function via instantiation
E2515: Cannot explicitly specialize a member of a generic template class
E2474: 'function' cannot be declared as static or inline
E2498: Need previously defined struct GUID
E2295: Too many candidate template specializations from 'specifier'
E2475: 'function' cannot be a template function
E2299: Cannot generate template specialization from 'specifier'
E2300: Could not generate a specialization matching type for 'specifier'
E2497: No GUID associated with type:'type'
E2522: Non-const function 'function' called for const object
E2523: Non-volatile function 'name' called for volatile object
E2513: Cannot emit RTTI for 'parameter' in 'function'
E2512: Cannot emit RTTI for return type of 'function'
E2507: 'class' is not a direct base class of 'class'
E2529: Path 'path' exceeds maximum size of 'n'
E2495: Redefinition of uuid is not identical
E2500: __declspec(selectany) is only for initialized and externally visible variables
E2482: String constant expected
E2481: Unexpected string constant
E2386: Cannot involve parameter 'parameter' in a complex partial specialization expression
E2387: Partial specializations may not specialize dependent non-type parameters ('parameter')
E2388: Argument list of specialization cannot be identical to the parameter list of primary template
E2389: Mismatch in kind of substitution argument and template parameter 'parameter'
E2480: Cannot involve template parameters in complex partial specialization arguments
E2392: Template instance 'template' is already instantiated
E2393: Cannot take the address of non-type, non-reference template parameter 'parameter'
E2399: Cannot reference template argument 'arg' in template class 'class' this way
E2397: Template argument cannot have static or local linkage
E2485: Cannot use address of array element as non-type template argument
E2402: Illegal base class type: formal type 'type' resolves to 'type'
E2403: Dependent call specifier yields non-function 'name'
E2404: Dependent type qualifier 'qualifier' has no member type named 'name'
E2405: Dependent template reference 'identifier' yields non-template symbol
E2406: Dependent type qualifier 'qualifier' is not a class or struct type
E2407: Dependent type qualifier 'qualifier' has no member symbol named 'name'
E2408: Default values may be specified only in primary class template declarations
E2409: Cannot find a valid specialization for 'specifier'
E2410: Missing template parameters for friend template 'template'
E2486: Cannot use address of class member as non-type template argument
E2411: Declaration of member function default parameters after a specialization has already been expanded
E2412: Attempting to bind a member reference to a dependent type
E2414: Destructors cannot be declared as template functions
E2473: Invalid explicit specialization of 'specifier'
E2490: Specialization within template classes not yet implemented
E2416: Invalid template function declaration
E2417: Cannot specify template parameters in explicit specialization of 'specifier'
E2418: Maximum instantiation depth exceeded; check for recursion
E2420: Explicit instantiation can only be used at global scope
E2422: Argument kind mismatch in redeclaration of template parameter 'parameter'
E2423: Explicit specialization or instantiation of non-existing template 'template'
E2479: Cannot have both a template class and function named 'name'
E2484: The name of template class 'class' cannot be overloaded
E2426: Explicit specialization of 'specifier' requires 'template<>' declaration
E2487: Cannot specify default function arguments for explicit specializations
E2427: 'main' cannot be a template function
E2429: Not a valid partial specialization of 'specifier'
E2430: Number of template parameters does not match in redeclaration of 'specifier'
E2477: Too few template parameters were declared for template 'template'
E2478: Too many template parameters were declared for template 'template'
E2431: Non-type template parameters cannot be of floating point, class, or void type
E2434: Template declaration missing template parameters ('template<...>')
E2435: Too many template parameter sets were specified
E2436: Default type for template template argument 'arg' does not name a primary template class
E2437: 'typename' should be followed by a qualified, dependent type name
E2438: Template template arguments must name a class
E2439: 'typename' is only allowed in template declarations
E2440: Cannot generate specialization from 'specifier' because that type is not yet defined
E2441: Instantiating 'specifier'
E2503: Missing or incorrect version of TypeLibImport.dll
E2470: Need to include header <typeinfo> to use typeid
E2514: Cannot (yet) use member overload resolution during template instantiation
E2508: 'using' cannot refer to a template specialization
E2462: 'virtual' can only be used with non-template member functions
W8086: Incorrect use of #pragma alias "aliasName"="substituteName"
W8099: Static main is not treated as an entry point
W8093: Incorrect use of #pragma codeseg [seg_name] ["seg_class"] [group]
W8094: Incorrect use of #pragma comment( <type> [,"string"] )
W8085: Function 'function' redefined as non-inline
W8105: %s member '%s' in class without constructors
W8095: Incorrect use of #pragma message( "string" )
W8098: Multi-character character constant
W8096: Incorrect use of #pragma code_seg(["seg_name"[,"seg_class"]])
W8083: Pragma pack pop with no matching pack push
W8097: Not all options can be restored at this time
W8084: Suggest parentheses to clarify precedence
W8092: 'type' argument 'specifier' passed to 'function' is not an iterator: 'type' iterator required
W8087: 'operator::operator==' must be publicly visible to be contained by a 'type'
W8090: 'type::operator<' must be publicly visible to be used with 'type'
W8089: 'type::operator<' must be publicly visible to be contained by a 'type'
W8091: 'type' argument 'specifier' passed to 'function' is a 'iterator category' iterator: 'iterator category' iterator required
W8076: Template instance 'specifier' is already instantiated
W8077: Explicitly specializing an explicitly specialized class member makes no sense
Informational messages
E2196: Cannot take address of member function 'function'
F1002: Unable to create output file 'filename'
F1003: Error directive: 'message'
F1004: Internal compiler error
F1006: Bad call of intrinsic function
F1007: Irreducible expression tree
F1009: Unable to open input file 'filename'
F1011: Register allocation failure
F1012: Compiler stack overflow
F1013: Error writing output file
F1000: Compiler table limit exceeded
F1005: Include files nested too deep
F1008: Out of memory
F1010: Unable to open 'filename'
E2000: 286/287 instructions not enabled
Abnormal program termination
E2009: Attempt to grant or reduce access to 'identifier'
E2011: Illegal to take address of bit field
E2010: Cannot add or subtract relocatable symbols
E2013: 'function1' cannot be distinguished from 'function2'
E2014: Member is ambiguous: 'member1' and 'member2'
E2015: Ambiguity between 'function1' and 'function2'
E2017: Ambiguous member name 'name'
E2019: 'identifier' cannot be declared in an anonymous union
E2020: Global anonymous union not static
E2022: Array size too large
E2024: Cannot modify a const object
E2025: Assignment to 'this' not allowed, use X::operator new instead
E2026: Assembler statement too long
E2001: Constructors and destructors not allowed in __automated section
E2002: Only __fastcall functions allowed in __automated section
E2003: Data member definition not allowed in __automated section
E2004: Only read or write clause allowed in property declaration in __automated section
E2005: Redeclaration of property not allowed in __automated section
E2027: Must take address of a memory location
E2028: operator -> must return a pointer or a class
E2029: 'identifier' must be a previously defined class or struct
E2030: Misplaced break
E2031: Cannot cast from 'type1' to 'type2'
E2033: Misplaced continue
E2034: Cannot convert 'type1' to 'type2'
E2036: Conversion operator cannot have a return type specification
E2037: The constructor 'constructor' is not allowed
E2039: Misplaced decimal point
E2041: Incorrect use of default
E2042: Declare operator delete (void*) or (void*, size_t)
E2044: operator delete must return void
E2045: Destructor name must match the class name
E2048: Unknown preprocessor directive: 'identifier'
E2046: Bad file name format in include directive OR Bad file name format in line directive
E2051: Invalid use of dot
E2053: Misplaced elif directive
E2054: Misplaced else
E2055: Misplaced else directive
E2056: Misplaced endif directive
E2059: Unknown language, must be C or C++
E2060: Illegal use of floating point
E2061: Friends must be functions or classes
E2062: Invalid indirection
E2063: Illegal initialization
E2064: Cannot initialize 'type1' with 'type2'
E2068: 'identifier' is not a non-static data member and can't be initialized here
E2069: Illegal use of member pointer
E2071: operator new must have an initial parameter of type size_t
E2072: Operator new[] must return an object of type void
E2075: Incorrect 'type' option: option
E2076: Overloadable operator expected
E2080: 'function' must be declared with one parameter
E2077: 'operator' must be declared with one or no parameters
E2079: 'function' must be declared with no parameters
E2078: 'operator' must be declared with one or two parameters
E2081: 'function' must be declared with two parameters
E2082: 'identifier' must be a member function or have a parameter of class type
E2083: Last parameter of 'operator' must have type 'int'
E2084: Parameter names are used only with a function body
E2085: Invalid pointer addition
E2086: Illegal pointer subtraction
E2087: Illegal use of pointer
E2088: Bad syntax for pure function definition
E2089: Identifier 'identifier' cannot have a type qualifier
E2090: Qualifier 'identifier' is not a class or namespace name
E2092: Storage class 'storage class' is not allowed here
E2096: Illegal structure operation
E2104: Invalid use of template keyword
E2108: Improper use of typedef 'identifier'
E2109: Not an allowed type
E2110: Incompatible type conversion
E2113: Virtual function 'function1' conflicts with base class 'base'
E2114: Multiple base classes require explicit class names
E2115: Bit field too large
E2116: Bit fields must contain at least one bit
W8005: Bit fields must be signed or unsigned int
E2119: User break
E2111: Type 'typename' may not be defined here
E2121: Function call missing )
E2123: Class 'class' may not contain pure functions
E2126: Case bypasses initialization of a local variable
E2127: Case statement missing :
E2128: Case outside of switch
E2129: Character constant too long (or empty)
E2133: Unable to execute command 'command'
E2134: Compound statement missing closing brace
E2137: Destructor for 'class' required in conditional expression
E2135: Constructor/Destructor cannot be declared 'const' or 'volatile'
E2138: Conflicting type modifiers
E2136: Constructor cannot have a return type specification
E2038: Cannot declare or define 'identifier' here: wrong namespace
E2154: Cannot define 'identifier' using a namespace alias
E2421: Cannot use local type 'identifier' as template argument
E2035: Conversions of class to itself or base class not allowed
E2139: Declaration missing ;
E2140: Declaration is not allowed here
E2141: Declaration syntax error
E2142: Base class 'class' contains dynamically dispatchable functions
E2143: Matching base class function 'function' has different dispatch number
E2144: Matching base class function 'function' is not dynamic
E2145: Functions 'function1' and 'function2' both use the same dispatch number
E2146: Need an identifier to declare
E2147: 'identifier' cannot start a parameter declaration
E2150: Type mismatch in default argument value
E2152: Default expression may not use local variables
E2153: Define directive needs an identifier
E2155: Too many default cases
E2156: Default outside of switch
E2158: Operand of 'delete' must be non-const pointer
E2159: Trying to derive a far class from the huge base 'base'
E2160: Trying to derive a far class from the near base 'base'
E2161: Trying to derive a huge class from the far base 'base'
E2162: Trying to derive a huge class from the near base 'base'
E2163: Trying to derive a near class from the far base 'base'
E2164: Trying to derive a near class from the huge base 'base'
E2165: Destructor cannot have a return type specification
E2166: Destructor for 'class' is not accessible
E2167: 'function' was previously declared with the language 'language'
E2168: Division by zero
E2169: 'identifier' specifies multiple or duplicate access
E2170: Base class 'class' is included more than once
E2171: Body has already been defined for function 'function'
E2172: Duplicate case
E2175: Too many storage classes in declaration
E2176: Too many types in declaration
E2179: virtual specified more than once
E2007: Dispid only allowed in __automated sections
Divide error
E2182: Illegal parameter to __emit__
E2183: File must contain at least one external declaration
E2184: Enum syntax error
E2185: The value for 'identifier' is not within the range of an int
E2186: Unexpected end of file in comment started on line 'number'
E2187: Unexpected end of file in conditional started on line 'number'
E2188: Expression syntax
E2190: Unexpected closing brace
E2189: extern variable cannot be initialized
E2344: Earlier declaration of 'identifier'
E2192: Too few parameters in call
E2193: Too few parameters in call to 'function'
E2194: Could not find file 'filename'
E2197: File name too long
E2195: Cannot evaluate function call
E2198: Not a valid expression format type
E2200: Functions may not be part of a struct or union
Floating point error: Divide by 0 OR Floating point error: Domain OR Floating point error: Overflow
Floating point error: Stack fault
Floating point error: Partial loss of precision OR Floating point error: Underflow
E2201: Too much global data defined in file
E2203: Goto bypasses initialization of a local variable
E2204: Group overflowed maximum size: 'name'
E2206: Illegal character 'character' (0x'value')
E2207: Implicit conversion of 'type1' to 'type2' not allowed
E2208: Cannot access an inactive scope
E2209: Unable to open include file 'filename'
E2210: Reference member 'member' is not initialized
E2212: Function defined inline after use as extern
E2211: Inline assembly not allowed in inline and template functions
F1001: Internal code generator error
E2413: Invalid template declaration
E2070: Invalid use of namespace 'identifier'
E2214: Cannot have a 'non-inline function/static data' in a local class
E2215: Linkage specification not allowed
E2216: Unable to create turboc.$ln
E2218: Templates can only be declared at namespace or class scope
E2217: Local data exceeds segment size limit
E2219: Wrong number of arguments in call of macro 'macro'
E2220: Invalid macro argument separator
E2221: Macro argument syntax error
E2222: Macro expansion too long
E2223: Too many decimal points
E2224: Too many exponents
E2225: Too many initializers
E2226: Extra parameter in call
E2227: Extra parameter in call to function
E2228: Too many error or warning messages
E2233: Cannot initialize a class member here
E2232: Constant/Reference member 'member' in class without constructors
E2229: Member 'member' has the same name as its class
E2234: Memory reference expected
E2231: Member 'member' cannot be used without an object
E2235: Member function must be called or its address taken
O2237: DPMI programs must use the large memory model
E2238: Multiple declaration for 'identifier'
E2239: 'identifier' must be a member function
E2240: Conversion of near pointer not allowed
E2243: Array allocated using 'new' may not have an initializer
E2244: 'new' and 'delete' not supported
E2245: Cannot allocate a reference
E2309: Inline assembly not allowed
E2250: No base class to initialize
E2254: : expected after private/protected/private
E2255: Use :: to take the address of a member function
E2256: No : following the ?
E2257: , expected
E2258: Declaration was expected
E2259: Default value missing
E2260: Default value missing following parameter 'parameter'
E2263: Exception handling not enabled
E2264: Expression expected
E2266: No file names given
E2265: No file name ending
E2271: Goto statement missing label
E2272: Identifier expected
E2275: Opening brace expected
E2276: ( expected
E2274: < expected
E2277: Lvalue required
E2278: Multiple base classes not supported for Delphi classes
E2280: Member identifier expected
E2279: Cannot find default constructor to initialize member 'identifier'
E2310: Only member functions may be 'const' or 'volatile'
E2311: Non-virtual function 'function' declared pure
E2283: Use . or -> to call 'function'
E2284: Use . or -> to call 'member', or & to take its address
E2285: Could not find a match for 'argument(s)'
E2286: Overloaded function resolution not supported
E2287: Parameter 'number' missing name
E2288: Pointer to structure required on left side of -> or ->*
E2290: 'code' missing ]
E2291: brace expected
E2292: Function should return a value
E2293: ) expected
E2294: Structure required on left side of . or .*
E2312: 'constructor' is not an unambiguous base class of 'class'
E2313: Constant expression required
E2296: Templates not supported
E2314: Call of nonfunction
E2321: Declaration does not specify a tag or an identifier
E2297: 'this' can only be used within a member function
E2316: 'identifier' is not a member of 'struct'
E2317: 'identifier' is not a parameter
E2319: 'identifier' is not a public base class of 'classtype'
E2320: Expression of scalar type expected
E2302: No type information
E2303: Type name expected
E2304: 'Constant/Reference' variable 'variable' must be initialized
E2305: Cannot find 'class::class' ('class'&) to copy a vector OR Cannot find 'class'::operator=('class'&) to copy a vector
E2306: Virtual base classes not supported for Delphi classes
E2308: do statement must have while
E2322: Incorrect number format
E2324: Numeric constant too large
E2282: Namespace name expected
E2334: Namespace member 'identifier' declared outside its namespace
E2325: Illegal octal digit
E2329: Invalid combination of opcode and operands
E2327: Operators may not have default argument values
E2330: Operator must be declared as function
E2333: Class member 'member' declared outside its class
E2335: Overloaded 'function name' ambiguous in this context
E2339: Cannot overload 'main'
E2336: Pointer to overloaded function 'function' doesn't match 'type'
E2337: Only one of a set of overloaded functions can be "C"
E2338: Overlays only supported in medium, large, and huge memory models
E2340: Type mismatch in parameter 'number'
E2341: Type mismatch in parameter 'number' in call to 'function'
E2342: Type mismatch in parameter 'parameter'
E2343: Type mismatch in parameter 'parameter' in call to 'function'
E2345: Access can only be changed to public or protected
E2349: Nonportable pointer conversion
E2350: Cannot define a pointer or reference to a reference
E2352: Cannot create instance of abstract class 'class'
E2354: Two operands must evaluate to the same type
E2355: Recursive template function: 'x' instantiated 'y'
E2356: Type mismatch in redeclaration of 'identifier'
E2357: Reference initialized with 'type1', needs lvalue of type 'type2'
E2358: Reference member 'member' needs a temporary for initialization
E2360: Invalid register combination (e.g. [BP+BX])
E2361: 'specifier' has already been included
E2362: Repeat count needs an lvalue
E2363: Attempting to return a reference to local variable 'identifier'
E2364: Attempting to return a reference to a local object
E2365: Member pointer required on right side of .* or ->*
E2366: Can't inherit non-RTTI class from RTTI base OR E2367 Can't inherit RTTI class from non-RTTI base
E2368: RTTI not available for expression evaluation
E2371: sizeof may not be applied to a bit field
E2372: sizeof may not be applied to a function
E2373: Bit field cannot be static
E2374: Function 'function' cannot be static
Stack overflow
(E2376: statement missing
E2377: statement missing )
E2378: do-while or for statement missing ;
E2379: Statement missing ;
E2380: Unterminated string or character constant
E2381: Structure size too large
E2382: Side effects are not allowed
E2383: Switch selection expression must be of integral type
E2433: Specialization after first use of template
E2384: Cannot call near class member function with a pointer of type 'type'
E2390: Type mismatch in parameter 'number' in template class name 'template'
E2391: Type mismatch in parameter 'parameter' in template class name 'template'
E2394: Too few arguments passed to template 'template'
E2395: Too many arguments passed to template 'template'
E2396: Template argument must be a constant expression
E2401: Invalid template argument list
E2400: Nontype template argument must be of scalar type
E2415: Template functions may only have 'type-arguments'
E2425: 'member' is not a valid template type member
E2428: Templates must be classes or functions
E2432: 'template' qualifier must name a template class or function instance'
E2442: Two consecutive dots
E2443: Base class 'class' is initialized more than once
E2444: Member 'member' is initialized more than once
E2445: Variable 'identifier' is initialized more than once
E2446: Function definition cannot be a typedef'ed declaration
E2132: Templates and overloaded operators cannot have C linkage
E2447: 'identifier' must be a previously defined enumeration tag
E2448: Undefined label 'identifier'
E2449: Size of 'identifier' is unknown or zero
E2450: Undefined structure 'structure'
E2451: Undefined symbol 'identifier'
E2453: Size of the type 'identifier' is unknown or zero
E2452: Size of the type is unknown or zero
E2454: union cannot be a base type
E2455: union cannot have a base type
E2456: Union member 'member' is of type class with 'constructor' (or destructor, or operator =)
E2461: '%s' requires run-time initialization/finalization
E2464: 'virtual' can only be used with member functions
E2465: unions cannot have virtual member functions
E2466: void & is not a valid type
E2467: 'Void function' cannot return a value
E2468: Value of type void is not allowed
E2469: Cannot use tiny or huge memory model with Windows
E2006: CodeGuarded programs must use the large memory model and be targeted for Windows
E2269: The function 'function' is not available
E2124: Invalid function call
E2213: Invalid 'expression' in scope override
E2236: Missing 'identifier' in scope override
Pure virtual function called
E2095: String literal not allowed in this context
Unexpected termination during compilation [Module Seg#:offset] OR Unexpected termination during linking [Module Seg#:offset]
E2012: Cannot take address of 'main'
E2016: Ambiguous override of virtual base member 'base_function': 'derived_function'
E2018: Cannot throw 'type' -- ambiguous base class 'base'
E2021: Array must have at least one element
E2023: Array of references is not allowed
E2032: Illegal use of closure pointer
E2040: Declaration terminated incorrectly
E2047: Bad 'directive' directive syntax
E2049: Class type 'type' cannot be marked as __declspec(delphireturn)
E2052: Dynamic function 'function' conflicts with base class 'class'
E2057: Exception specification not allowed here
E2058: Exception handling variable may not be used here
E2065: Using namespace symbol 'symbol' conflicts with intrinsic of the same name
E2067: 'main' must have a return type of int
E2073: Nothing allowed after pragma option pop
E2091: Functions cannot return arrays or functions
E2093: Operator 'operator' not implemented in type 'type' for arguments of the same type
E2094: Operator 'operator' not implemented in type 'type' for arguments of type 'type'
E2097: Explicit instantiation only allowed at file or namespace scope
E2098: Explicit specialization declarator "template<>" now required
E2099: Explicit specialization only allowed at file or namespace scope
E2101: 'export' keyword must precede a template declaration
E2103: Explicit instantiation must be used with a template class or function
E2106: Explicit specialization must be used with a template class or function
E2112: Unknown unit directive: 'directive'
E2118: Bit fields must have integral type
E2120: Cannot call 'main' from within the program
E2125: Compiler could not generate copy constructor for class 'class' OR Compiler could not generate default constructor for class 'class' OR Compiler could not generate operator = for class 'class'
E2130: Circular property definition
E2131: Objects of type 'type' cannot be initialized with { }
E2148: Default argument value redeclared for parameter 'parameter'
E2149: Default argument value redeclared
E2151: Type mismatch in default value for parameter 'parameter'
E2157: Deleting an object requires exactly one conversion to pointer operator
E2173: Duplicate handler for 'type1', already had 'type2'
E2174: The name handler must be last
E2177: Redeclaration of #pragma package with different arguments
E2178: VIRDEF name conflict for 'function'
E2180: Dispid number already used by identifier
E2181: Cannot override a 'dynamic/virtual' with a 'dynamic/virtual' function
E2202: Goto into an exception handler is not allowed
E2205: Illegal type type in __automated section
E2242: Specifier requires Delphi style class type
E2247: 'member' is not accessible
E2248: Cannot find default constructor to initialize array element of type 'class'
E2251: Cannot find default constructor to initialize base class 'class'
E2252: 'catch' expected
E2253: Calling convention must be attributed to the function type, not the closure
E2261: Use of dispid with a property requires a getter or setter
E2262: '__except' or '__finally' expected following '__try'
E2270: > expected
E2273: 'main' cannot be declared as static or inline
E2281: Identifier1 requires definition of Identifier2 as a pointer type
E2289: __published or __automated sections only supported for Delphi classes
E2298: Cannot generate 'function' from template function 'template'
E2301: Cannot use templates in closure arguments -- use a typedef
E2307: Type 'type' is not a defined class with virtual functions
E2315: 'Member' is not a member of 'class', because the type is not yet defined
E2318: 'type' is not a polymorphic class type
E2323: Illegal number suffix
E2326: Use __declspec(spec1[, spec2]) to combine multiple __declspecs
E2328: Classes with properties cannot be copied by value
E2331: Number of allowable option contexts exceeded
E2332: Variable 'variable' has been optimized and is not available
E2476: Cannot overload 'function'
E2346: 'x' access specifier of property 'property' must be a member function
E2347: Parameter mismatch in access specifier 'specifier' of property 'property'
E2348: Storage specifier not allowed for array properties
E2351: Static data members not allowed in __published or __automated sections
E2353: Class 'classname' is abstract because of 'member = 0'
E2359: Reference member 'member' initialized with a non-reference parameter
E2369: Cannot use the result of a property assignment as an rvalue'
E2370: Simple type name expected
E2398: Template function argument 'argument' not used in argument types
E2419: Error while instantiating template 'template'
E2424: Template class nesting too deep: 'class'
E2457: Delphi style classes must be caught by reference
E2458: Delphi classes have to be derived from Delphi classes
E2459: Delphi style classes must be constructed using operator new
E2460: Delphi style classes require exception handling to be enabled
E2463: 'base' is an indirect virtual base class of 'class'
Null pointer assignment
E2268: Call to undefined function 'function'
E2375: Assembler stack overflow
Initializing enumeration with type
<name> is not a valid identifier
Example for "Temporary used ..." error messages
Application is running
Printf/Scanf floating-point formats not linked
W8000: Ambiguous operators need parentheses
W8060: Possibly incorrect assignment
W8002: Restarting compile using assembly
W8003: Unknown assembler instruction
W8052: Base initialization without a class name is now obsolete
E2117: Bit fields must be signed or unsigned int
W8064: Call to function with no prototype
W8065: Call to function 'function' with no prototype
W8009: Constant is long
W8008: Condition is always true OR W8008 Condition is always false
W8012: Comparing signed and unsigned values
W8010: Continuation character \ found in // comment
W8080: 'identifier' is declared but never used
W8014: Declaration ignored
W8068: Constant out of range in comparison
W8016: Array size for 'delete' ignored
W8082: Division by zero
W8018: Assigning 'type' to 'enumeration'
W8006: Initializing 'identifier' with 'identifier'
W8001: Superfluous & with function
W8020: 'identifier' is declared as both external and static
W8007: Hexadecimal value contains more than three digits
W8024: Base class 'class1' is also a base class of 'class2'
W8022: 'function1' hides virtual function 'function2'
W8023: Array variable 'identifier' is near
W8061: Initialization is only partially bracketed
W8038: constant member 'identifier' is not initialized
W8071: Conversion may lose significant digits
W8043: Macro definition ignored
W8017: Redefinition of 'x' is not identical
W8079: Mixing pointers to different 'char' types
W8067: Both return and return with a value used
W8048: Use qualified name to access member type 'identifier'
W8039: Constructor initializer list ignored
W8040: Function body ignored
W8042: Initializer for object 'x' ignored
W8044: #undef directive ignored
W8037: Non-const function 'function' called for const object
W8051: Non-volatile function 'function' called for volatile object
W8019: Code has no effect
W8057: Parameter 'parameter' is never used
W8070: Function should return a value
W8047: Declaration of static function function ignored
W8041: Negating unsigned value
W8054: Style of function definition is now obsolete
W8025: Ill-formed pragma
W8063: Overloaded prefix operator 'operator' used as a postfix operator
W8015: Declare 'type' prior to use in prototype
W8069: Nonportable pointer conversion
W8066: Unreachable code
W8029: Temporary used for parameter '???'
W8031: Temporary used for parameter 'parameter' OR W8029 Temporary used for parameter 'number' OR W8030 Temporary used for parameter 'parameter' in call to 'function' OR W8032 Temporary used for parameter 'number' in call to 'function'
W8032: Temporary used for parameter 2 in call to '???'
W8028: Temporary used to initialize 'identifier'
W8074: Structure passed by value
W8011: Nonportable pointer comparison
W8075: Suspicious pointer conversion
W8059: Structure packing size has changed
W8045: No declaration for function 'function'
W8073: Undefined structure 'structure'
W8013: Possible use of 'identifier' before definition
W8004: 'identifier' is assigned a value that is never used
W8081: Void functions may not return a value
W8078: Throw expression violates exception specification
W8021: Handler for 'type1' hidden by previous handler for 'type2'
W8056: Integer arithmetic overflow
W8035: User-defined message
W8049: Use '> >' for nested templates Instead of '>>'
W8026: Functions with exception specifications are not expanded inline
W8058: Cannot create pre-compiled header: 'reason'
W8046: Pragma option pop with no matching option push
W8050: No type OBJ file present. Disabling external types option.
W8027: Functions containing 'statement' are not expanded inline
W8036: Non-ANSI keyword used: 'keyword'
W8053: 'ident' is obsolete
W8103: Path 'path' and filename 'filename' exceed maximum size of 'n'
W8062: Previous options and warnings not restored
W8055: Possible overflow in shift operation
W8072: Suspicious pointer arithmetic
W8033: Conversion to 'type' will fail for members of virtual base 'class'
W8034: Maximum precision used for member pointer type 'type'
C++ Examples
Remove and MessageDlg example
C++ Language Guide
C++ Specifics
Classes
C++ Classes
Friends Of Classes
Friends Of Classes
Class Member List
Inline Functions
Inline Functions
Class Name Scope
The Keyword This
Static Members
Class Names
Member Scope
Base And Derived Class Access
Member Access Control
Member Scope
Nested Types
Class Objects
Virtual Base Classes
Virtual Base Classes
Class Types
Member Functions
VCL Class Declarations
Class Templates Overview
Using Angle Brackets In Templates
Template Arguments
Class Templates
Eliminating Pointers In Templates
Using Type-safe Generic Lists In Templates
Compiler Template Switches
Template Compiler Switches
Template Generation Semantics
Constructors And Destructors
Introduction To Constructors And Destructors
Constructors
Class Initialization
Constructor Defaults
Constructors
Order Of Calling Constructors
Overloading Constructors
The Copy Constructor
Destructors
Destructors
Exit And Destructors
Invoking Destructors
Virtual Destructors
abort And Destructors
atexit, #pragma exit, And Destructors
C++ namespaces
Declaring A namespace
Accessing Elements Of A namespace
Anonymous namespaces
Defining A namespace
Explicit Access Qualification
Extending A namespace
namespace Alias
using Directive
C++ Scope
C++ Scope
C++ Scoping Rules Summary
Class Scope
Hiding
Exporting And Importing Templates
Exporting And Importing Templates
Function Templates Overview
Function Templates
Implicit And Explicit Template Functions
Overriding A Template Function
The new And delete Operators
Handling Errors For The New Operator
Operator new Placement Syntax
Overloading The Operator delete
Overloading The Operator new
The delete Operator With Arrays
Operator new
The Operator new With Arrays
New-style Typecasting Overview
New-style Typecasting
Operator Overloading Overview
How To Construct A Class Of Complex Vectors
Example Of Overloading Operators
Overloading Operators
Overloading Operator Functions Overview
Overloading The Assignment operator =
Overloading Binary Operators
Overloading The Class Member Access Operators ->
Overloading The Function Call Operator ( )
Overloading Operator Functions
Overloaded Operators And Inheritance
Overloading The Subscript Operator []
Overloading Unary Operators
Polymorphic Classes
Abstract Classes
Abstract Classes
Polymorphic Classes
Virtual Functions
Dynamic Functions
Virtual Functions
Referencing
Reference Arguments
Referencing
Simple References
Run-time Type Identification (RTTI)
Runtime Type Identification (RTTI) Overview
The Typeid Operator
Runtime Type Identification And Destructors
The Scope Resolution Operator
Scope Resolution Operator ::
Stricter C++ Compiler (C++Builder 2007)
Stricter C++ Compiler: Binding of References and Qualifiers
Stricter C++ Compiler: String Literals Are Now Constants
Stricter C++ Compiler: Template Changes
Stricter C++ Compiler: Function Overload Resolution
Stricter C++ Compiler: Initialization and Conversion
Templates
Template Body Parsing
Using Templates
Keywords, Alphabetical Listing
__declspec(dllexport)
__declspec(dllimport)
__declspec(naked)
__declspec(noreturn)
__declspec(nothrow)
__declspec(novtable)
__declspec(property)
__declspec(selectany)
__declspec(thread)
__declspec(uuid(“ComObjectGUID”))
sizeof
__automated
__classid
__closure
__declspec
__dispid
__except
__inline
__int8, __int16, __int32, __int64, Unsigned __int64, Extended Integer Types
__msfastcall
__msreturn
__property
__published
__rtti, -RT Option
__thread, Multithread Variables
__try
_export, __export
_fastcall, __fastcall
_stdcall, __stdcall
asm, _asm, __asm
auto
bool, false, true
break
case
catch
cdecl, _cdecl, __cdecl
char
class
const
const_cast (typecast Operator)
continue
default
delete
do
double
dynamic_cast (typecast Operator)
enum
explicit
export
extern
__finally
float
for
friend
goto
if, else
import, _import, __import
inline
int
long
mutable
namespace
new
operator
pascal, _pascal, __pascal
private
protected
public
register
reinterpret_cast (typecast Operator)
return
short
signed
static
static_cast (typecast Operator)
struct
switch
template
this
throw
try
typedef
typeid
typename
union
unsigned
using (declaration)
virtual
void
volatile
wchar_t
while
Keywords, By Category
Modifiers
Operators
Special Types
Statements
Storage Class Specifiers
Type Specifiers
C++Builder Keyword Extensions
C++ Specific Keywords
Language Structure
Binary Operators
Binary Operators
Bitwise Operators
C++ Specific Operators
Equality Operators
Logical Operators
Relational Operators
Assignment Operators
Comma Operator
Conditional Operators
Multiplicative Operators
Declarations
Duration
Linkage
Objects
Scope
Storage Classes And Types
Translation Units
Visibility
Declaration Syntax
Tentative Definitions
Possible Declarations
External Declarations and Definitions
Type Specifiers
Type Categories
The Fundamental Types
Initialization
Declaration and Declarators
Use of Storage Class Specifiers
Variable Modifiers
Mixed-Language Calling Conventions
Multithread Variables
Function Modifiers
Enumerations
Enumerations
Assignment To Enum Types
Expressions
Expressions
Precedence Of Operators
Expressions And C++
Evaluation Order
Errors And Overflows
Functions
Functions
The main() Function
About The main() Function
Arguments to main()
Default Runtime Libraries
Dynamic-link Libraries
Multithread Programs
Passing File Information To Child Processes
Static Runtime Libraries
The Value main() Returns
Using --p (Pascal Calling Conventions)
Wildcard Arguments
Declarations And Definitions
Declarations And Prototypes
Definitions
Extended Types Formatted I/O
Formal Parameter Declarations
Function Calls And Argument Conversions
Operators Summary
Operators Summary
Pointers
Arrays
C++ Reference Declarations
Pointer Arithmetic
Pointer Constants
Pointer Conversions
Pointer Declarations
Pointers
Pointers To Functions
Pointers To Objects
Postfix Expression Operators
. (direct Member Selector)
-> (indirect Member Selector)
Array Subscript Operator
Increment/decrement Operators
Function Call Operator
Primary Expression Operators
Primary Expression Operators
Statements
Blocks
C++ Specifics
Expression Statements
Iteration Statements
Jump Statements
Labeled Statements
Selection Statements
Statements
Structures
Structures
Untagged Structures And Typedefs
Structure Member Declarations
Structures And Functions
Structure Member Access
Structure Name Spaces
Incomplete Declarations
Bit Fields
Unary Operators
Unary Operators
Arithmetic Operators
Plus And Minus Operators
Reference/Deference Operators
Unions
Unions
Anonymous Unions
Union Declarations
Lexical Elements
Lexical Elements
Tokens Overview
Constants Overview
Character Constants Overview
Character Constants
Escape Sequences
The Three Char Types
Wide-character And Multi-character Constants
Constants
Integer Constant Without L Or U
Constant Expressions
Constant Expressions
Constants and Internal Representation
Constants And Internal Representation
Floating Point Constants
Enumeration Constants
Enumeration Constants
Integer Constants
Internal Representation of Numerical Types
Internal Representation Of Numerical Types
String Constants
String Constants
Tokens
Identifiers Overview
Identifiers
Keywords Overview
Keywords
Keyword Extensions
C++-Specific Keywords
Table Of CodeGear C++ Register Pseudovariables
Punctuators Overview
Punctuators
Whitespace Overview
Comments
Whitespace
The Preprocessor
Conditional Compilation Overview
Conditional Compilation
#if, #elif, #else, And #endif
#ifdef And #ifndef
Defined
Defining And Undefining Macros
Using The -D And -U Command-line Options
Keywords And Protected Words In Macros
#define
#undef
The #error Control Directive
#error
File Inclusion With #include
#include
Header File Search With <header_name>
Header File Search With "header_name"
The #line Control Directive
#line
Macros With Parameters Overview
Macros With Parameters
Nesting Parentheses And Commas
Token Pasting With ##
Converting To Strings With #
Using The Backslash (\) For Line Continuation
Side Effects And Other Dangers
Pragma Directives Overview
#pragma
#pragma alignment
#pragma anon_struct
#pragma argsused
#pragma checkoption
#pragma codeseg
#pragma comment
#pragma defineonoption and #pragma undefineonoption
#pragma exit and #pragma startup
#pragma hdrfile
#pragma hdrstop
#pragma inline
#pragma intrinsic
#pragma link
#pragma message
#pragma nopushoptwarn
#pragma obsolete
#pragma option
#pragma pack
#pragma package
#pragma region and #pragma end_region
#pragma resource
#pragma warn
Predefined Macros Overview
Predefined Macros
Preprocessor Directives
Preprocessor Directives
# (null Directive)
C Runtime Library Reference
alloc.h
_heapchk
_heapmin
_heapset
_msize
_rtl_heapwalk
calloc
free
heapcheck
heapcheckfree
heapchecknode
heapfillfree
heapwalk
malloc
realloc
stackavail
assert.h
NDEBUG #define
assert
conio.h
_setcursortype
cgets
clreol
clrscr
cprintf
cputs
cscanf
delline
getch
getche
getpass
gettext
gettextinfo
gotoxy
highvideo
insline
kbhit
lowvideo
movetext
normvideo
putch
puttext
textattr
textbackground
textcolor
textmode
ungetch
wherex
wherey
window
ctype.h
_ctype
_IS_xxx #defines
_tolower
_toupper
isalnum, __iscsym, iswalnum, _ismbcalnum
isalpha, __iscsymf, iswalpha, _ismbcalpha
isascii, iswascii
iscntrl, iswcntrl
isdigit, iswdigit, _ismbcdigit
isgraph, iswgraph, _ismbcgraph
islower, iswlower, _ismbclower
isprint, iswprint, _ismbcprint
ispunct, iswpunct, _ismbcpunct
isspace, iswspace, _ismbcspace
isupper, iswupper, _ismbcupper
isxdigit, iswxdigit
toascii
tolower, _mbctolower, towlower
toupper, _mbctoupper, towupper
delayimp.h
__pfnDliNotifyHook, __pfnDliFailureHook
__FUnloadDelayLoadedDLL
direct.h
_chdrive
_getdcwd, _wgetdcwd
dirent.h
closedir, wclosedir
opendir, wopendir
readdir, wreaddir
rewinddir, wrewinddir
dir.h
chdir
MAXxxxx #defines (fnsplit)
findclose, _wfindclose
findfirst, _wfindfirst
findnext, _wfindnext
fnmerge, _wfnmerge
fnsplit, _wfnsplit
Bit Definitions for fnsplit
getcurdir, _wgetcurdir
getcwd, _wgetcwd
getdisk, setdisk
mkdir, _wmkdir
_mktemp, _wmktemp
_rmdir, _wrmdir
searchpath, wsearchpath
dos.h
FA_xxxx #defines
NFDS #define
_getdrive
_osmajor
_osminor
_osversion
_sleep
_version
disable, _disable, enable, _enable
dostounix
geninterrupt
getdate, setdate
getdfree
gettime, settime
unixtodos
_unlink, _wunlink
errno.h
EDOM, ERANGE, #defines
_doserrno
errno (C Runtime Library Reference)
Error Numbers in errno
perror,_wperror
_sys_errlist
_sys_nerr
except.h
__throwExceptionName
__throwFileName
__throwLineNumber
set_terminate
set_unexpected
terminate
unexpected
fastmath.h
Using fastmath math routines
fcntl.h
O_xxxx #defines
_fmode
_pipe
open, _wopen
_sopen, _wsopen
float.h
CW_DEFAULT #define
_chgsign, _chgsignl
_clear87, _clearfp
_control87, _controlfp
_copysign, _copysignl
_finite, _finitel
_fpclass, _fpclassl
_fpreset
_isnan, _isnanl
_logb, _logbl
_nextafter, _nextafterl
_scalb, _scalbl
_status87, _statusfp
io.h
_findclose
_findfirst, __wfindfirst
_findfirsti64, _wfindfirsti64
_findnext, __wfindnext
_findnexti64, _wfindnexti64
_get_osfhandle
_open_osfhandle
_pclose
_rtl_chmod, _wrtl_chmod
_rtl_close
_rtl_creat, _wrtl_creat
_rtl_open, _wrtl_open
_rtl_read
_rtl_write
_snprintf;_snwprintf
access, _waccess
chmod, _wchmod
chsize
close
_creat, _wcreat
creatnew
creattemp
dup
dup2
eof
filelength
_fileno
getftime, setftime
isatty
lock
locking
lseek
read
setmode
tell
umask
unlock
vsscanf
write
limits.h
CHAR_xxx #defines
INT_xxx #defines
LONG_xxx #defines
SCHAR_xxx #defines
SHRT_xxx #defines
Uxxxx_MAX #defines
locale.h
localeconv
setlocale, _wsetlocale
malloc.h
alloca
math.h
HUGE_VAL #defines
M_E, M_LOGxxx, M_LNxx #defines
M_SQRTxx #defines
PI constants
atof, _wtof
_atold, _wtold
_i64toa, _i64tow
_matherr, _matherrl
abs
acos, acosl
asin, asinl
atan, atanl
atan2, atan2l
cabs, cabsl
ceil, ceill
cos, cosl
cosh, coshl
exp, expl
fabs, fabsl
floor, floorl
fmod, fmodl
frexp, frexpl
hypot, hypotl
ldexp, ldexpl
ldiv
log, logl
log10, log10l
modf, modfl
poly, polyl
pow, powl
pow10, pow10l
sin, sinl
sinh, sinhl
sqrt, sqrtl
tan, tanl
tanh, tanhl
mem.h
memccpy
memchr, _wmemchr
memcmp
memcpy, _wmemcpy
memicmp
memmove
memset, _wmemset
setmem
new.h
_new_handler
set_new_handler function
process.h
P_xxxx #defines
_adopt_thread
_beginthread
_beginthreadNT
_beginthreadex
_c_exit
_cexit
_endthread
_endthreadex
_expand
_unadopt_thread
cwait
execl, execle, execlp, execlpe, execv, execve, execvp, execvpe, _wexecl, _wexecle, _wexeclp, _wexeclpe, _wexecv, _wexecve, _wexecvp, _wexecvpe
getpid
spawnl, spawnle, spawnlp, spawnlpe, spawnv, spawnve, spawnvp, spawnvpe, _wspawnl, _wspawnle, _wspawnlp, _wspawnlpe, _wspawnv, _wspawnve, _wspawnvp, _wspawnvpe
wait
setjmp.h
longjmp
setjmp
share.h
SH_xxxx #defines
signal.h
SIGxxxx #defines
SIG_xxx #defines
raise
signal (C RTL)
stdarg.h
va_arg, va_end, va_start
stddef.h
NULL #define
_threadid
offsetof
stdio.h
BUFSIZ #define
_F_xxxx #defines
OPEN_MAX #define
L_ctermid #define
L_tmpnam #define
TMP_MAX #define
_IOxxx #defines
_fsopen, _wfsopen
_popen, _wpopen
_vsnprintf;_vsnwprintf
clearerr
EOF #define
fclose
_fcloseall
_fdopen, _wfdopen
feof
ferror
fflush
fgetc, fgetwc
_fgetchar, _fgetwchar
fgetpos
fgets, fgetws
_flushall
fopen, _wfopen
fprintf, fwprintf
fputc, fputwc
_fputchar, _fputwchar
fputs, fputws
fread
freopen, _wfreopen
fscanf, fwscanf
fseek
fsetpos
ftell
fwrite
getc, getwc
getchar, getwchar
gets, _getws
_getw
printf, wprintf
putc, putwc
putchar, putwchar
puts, _putws
_putw
remove, _wremove
rename, _wrename
rewind
_rmtmp
scanf, wscanf
setbuf
setvbuf
snprintf;snwprintf
sprintf, swprintf
sscanf, swscanf
stderr, stdin, stdout
_tempnam, _wtempnam
tmpfile
tmpnam, _wtmpnam
ungetc, ungetwc
vfprintf, vfwprintf
vfscanf
vprintf, vwprintf
vscanf
vsnprintf;vsnwprintf
vsprintf, vswprintf
stdlib.h
EXIT_xxxx #defines
RAND_MAX #define
_argc
_argv, _wargv
_atoi64, _wtoi64
_crotl, _crotr
_exit
_fullpath, _wfullpath
_lrand
_lrotl, _lrotr
_makepath, _wmakepath
_rotl, _rotr
_searchenv, _wsearchenv
_searchstr, _wsearchstr
_splitpath, _wsplitpath
_ui64toa, _ui64tow
abort
atexit
atoi, _wtoi
atol, _wtol
bsearch
div
ecvt
_environ, _wenviron
exit
fcvt
gcvt
getenv, _wgetenv
itoa, _itow
labs
lfind
lsearch
ltoa, _ltoa, _ltow
max
mblen
mbstowcs
mbtowc
min
putenv, _wputenv
qsort
rand
random
randomize
srand
strlen, _mbslen, wcslen, _mbstrlen
strtod, _strtold, wcstod, _wcstold
strtol, wcstol
strtoul, wcstoul
swab
system, _wsystem
ultoa, _ultow
wcstombs
wctomb
string.h
_ismbblead, _ismbbtrail
_ismbclegal
_ismbslead, _ismbstrail
_mbbtype
_mbccpy
_mbsbtype
_mbsnbcmp
_mbsnbcnt, _mbsnccnt, _strncnt, _wcsncnt
_mbsnbcoll, _mbsnbicoll
_mbsnbcpy
_mbsnbicmp
_mbsnbset
_mbsninc, _strninc, _wcsninc
_mbsspnp, _strspnp, _wcsspnp
_strdec, mbsdec, _wcsdec
_strerror
_strinc, mbsinc, _wcsinc
_strnextc,_mbsnextc,_wcsnextc
stpcpy, _wstpcpy, _stpcpy
strcat, _mbscat, wcscat
strchr, _mbschr, wcschr
strcmp, _mbscmp, wcscmp
strcmpi
strcoll,_stricoll, _mbscoll, _mbsicoll, wcscoll, _wcsicoll
strcpy
strcspn, _mbscspn, wcscspn
strdup, _mbsdup, _wcsdup
strerror
stricmp, _mbsicmp, _wcsicmp
strlwr, _mbslwr, _wcslwr
strncat
strncmp, _mbsncmp, wcsncmp
strncmpi, wcsncmpi
strncoll, strnicoll, _mbsncoll, _mbsnicoll, _wcsncoll, _wcsnicoll
strncpy, _mbsncpy, wcsncpy
strnicmp, _mbsnicmp, _wcsnicmp
strnset, _mbsnset, _wcsnset
strpbrk, _mbspbrk, wcspbrk
strrchr, _mbsrchr, wcsrchr
strrev, _mbsrev, _wcsrev
strset, _mbsset, _wcsset
strspn, _mbsspn, wcsspn
strstr, _mbsstr, wcsstr
strtok, _mbstok, wcstok
strupr, _mbsupr, _wcsupr
strxfrm, wcsxfrm
sys\stat.h
S_Ixxxx #defines
_stati64, _tstati64, stati64, _wstati64
fstat, stat, _wstat
sys\timeb.h
ftime
sys\types.h
time_t
time.h
_strdate, _wstrdate
_strtime, _wstrtime
asctime
clock
clock_t
ctime, _wctime
_daylight
difftime
gmtime
localtime
mktime
stime
strftime, wcsftime
time
_timezone
tm
_tzname,_wtzname
_tzset, _wtzset
typeinfo.h
bad_cast class
bad_typeid class
type_info class
utime.h
_utime, _wutime
values.h
BITSPERBYTE #define
HIBITx #defines
MAXxxxx #defines (integer data types)
Float and Double Limits
Win32 Developer's Guide
Component Writer's Guide
Creating a graphic component
Adding Graphic Capabilities
Creating a Graphic Component
Creating and Registering the Component
Declaring the Access Properties
Declaring the Class Fields
Declaring the Property
Declaring the Property Type
Determining What to Draw
Drawing the Component Image
Initializing Owned Classes
Overriding the Constructor and Destructor
Publishing Inherited Properties
Publishing the Pen and Brush
Refining the Shape Drawing
Setting Owned Classes' Properties
Writing the Implementation Method
Creating events
Creating Events: Overview
What Are Events?
Events Are closures (C++)
Events Are Method Pointers
Calling the Click-event Handler
Events Are Properties
Event Types Are Method-pointer Types
Event Handler Types Are Procedures
Event Handlers Have A Return Type of void (C++)
Event Types Are closure Types (C++)
Event Handlers Are Optional
Implementing the Standard Events
Identifying Standard Events
Making Events Visible
Changing the Standard Event Handling
Defining Your Own Events
Triggering the Event
Two Kinds of Events
Defining the Handler Type
Declaring the Event
Calling the Event
Empty Handlers Must Be Valid
Users Can Override Default Handling
Creating methods
Abstract Methods
Avoiding Interdependencies
Creating Methods: Overview
Declaring Methods
Example of Declaring Methods
Methods That Should Be Protected
Methods That Should Be Public
Naming Methods
Protecting Methods
Making Methods Virtual
Creating properties
Creating Properties: Overview
Why Create Properties?
Types of Properties
Publishing Inherited Properties
Defining Properties
Property Declarations
Internal Data Storage
Direct Access
Access Methods (properties)
The Read Method
The Write Method
Default Property Values
Specifying No Default Value
Creating Array Properties
Creating Properties for Interfaces
Creating Properties for Subcomponents
Storing and Loading Properties
Using the Store-and-load Mechanism
Specifying Default Values
Determining What to Store
Initializing After Loading
Storing and Loading Unpublished Properties
Creating Methods to Store and Load Property Values
Overriding the DefineProperties Method
Customizing a grid
Accessing the Day, Month, and Year
Changing Initial Values
Creating and registering the component
Customizing a Grid: Overview
Excluding Blank Cells
Filling in the Cells
Generating the Day Numbers
Moving the Selection
Navigating Days
Navigating Months and Years
Providing an OnChange Event
Publishing Inherited Properties
Resizing the Cells
Selecting the Current Day
Storing the Internal Date
Tracking the Date
Extending the IDE
Adding an Action to the Action List
Adding an Image to the Image List
Creating Forms and Projects
Debugging a Wizard
Deleting Toolbar Buttons
Extending the IDE
Implementing the Wizard Interfaces
Installing the Wizard Package
Interface Version Numbers
Notifying a Wizard of IDE Events
Obtaining Tools API Services
Overview of the Tools API
Using Editor Interfaces
Using Module Interfaces
Using Native IDE Objects
Working with Files and Editors
Writing a Wizard Class
Handling messages
Broadcasting a Message to All Controls in a Form
Calling a Control's Message Handler Directly
Responding to System Events
Sending a Message That Does Not Execute Immediately
Sending a Message Using the Windows Message Queue
Sending Messages
Changing Message Handling
Creating New Message Handlers
Declaring a Message Identifier
Example: User-defined Messages
Example: Message Structure
Declaring a Message-structure Type
Declaring a New Message-handling Method
Example: Message Handler
Defining Your Own Messages
Dispatching Messages
Example: Overriding a Message Handler
Overriding the Handler Method
Handling Messages and System Notifications: Overview
Trapping Messages
The WndProc Method
Understanding the message-handling system
Using Message Parameters
What's in a Windows Message?
Introduction to component creation
Overview of Component Creation
Class library
Components and Classes
Creating Components
Modifying Existing Controls
Creating Original Controls
Creating a New Component
Creating a Unit File
Declaring A New Constructor (C++)
Deriving the Component
Creating Nonvisual Components
Creating Graphic Controls
Encapsulating Graphics
Setting Properties, Methods, and Events
Registering the Component
Removing Dependencies
Registering Components
Subclassing Windows Controls
Creating a Component with the Component Wizard
What Goes into a Component?
Making Source Files Available
Testing Installed Components
Testing Uninstalled Components
Making a control data aware
Adding the Data Link
Adding the ReadOnly property
Allowing Needed Updates
Changing the Default Value of FReadOnly
Creating a Data Browsing Control
Creating a Data Editing Control
Creating and registering the component
Declaring the Access Properties for a Data-aware Control
Declaring the Class Field
Handling Mouse-down and Key-down Messages
Initializing the Data Link
Making a Control Data Aware
Making the Control Read-only
Modifying the Change Method
Responding to Data Changes
Responding to Key-down Messages
Responding to Mouse-down Messages
Updating the Dataset
Updating the Field Data Link Class
Making components available at design time
Adding Clipboard Formats
Adding Component Editors
Adding Items to the Context Menu
Adding Property Editors
Changing the Double-click Behavior
Compiling Components into Packages
Creating the Entries
Creating the Help File
Declaring the Register Procedure
Deriving a Property-editor Class
Editing the Property as a Whole
Implementing Commands
Making Component Help Context-sensitive
Making Components Available at Design Time: Overview
Property Categories
Specifying Property Categories
Providing Help for Your Component
Registering Components
Registering Multiple Properties at Once
Registering One Property at a Time
Registering the Component Editor
Registering the Property Editor
Setting the Property Value
Specifying Editor Attributes
Specifying Menu Items
Specifying the Components
Specifying the Palette Page
Troubleshooting Custom Components (C++)
Using the IsPropertyInCategory Function
Using the RegisterComponents Function
Writing the Register Procedure
Making a dialog box a component
Adding Interface Properties
Adding the Execute Method
Creating and Registering the Component
Creating the Component Interface
Defining the Component Interface
Including the Form Unit
Making a Dialog Box a Component: Overview
Testing the Component
Modifying an existing component
Creating and Registering the Component
Modifying an Existing Component: Overview
Modifying the Component Object
Overriding the Constructor
Specifying the New Default Property Value
Object-oriented programming for component writers
Object-oriented Programming for Component Writers: Overview
Defining New Classes
Deriving New Classes
Abstract Class Members
Adding New Capabilities to a Class
Ancestors, Descendants, and Class Hierarchies
Changing Class Defaults to Avoid Repetition
Controlling Access
Declaring a New Component Class
Defining the Design-time Interface
Defining the Component Writer's Interface
Defining the Runtime Interface
Dispatching Methods
Dynamic Methods
Hiding Implementation Details
Virtual Methods
Classes and Pointers
Overriding Methods
Regular Methods (C++)
Static Methods
Using graphics in components
Creating and Managing Off-screen Bitmaps
Loading and Storing Graphics
Handling Palettes
Off-screen Bitmaps
Overview of Graphics
Using a Picture, Graphic, or Canvas
Responding to Changes
Responding to Palette Changes
Specifying a Palette for a Control
Using Graphics in Components: Overview
Using the Canvas
Working with Pictures
Developing COM-based Applications
COM basics
Overview of COM Technologies
Parts of a COM Application
COM Interfaces
The Fundamental COM Interface, IUnknown
COM Interface Pointers
COM Servers
CoClasses and Class Factories
In-process, Out-of-process, and Remote Servers
The Marshaling Mechanism
Aggregation
COM Clients
COM Extensions
Automation Servers
Active Server Pages
ActiveX Controls
Active Documents
Type Libraries
Implementing COM Objects with Wizards
Code Generated by Wizards
COM+ Event And Event Subscriber Objects
Creating an Active Server Page
Creating Active Server Pages: Overview
Creating an Active Server Object
Using the ASP Intrinsics
Creating ASPs for In-process or Out-of-process Servers
Registering an Active Server Object
Testing and Debugging the Active Server Page Application
Using ActiveX controls
Elements of an ActiveX Control
Designing an ActiveX Control
Generating an ActiveX Control Based On a VCL Form
Licensing ActiveX Controls
Customizing the ActiveX Control's Interface
Adding Additional Properties, Methods, and Events
How Delphi Adds Properties
How Delphi Adds Events
Enabling Simple Data Binding with the Type Library
Creating a Property Page for an ActiveX Control
Creating a New Property Page
Adding Controls to a Property Page
Associating Property Page Controls with ActiveX Control Properties
Updating the Property Page
Updating the Object
Connecting a Property Page to an ActiveX Control
Creating COM clients
Creating COM Clients
Importing Type Library Information
Code Generated When You Import Type Library Information
Controlling an Imported Object
Using Component Wrappers
Writing Client Code Based On Type Library Definitions
Connecting to a Server
Controlling an Automation Server Using a Dual Interface
Controlling an Automation Server Using a Dispatch Interface
Handling Events in an Automation Controller
Creating Clients for Servers That Do Not Have a Type Library
Using .NET Assemblies with Delphi
Requirements for COM Interoperability
.NET Components and Type Libraries
Accessing User-defined .NET Components
Creating simple COM servers
Creating Simple COM Servers: Overview
Designing a COM Object
Using the COM Object Wizard
Using the Automation Object Wizard
COM Object Instancing Types
Choosing a Threading Model
Defining a COM Object's Interface
Managing Events in Your Automation Object
Automation Interfaces
Dual Interfaces
Dispatch Interfaces
Custom Interfaces
Marshaling Data
Registering a COM Object
Testing and Debugging the Application
Working with type libraries
Working with Type Libraries: Overview
Type Library Editor
Parts of the Type Library Editor
Toolbar
Object List Pane
Status Bar
Pages of Type Information
Type Library Elements
Using the Type Library Editor
Valid Types
SafeArrays
Using Object Pascal or IDL Syntax
Creating a New Type Library
Opening an Existing Type Library
Adding an Interface to the Type Library
Modifying an Interface Using the Type Library
Adding Properties and Methods to the Type Library
Adding a CoClass to the Type Library
Adding an Interface to a CoClass
Adding an Enumeration to the Type Library
Adding an Alias to the Type Library
Adding a Record or Union to the Type Library
Adding a Module to the Type Library
Saving and Registering Type Library Information
Apply Updates Dialog
Saving a Type Library
Refreshing the Type Library
Registering the Type Library
Exporting an IDL File
Deploying Type Libraries
Developing Database Applications
Working with ADO components
ADO Connection Events
Accessing the Connection Object
Accessing the Connection's Datasets
Applying the Batch Updates to Base Tables
Canceling Batch Updates
Canceling Commands
Connecting to ADO Data Stores
Connecting to a Data Store Using TADOConnection
Connecting an ADO Dataset to a Data Store
Controlling Timeouts
Fetching Records Asynchronously
Filtering Multiple Rows Based On Update Status
Filtering Records Based On Bookmarks
Fine-tuning a Connection
Forcing Asynchronous Connections
Handling Command Parameters
Indicating the Types of Operations the Connection Supports
Inspecting the Update Status of Individual Rows
Loading Data from and Saving Data to Files
Opening the Dataset in Batch Update Mode
Overview of ADO Components
Retrieving Result Sets with Commands
Specifying the Command
Specifying Whether the Connection Automatically Initiates Transactions
Using ADO datasets
Using Batch Updates
Using Command Objects
Using TADODataSet
Using the Execute Method
Working with ADO Components
Working with Record Sets
Connecting to databases
Controlling Connections
Disconnecting from a Database Server
Managing Transactions
Obtaining Metadata
Sending Commands to the Server
Specifying the Transaction Isolation Level
Using Implicit Connections
Working with Associated Datasets
Connecting to Databases: Overview
Controlling Server Login
Connecting to a Database Server
Creating multi-tiered applications
Connecting to the Application Server
Creating Multi-tiered Applications: Overview
Connecting to the Server
Advantages of the Multi-tiered Database Model
Brokering Connections
Building a Multi-tiered Application
Building an InternetExpress Application
Building Web Applications Using InternetExpress
Calling Server Interfaces
Choosing a Connection Protocol
Configuring TMTSDataModule
Configuring TRemoteDataModule
Configuring TSOAPDataModule
Connecting to an Application Server That Uses Multiple Data Modules
Creating an Active Form for the Client Application
Creating the Application Server
Creating the Client Application
Creating Web Pages with an InternetExpress Page Producer
Customizing the InternetExpress Page Producer Template
Distributing a Client Application as an ActiveX Control
Dropping or Changing a Server Connection
Extending the Interface of the Application Server
Granting Permission to Access and Launch the Application Server
Managing Server Connections
Managing Transactions in Multi-tiered Applications
Overview of a Three-tiered Application
Pooling Remote Data Modules
Registering the Application Server
Setting Up the Remote Data Module
Setting Web Item Properties
Specifying a Connection Using HTTP
Specifying a Connection Using DCOM
Specifying a Connection Using SOAP
Specifying a Connection Using Sockets
Supporting Master/detail Relationships
Supporting State Information in Remote Data Modules
The Structure of the Application Server
The Structure of the Client Application
Understanding Multi-tiered Database Applications
Using an XML Broker
Using DCOM Connections
Using Transactional Data Modules
Using Multiple Remote Data Modules
Using SOAP Connections
Using Socket Connections
Using the Javascript Libraries
Using the Web Page Editor
Using Web Connections
Writing Web-based Client Applications
Creating reports with Rave Reports
Rave Component Overview
Getting More Information
Getting Started with Rave Reports
Rave Reports: Overview
Rave Visual Designer
Designing database applications
Database architecture
Connecting a Client Dataset to Another Dataset in the Same Application
Connecting Directly to a Database Server
Connecting to Another Dataset
Database Architecture
Using a Dedicated File on Disk
Using a Multi-Tiered Architecture
Combining Approaches
Designing Database Applications: Overview
Designing the user interface
Analyzing Data
Designing the User Interface
Writing Reports
Using databases
Database Security
Referential Integrity, Stored Procedures, and Triggers
Transactions
Types of Databases
Using Databases
Understanding datasets
Creating an Index with IndexFieldNames
Supplying Parameters at Design Time
Supplying Parameters at Runtime
Adding New Records
Applying or Canceling a Range
Calculating Fields
Canceling Changes
Controlling Read/Write Access to Tables
Creating and Deleting Tables
Creating Filters
Creating Master/detail Relationships
Deleting Records
Editing Records
Emptying Tables
Enabling and Disabling Filtering
Establishing Master/detail Relationships Using Parameters
Executing a Search with Find Methods
Executing a Search with Goto Methods
Executing Queries That Don't Return a Result Set
Executing Stored Procedures That Don't Return a Result Set
Fetching Multiple Result Sets
Limiting Records with Ranges
Making the Table a Detail of Another Dataset
Marking and Returning to Records
Modifying a Range
Modifying Entire Records
Navigating Records in a Filtered Dataset
Obtaining Information About Indexes
Opening and Closing Datasets
Posting Data
Preparing Queries
Preparing Stored Procedures
Searching On Partial Keys
Searching On Partial Keys
Setting Filter Options
Setting the Filter Property
Sorting Records with Indexes
Specifying Ranges
Specifying the Current Record After a Successful Search
Specifying the Query
Synchronizing Tables
Understanding the Differences Between Ranges and Filters
Using Indexes to Search for Records
Using Nested Detail Tables
Using Parameters in Queries
Using Query-type Datasets
Using Stored Procedure-type Datasets
Using TDataSet Descendants
Using Table Type Datasets
Using the Eof and Bof Properties
Using the First and Last Methods
Using the MoveBy Method
Using the Next and Prior Methods
Using Unidirectional Result Sets
Working with Stored Procedure Parameters
Using Locate
Using Lookup
Modifying Data
Searching Datasets
Specifying an Index with IndexName
Displaying and Editing a Subset of Data Using Filters
Understanding Datasets: Overview
Determining Dataset States
Navigating Datasets
Writing an OnFilterRecord Event Handler
Types of Datasets
Using the Borland Database Engine
BDE-based Architecture
Executing an Update Statement
Using an Update Component's Query Property
Using Multiple Update Objects
Calling the Apply Method
Executing the SQL Statements
Using the Borland Database Engine
Connecting to databases with TDatabase
Associating a Database Component with a Session
Connecting to Databases with TDatabase
Identifying the Database
Understanding Database and Session Component Interactions
Using Database Components in Data Modules
Setting BDE Alias Parameters
Identifying the Database
Managing database sessions
Activating a Session
Creating Additional Sessions
Iterating Through a Session's Database Components
Opening Database Connections
Searching for a Database Connection
Specifying Paradox Directory Locations
Retrieving Information About a Session
Closing Database Connections
Working with BDE Aliases
Naming a Session
Managing Multiple Sessions
Specifying Default Database Connection Behavior
Dropping Inactive Database Connections
Working with Password-protected Paradox and dBASE Tables
Managing Database Sessions
Managing Database Connections
Using BDE-enabled datasets
Associating a Dataset with Database and Session Connections
Binding Parameters
Caching BLOBs
Controlling Read/Write Access to Local Tables
Importing Data from Another Table
Working with BDE Handle Properties
Renaming a Table
Specifying a dBASE Index File
Specifying the Table Type for Local Tables
Using TQuery
Using TStoredProc
Using TTable
Using BDE-enabled Datasets
Creating Heterogenous Queries
Obtaining an Editable Result Set
Updating a Read-only Result Set
Working with Oracle Overloaded Stored Procedures
Using TBatchMove
Creating a Batch Move Component
Executing a Batch Move
The Data Dictionary
Tools for Working with the BDE
Specifying a Batch Move Mode
Using TBatchMove
Handling Batch Move Errors
Mapping Data Types
Using the BDE to cache updates
Applying Cached Updates Using a Database
Composing Update SQL Statements
Enabling BDE-based Cached Updates
Understanding Parameter Substitution in Update SQL Statements
Using the BDE to Cache Updates
Using the Update SQL Editor
Applying BDE-based Cached Updates
Using Update Objects to Update a Dataset
Creating an OnUpdateRecord Event Handler
Applying Cached Updates with Dataset Component Methods
Creating SQL Statements for Update Components
Handling Cached Update Errors
Using transactions with the BDE
Using Local Transactions
Using Passthrough SQL
Using Transactions with the BDE
Using client datasets
Adding a New Index
Adding Application-specific Information to the Data
Aggregating over groups of records
Applying Updates
Choosing the Type of Dataset for Caching Updates
Communicating with Providers Using Custom Events
Constraining Data Values
Copying Data from Another Dataset
Creating a New Dataset
Deleting and Switching Indexes
Editing Data
Getting Parameters from the Application Server
Handling Constraints from the Server
Indicating What Records Are Modified
Intervening as Updates Are Applied
Limiting Records with Parameters
Merging Changes into Data
Navigating Data in Client Datasets
Obtaining Aggregate Values
Overriding the Dataset On the Application Server
Overview of Using Cached Updates
Passing Parameters to the Source Dataset
Refreshing Records
Representing Calculated Values
Requesting Data from the Source Dataset or Document
Saving Changes
Sending Query or Stored Procedure Parameters
Setting Up a Simple Dataset
Sorting and Indexing
Specifying a Provider
Specifying Aggregates
Undoing Changes
Updating Records
Using a Client Dataset to Cache Updates
Using a Client Dataset with a Provider
Using a Client Dataset with File-based Data
Using a Simple Dataset
Using Indexes to Group Data
Using Internally Calculated Fields in Client Datasets
Using Maintained Aggregates
When to Use TSimpleDataSet
Cloning a Client Dataset Cursor
Working with Data Using a Client Dataset
Reconciling Update Errors
Assigning Data Directly
Loading Data from a File or Stream
Saving Data to a File or Stream
Using Client Datasets: Overview
Limiting What Records Appear
Using data controls
Associating a Data Control with a Dataset
Choosing How to Organize the Data
Displaying a Single Record
Changing the Associated Dataset at Runtime
Restricting Field Values with Radio Controls
Arranging the Order of Persistent Columns
Choosing Navigator Buttons to Display
Controlling Grid Drawing
Creating a Customized Grid
Creating a Grid That Contains Other Data-aware Controls
Creating Persistent Columns
Defining a Lookup List Column
Deleting Persistent Columns
Displaying ADT and Array Fields
Displaying Fly-over Help
Displaying Multiple Records
Editing in the Grid
Putting a Button in a Column
Responding to User Actions at Runtime
Restoring Default Values to a Column
Setting Column Properties at Design Time
Setting Grid Options
Using a Grid Control in Its Default State
Using a Single Navigator for Multiple Datasets
Viewing and Editing Data with TDBGrid
Navigating and Manipulating Records
Disabling and Enabling Data Display
Displaying and Editing Data in List and Combo Boxes
Displaying and Editing Data in Lookup List and Combo Boxes
Displaying and Editing Fields in an Edit Box
Displaying and Editing Graphics Fields in an Image Control
Displaying and Editing Text in a Memo Control
Displaying and Editing Text in a Rich Edit Memo Control
Displaying Data as Labels
Editing and Updating Data
Editing Data in a Control
Enabling and Disabling the Data Source
Enabling Editing in Controls On User Entry
Enabling Mouse, Keyboard, and Timer Events
Handling Boolean Field Values with Check Boxes
Refreshing Data Display
Responding to Changes Mediated by the Data Source
Using Common Data Control Features
Using TDBListBox and TDBComboBox
Using Data Controls
Using decision support components
Changing Other Decision Graph Series Properties
Changing Other Decision Graph Template Properties
Changing the Default Decision Graph Type
Changing the Series Graph Type
Creating Decision Datasets with TQuery or TTable
Creating Decision Grids
Decision Cube Properties and Events
Decision Graphs at Runtime
Decision Grids at Runtime
Decision Pivots: Runtime Behavior
Decision Support Components at Runtime
Drilling Down for Detail in Decision Grids
Limiting Dimension Selection in Decision Grids
Opening and Closing Decision Grid Fields
Overview of Decision Support Components
Decision Pivot Properties
Reorganizing Rows and Columns in Decision Grids
Saving Decision Graph Series Settings
Setting Decision Graph Template Defaults
Setting Dimension State
Setting Maximum Dimensions, Summaries, and Cells
Setting the Maximum Available Dimensions and Summaries
Using Paged Dimensions
Viewing and Changing Design Options
Viewing and Changing Dimension Settings
Viewing Overall Decision Graph Properties
One-Dimensional Crosstabs
Using Decision Graphs
The Decision Graph Display
Using the Decision Cube Editor
Creating and Using Decision Graphs
Multidimensional Crosstabs
Using Decision Cubes
Decision Grid Properties
Using Decision Pivots
Customizing Decision Graph Series
Using Datasets with Decision Support Components
Using Decision Support Components
Decision Support Components and Memory Control
Using Decision Grids
Customizing Decision Graphs
Creating Decision Graphs
Creating Decision Datasets with the Decision Query Editor
Using Decision Sources
Creating and Using Decision Grids
About Crosstabs
Guidelines for Using Decision Support Components
Using provider components
Responding to Client Update Requests
Adding Custom Information to Data Packets
Applying Updates to Datasets That do Not Represent a Single Table
Choosing How to Apply Updates Using a Dataset Provider
Communicating with the Client Dataset
Controlling What Information Is Included in Data Packets
Determining the Source of Data
Editing Delta Packets Before Updating the Database
Handling Server Constraints
Influencing How Updates Are Applied
Resolving Update Errors On the Provider
Responding to Client Data Requests
Responding to Client-generated Events
Screening Individual Updates
Setting Options That Influence the Data Packets
Specifying What Fields Appear in Data Packets
Using Provider Components
Using dbExpress Components
Using dbExpress Datasets
Accessing Schema Information
Connecting to the Database Server
Creating and Modifying Server Metadata
Debugging dbExpress Applications
Executing Commands That Do Not Return Records
Executing the Command
Fetching Metadata into a dbExpress Dataset
Fetching the Data
Representing the Records in a Table
Representing the Results of a Query
Representing the Results of a Stored Procedure
Setting Up Master/Detail Linked Relationships
Setting Up TSQLConnection
Specifying the Command to Execute
Specifying What Data to Display
Types of dbExpress Datasets
The Structure of Metadata Datasets
Using XML in database applications
Converting XML Documents into Data Packets
Defining Transformations
Mapping Between XML Nodes and Data Packet Fields
Using an XML Document as the Client of a Provider
Using an XML Document as the Source for a Provider
Using XML in Database Applications
Using XMLMapper
Working with field components
Accessing Field Values with a Dataset's FieldByName Method
Accessing Field Values with a Dataset's Fields Property
Arranging Persistent Fields
Associating Attribute Sets with Field Components
Creating a Custom Constraint
Defining a Data Field
Defining an Aggregate Field
Defining New Persistent Fields
Deleting Persistent Field Components
Displaying, Converting, and Accessing Field Values
Displaying Field Component Values in Standard Controls
Persistent Field Components
Removing Attribute Associations
Setting a Default Value for a Field
Setting Display and Edit Properties at Design Time
Using Object Fields
Using Server Constraints
Working with Constraints
Working with Field Component Methods at Runtime
Working with ADT Fields
Working with Array Fields
Working with DataSet Fields
Working with Reference Fields
Defining a Lookup Field
Creating Attribute Sets for Field Components
Programming a Calculated Field
Setting Persistent Field Properties and Events
Handling Events
Accessing Field Values with the Default Dataset Property
Defining a Calculated Field
Using Default Formatting for Numeric, Date, and Time Fields
Setting Field Component Properties at Runtime
Creating Persistent Fields
Converting Field Values
Dynamic Field Components
Working with Field Components: Overview
Controlling and Masking User Input
Programming with Delphi
Building applications, components, and libraries
Creating packages and DLLs
Creating DLLs Containing VCL Components (C++)
Creating Packages and DLLs
Linking DLLs
When to Use Packages and DLLs
Using DLLs in RAD Studio (C++)
Creating Applications
Creating Web server applications
Creating Web Services Applications
Creating WebSnap Applications
Creating Web Broker Applications
Creating Web Server Applications
Enabling Help in applications
Asking the Help Manager for Information
Calling a Help System Directly
Communicating with the Help Manager
Customizing the IDE Help System
Displaying Keyword-based Help
Displaying Tables of Contents
Enabling Help in Applications
Help System Interfaces
How TApplication Processes VCL Help
How VCL Controls Process Help
Implementing ICustomHelpViewer
Implementing IExtendedHelpViewer
Implementing IHelpSelector
Registering Help System Objects
Using Help in a VCL Application
Using IHelpSystem
GUI applications
Setting IDE, Project, and Compiler Options
Console Applications
MDI Applications
Code Templates
SDI Applications
User Interface Models
GUI Applications
Service applications
Debugging Service Applications
Service Applications
Service Name Properties
Service Threads
Using data modules
Accessing a Data Module from a Form
Adding a Remote Data Module to an Application Server Project
Creating and Editing Standard Data Modules
Creating Business Rules in a Data Module
Using Data Modules
Naming a Data Module and Its Unit File
Placing and Naming Components
Using Component Properties and Events in a Data Module
Using the Object Repository
Adding Items to the Object Repository
Copying an Item
Inheriting an Item
Modifying Shared Items
Sharing Items Within a Project
Sharing Objects in a Team Environment
Using an Item
Using an Object Repository Item in a Project
Using Project Templates
Using the Object Repository
Writing applications using COM
Writing Applications Using COM
Writing database applications
Distributing Database Applications
Writing Database Applications
Creating international applications
Additional Methods
Character Sets
Creating International Applications: Overview
Creating Resource DLLs
Designing the User Interface
Multibyte Character Sets
Dynamic Switching of Resource DLLs
Enabling Application Code
FlipChildren Method
Formats and Sort Order
Graphic Images
Including Bi-directional Functionality in Applications
Internationalization
Internationalization and Localization
Internationalizing Applications
Isolating Resources
Keyboard Mappings
Locale-specific Features
Localization
Localizing Applications
OEM and ANSI Character Sets
ParentBiDiMode Property
Text
Using Resource DLLs
Wide Characters
Delphi programming fundamentals
Designing Applications
Creating Projects
Editing Code
Compiling Applications
Debugging Applications
Deploying Applications
Deploying applications
Deploying BDE Applications
Deploying dbExpress Database Applications
Deploying On Apache Servers
Accommodating Varying Color Depths
ActiveX Controls
Application Files, Listed by File Name Extension
Borland Database Engine
Considerations When Dynamically Resizing Forms and Controls
Considerations When Not Dynamically Resizing
DLL Locations
Deploying Applications: Overview
Deploying Database Applications
Deploying General Applications
Deploying Web Applications
Fonts
Helper Applications
Identifying Application Files
Merge Modules
Deploying Multi-tiered Database Applications (DataSnap)
Package Files
Programming for Varying Host Environments
Screen Resolutions and Color Depths
Software License Requirements
Using Installation Programs
Operating System Versions
Developing the application user interface
Adding Forms
Adding Color, Patterns, or Pictures to Menus, Buttons, and Toolbars
Adding Icons to Menus and Toolbars
Adding Images to Menu Items
Adding, Inserting, and Deleting Menu Items
Adding a Cool Bar Component
Adding a Speed Button to a Panel
Adding a Toolbar Using a Panel Component
Adding a Toolbar Using the Toolbar Component
Adding a Tool Button
Adding Hidden Toolbars
Allowing Toggle Buttons
Allowing Toggled Tool Buttons
Assigning a Menu to a Tool Button
Assigning a Speed Button's Glyph
Assigning Images to Tool Buttons
Building Menus
Common Controls and XP Themes
Controlling When Forms Reside in Memory
Creating and Managing Menus
Creating and Using Component Templates
Creating Customizable Toolbars and Menus
Creating Dynamic Menus
Creating Frames
Creating Most Recently Used Lists
Creating Submenus
Creating Toolbars and Menus
Creating a Group of Speed Buttons
Creating Forms Dynamically
Creating Groups of Tool Buttons
Creating Modeless Forms Such as Windows
Demo Programs: Actions, Action Lists, Menus, and Toolbars
Designing Toolbars and Cool Bars
Determining the Order of Merged Menu Items: GroupIndex Property
Developing the Application User Interface: Overview
Displaying an Auto-created Form
Editing Menu Items in the Object Inspector
What Happens When an Action Fires
Handling the Screen
Hiding the Main Form
Hiding Unused Items and Categories in Action Bands
Hiding and Showing Toolbars
How Actions Find Their Targets
Developing Dialog Boxes
Importing Resource Files
Managing Layout
Manipulating Menu Items at Runtime
Merging Menus
Using Forms
Moving Menu Items
Naming Conventions for Template Menu Items and Event Handlers
Naming Menus
Naming the Menu Items
Opening the Menu Designer
Organizing Actions for Toolbars and Menus
Passing Additional Arguments to Forms
Predefined Action Classes
Registering Actions
Responding to Clicks
Retrieving Data from Forms
Retrieving Data from Modal Forms
Retrieving Data from Modeless Forms
Reusing Components and Groups of Components
Saving a Menu as a Template
Selecting Menu and Toolbar Styles
Setting Up Action Bands
Setting Up Action Lists
Setting the Appearance of the Cool Bar
Setting the Initial Condition of a Speed Button
Setting Tool Button Appearance and Initial Conditions
Sharing Frames
Specifying Accelerator Keys and Keyboard Shortcuts
Specifying the Active Menu: Menu Property
Switching Between Menus at Design Time
Controlling Application Behavior
Updating Actions
Using Action Lists
Using and Modifying Frames
Using Menu Templates
Using the Main Form
Using the Menu Designer Context Menu
Creating a Form Instance Using a Local Variable
Viewing the Menu
What Is an Action?
Working at the Application Level
Working with Frames
Writing Action Components
Using Windows Common Dialog Boxes
Exception handling
Unwinding Exceptions (C++)
Exception Handling Options (C++)
Constructors In Exception Handling (C++)
Defining Protected Blocks
Exception Handling
Exception-handling Statements
Throwing An Exception (C++)
Raising an Exception
Reraising Exceptions
Smart Pointers (C++)
Scope of Exception Handlers
Silent Exceptions
Writing A finally Block
Writing a Finally Block
Writing Exception Handlers
Writing finally Blocks
Writing the Try Block
Handling Classes of Exceptions
Types of controls
Value List Editors (VCL Only)
Animation Control
Bevels
Bitmap Buttons
Button Controls
Buttons and Similar Controls
Check Boxes
Combo Boxes
Cool Bars (VCL Only)
Draw Grids
Graphic Controls
Group Boxes and Radio Groups
Grouping Controls
List Controls
Header Controls
Help and Hint Properties
Hot Key Controls (VCL Only)
Images
Labels
List Boxes and Check-list Boxes
List Views
Memo and Rich Edit Controls
Page Controls
Paint Boxes
Panels
Progress Bars
Radio Buttons
Scroll Bars
Scroll Boxes
Shapes
Specialized Input Controls
Speed Buttons
Splitter Controls
Status Bars
String Grids
Tab Controls
Grids
Edit Controls
Toolbars
Track Bars
Tree Views
Up-down Controls (VCL Only)
Display Controls
Text Controls
Text Viewing Controls
Understanding the component library
Understanding the Component Library
Properties, Methods, and Events
Types of Events
Objects, Components, and Controls
TObject Branch
TPersistent Branch
TComponent Branch
TControl Branch
TWinControl/TWidgetControl Branch
Using the object model
Using Object Variables
Changing the Name of a Component
Components and Ownership
Creating, Instantiating, and Destroying Objects
Examining a Delphi Object
Inheriting Data and Code from an Object
Private, Protected, Public, and Published Declarations
Scope and Qualifiers
Using the Object Model
What Is an Object?
TInterfacedObject
Defining New Classes
Aggregation
Implementing IInterface
Memory Management of Interface Objects
Not Using Reference Counting
Reusing Code and Delegation
Using Interfaces Across the Hierarchy
Using Implements for Delegation
Using Interfaces
Using Interfaces in Distributed Applications
Using Interfaces with Procedures
Using Reference Counting
Using the as Operator with Interfaces
Using the VCL/RTL
Using the VCL/RTL: Overview
Adding New Measurement Types
Approaches to File I/O
Common List Operations
Converting Measurements
Copying and Clearing Custom Variants
Copying Data from One Stream to Another
Creating a Class to Enable the Custom Variant Type
Creating a Simple Conversion Family and Adding Units
Defining Custom Variants
Enabling Casting
Use __fastcall When Overriding VCL Methods
Working with ini Files and the System Registry
Using Streams
Using TRegistry
Implementing Binary Operations
Implementing Comparison Operations
Implementing Unary Operations
Loading and Saving Custom Variant Values
Performing Conversions
Persistent Lists
Specifying the Stream Position and Size
Storing a Custom Variant Type's Data
String Dependencies
Supporting Properties and Methods in Custom Variants
Using a Class to Manage Conversions
Using a Conversion Function
Using Streams to Read or Write Data
Using the TCustomVariantType Descendant
Writing Utilities to Work with a Custom Variant Type
Commonly Used Long String Routines
Commonly Used Routines for Null-terminated Strings
Compiler Directives for Strings
Copying a File
Declaring and Initializing Strings
Deleting a File
File Date-time Routines
Finding a File
Manipulating Files
Mixing and Converting String Types
Passing a Local Variable as a PChar
Creating Drawing Spaces
Printing
Using TRegistryIniFile
Renaming a File
Returning a PChar Local Variable
String to PChar Conversions
Using TIniFile and TMemIniFile
Using File Streams
Accessing a Particular String
Adding a String to a List
Associating Objects with a String List
Copying a Complete String List
Counting the Strings in a List
Creating a New String List
Deleting a String from a List
Locating Items in a String List
Iterating Through Strings in a List
Loading and Saving String Lists
Manipulating Strings in a List
Working with Lists
Working with String Lists
Wide Character Routines
Working with Files
Working with Strings
Working with components
Adding Custom Components to the Tool Palette
Associating Menu Events with Event Handlers
Calling Methods
Deleting Event Handlers
Displaying and Coding Shared Events
Associating an Event with an Existing Event Handler
Generating a New Event Handler
Generating a Handler for a Component's Default Event
Locating Event Handlers
Setting Properties at Design Time
Setting Component Properties
Setting Properties at Runtime
Using Property Editors
Using the Sender Parameter
Working with Events and Event Handlers
Working with controls
Accepting Dragged Items
Adding Graphical Objects to a String List
Adding Graphics to Controls
Adding Images to a String List
Adding Images to an Application
Adding Scroll Bars at Runtime
Adding the Clipboard Object
Changing the Drag Mouse Pointer
Controlling How Child Controls Are Docked
Controlling How Child Controls Are Undocked
Controlling How Child Controls Respond to Drag-and-dock Operations
Customizing Drag and Drop with a Drag Object
Cutting, Copying, and Pasting Text
Deleting Selected Text
Disabling Menu Items
Implementing Drag and Drop in Controls
Drawing Owner-draw Items
Drawing Owner-drawn Items
Dropping Items
Ending a Drag Operation
Handling the OnPopup Event
Implementing Drag and Dock in Controls
Making a Control a Dockable Child
Making a Windowed Control a Docking Site
Providing a Pop-up Menu
Selecting All Text
Selecting Text
Indicating That a Control Is Owner-drawn
Setting Text Alignment
Sizing Owner-draw Items
Starting a Drag Operation
Working with Text in Controls
Working with graphics and multimedia
Changing the Brush Style
Overview of Graphics Programming
Working with Multimedia
Adding Audio and/or Video Clips to an Application
Adding Silent Video Clips to an Application
Example of Adding Audio and/or Video Clips (VCL Only)
Example of Adding Silent Video Clips
Adding a Field to a Form Object to Track Mouse Actions
Adding an Image Control
Changing the Brush Color
Changing the Pen Color
Changing the Pen Mode
Changing the Pen Style
Changing the Pen Width
Changing the Tool with Speed Buttons
Common Properties and Methods of Canvas
Copying Graphics to the Clipboard
Cutting Graphics to the Clipboard
Drawing Lines
Drawing Lines and Polylines
Drawing On a Graphic
Drawing On the Bitmap
Drawing Polygons
Drawing Polylines
Drawing Rectangles and Ellipses
Drawing Rounded Rectangles
Drawing Shapes
Drawing Shapes
Getting the Pen Position
Handling Multiple Drawing Objects in Your Application
Keeping Track of Which Drawing Tool to Use
Loading a Picture from a File
Loading and Saving Graphics Files
Making Scrollable Graphics
Pasting Graphics from the Clipboard
Placing the Control
Reading and Setting Pixels
Refining Line Drawing
Refreshing the Screen
Replacing the Picture
Responding to a Mouse Move
Responding to a Mouse-down Action
Responding to a Mouse-up Action
Responding to the Mouse
Rubber Banding Example
Saving a Picture to a File
Setting the Brush Bitmap Property
Setting the Initial Bitmap Size
Sharing Code Among Event Handlers
Tracking Movement
Tracking the Origin Point
Types of Graphic Objects
Using Brushes
Using Canvas Methods to Draw Graphic Objects
Using Drawing Tools
Using Pens
Using the Clipboard with Graphics
Using the Properties of the Canvas Object
What's in a Mouse Event
Working with Graphics and Multimedia: Overview
Working with packages and components
Loading Packages with the LoadPackage Function
Working with Packages and Components: Overview
Compiling Packages
Creating and Editing Packages
Creating a Package
Custom Packages
Deciding Which Runtime Packages to Use
Deploying Packages
Design-time Packages
Editing an Existing Package
Editing Package Source Files Manually
Installing Component Packages
Package Collection Files
Package Files Created by Compiling
Packages and Standard DLLs
Package-specific Compiler Directives
Runtime Packages
Understanding the Structure of a Package
Loading Packages in an Application
Compiling and Linking from the Command Line
Weak Packaging
Why Use Packages?
Writing multi-threaded applications
Coordinating threads
Other Techniques for Sharing Memory
Avoiding Simultaneous Access
Coordinating Threads
Locking Objects
Using Critical Sections
Using the Multi-read Exclusive-write Synchronizer
Waiting for a Task to Be Completed
Waiting for a Thread to Finish Executing
Waiting for Other Threads
Writing Multi-threaded Applications
Defining thread objects
Checking for Termination by Other Threads
Defining Thread Objects
Handling Exceptions in the Thread Function
Initializing the Thread
Using the Main VCL Thread
Using Thread-local Variables
Writing Clean-up Code
Writing the Thread Function
Executing thread objects
Assigning Separate Names to Similar Threads
Converting an Unnamed Thread to a Named Thread
Naming a Thread
Debugging Multi-threaded Applications
Executing Thread Objects
Overriding the Default Priority
Starting and Stopping Threads
Writing Internet Applications
Creating Internet server applications
Debugging server appliations
Debugging Web Applications That Are DLLs
Debugging Server Applications
Using the Web Application Debugger
About Web Broker and WebSnap
HTTP server activity
Composing Client Requests
HTTP Server Activity
Responding to Client Requests
Serving Client Requests
Types of Web Server Applications
Creating Internet Applications: Overview
Terminology and standards
HTTP Request Header Information
Parts of a Uniform Resource Locator
Terminology and Standards
Using IntraWeb
Getting started with IntraWeb
Getting Started with IntraWeb
Creating a New VCL for the Web Application
Editing the Main Form
Writing an Event Handler for the Button
Running the Completed Application
Using IntraWeb Components
Creating Web Server Applications Using IntraWeb
Using IntraWeb with Web Broker and WebSnap
Using Web Broker
Generating the content of response messages
Using database information in responses
Adding a Session to the Web Module
Embedding Tables in HTML Documents
Representing a Dataset in HTML
Specifying the Columns
Specifying the Row Attributes
Specifying the Table Attributes
Using Dataset Page Producers
Using Database Information in Responses
Using TDataSetTableProducer
Using TQueryTableProducer
Using Table Producers
Chaining Page Producers Together
Converting HTML-transparent Tags
Generating the Content of Response Messages
HTML Templates
Specifying the HTML Template
Using Page Producer Components
Using Page Producers from an Action Item
Using Predefined HTML-transparent Tag Names
Using Web Broker
The structure of a Web Broker application
Accessing client request information
Accessing Client Request Information
Properties That Contain Request Header Information
Properties That Describe the Content
Properties That Describe the Expected Response
Properties That Describe the Web Client
Properties That Identify the Purpose of the Request
Properties That Identify the Target
The Content of HTTP Request Messages
Adding Actions to the Dispatcher
Action items
Action Items
Choosing a Default Action Item
Determining When Action Items Fire
Enabling and Disabling Action Items
Responding to Request Messages with Action Items
The Request Method Type
The Target URL
Dispatching Request Messages
Creating HTTP response messages
Creating HTTP Response Messages
Describing the Content
Describing the Server Application
Filling in the Response Header
Indicating the Need for Client Action
Indicating the Response Status
Sending the Response
Setting the Response Content
The Structure of a Web Broker Application
The Web dispatcher
The Web Dispatcher
Creating Web Server Applications with Web Broker
The Web Application Object
The Web Module
Using Web Services
Adding New Web Services
Browsing for Business Services
Calling Invokable Interfaces
Creating Custom Exception Classes for Web Services
Defining and Using SOAP Headers
Generating WSDL Documents for a Web Service Application
Importing WSDL Documents
Processing Headers in Client Applications
Registering Nonscalar Types
Remotable Object Example
Understanding Invokable Interfaces
Using Nonscalar Types in Invokable Interfaces
Using Remotable Objects
Using the SOAP Application Wizard
Using the WSDL Importer
Using Web Services
Writing Clients for Web Services
Writing Servers that Support Web Services
Using WebSnap
Creating Web server applications with WebSnap
Advanced HTML Design
Specifying Application Module Components
Creating Web Server Applications with WebSnap
Selecting a Server Type
Selecting Web Application Module Options
Creating Web Server Applications Using WebSnap
Dispatching requests and responses
Adapter dispatcher operation
Adapter Dispatcher Operation
Receiving Adapter Requests and Generating Responses
Dispatcher Components
Dispatching Action Items
Dispatching Requests and Responses
Page dispatcher operation
Fundamental WebSnap components
Web modules
Web Application Module Types
Web Data Modules
Web Modules
Web Page Modules
Adapters
Fundamental WebSnap Components
Page Producers
Login support
Adding Login Support
Login Pages
Login Support
Setting Pages to Require Logins
User Access Rights
Using the Sessions Service
Server-side scripting in WebSnap
Script Objects
Server-side Scripting in WebSnap
Working with sockets
Describing sockets
Describing Sockets
Describing the Host
Using Ports
Working with Sockets
Implementing services
Implementing Services
Services and Ports
Understanding Service Protocols
Reading and writing over socket connections
Blocking Connections
Non-blocking Connections
Reading and Writing Events
Reading and Writing Over Socket Connections
Responding to socket events
Client Events
Error Events
Responding to Socket Events
Server Events
Types of socket connections
Client Connections
Listening Connections
Server Connections
Types of Socket Connections
Using socket components
Using client sockets
Closing the Connection
Forming the Connection
Getting Information About the Connection
Specifying the Desired Server
Using Client Sockets
Using Socket Components
Using server sockets
Closing Server Connections
Connecting to Clients
Listening for Client Requests
Specifying the Port
Using Server Sockets
Getting Information About the Connection
Working with XML documents
Working with XML Documents
Using the Document Object Model
Working with XML Components
Using TXMLDocument
Working with XML Nodes
Abstracting XML Documents with the Data Binding Wizard
Using the XML Data Binding Wizard
Using Code That the XML Data Binding Wizard Generates
Copyright(C) 2008 CodeGear(TM). All Rights Reserved.
