Index

. (direct Member Selector)

. operator

?: operator

__declspec(uuid(“ComObjectGUID”))

[

[ ] operator

__declspec(dllexport)

__declspec(dllimport)

__declspec(selectany)

__declspec(thread)

__declspec,

__declspec, dllexport

__declspec, dllimport

__declspec, naked

__has_nothrow_copy_constructor

__declspec, noreturndeclspec, noreturn

__declspec, nothrow

__declspec, novtable

__declspec, property

__declspec, selectany

__declspec, thread

__declspec, uuid

__finally,

__FUnloadDelayLoadedDLL

__has_nothrow_assign

__has_nothrow_default_constructor

__has_trivial_assign

__has_trivial_copy_constructor

__has_trivial_default_constructor

__has_trivial_destructor

__has_virtual_destructor

__import

__int8, __int16, __int32, __int64, Unsigned __int64, Extended Integer Types

__inline

__int8, __int16, and so forth

__is_complete_type (typename T )

__is_lvalue_reference

__is_member_function_pointer

__is_member_object_pointer

__is_rvalue_reference

__is_unsigned ( typename T )

__pfnDliNotifyHook, __pfnDliFailureHook

__property

__published

__rtti

__thread, Multithread Variables

__rtti, -RT Option

_bool __has_trivial_destructor (typename T )

_findfirsti64, _wfindfirsti64

_control87, _controlfp

_copysign, _copysignl

_export

_fastcall

_fastcall, __fastcall

_fcloseall

_fdopen, _wfdopen

_fgetchar, _fgetwchar

_fileno

_findclose

_findfirst, __wfindfirst

_findnext, __wfindnext

_findnexti64, _wfindnexti64

_fputchar, _fputwchar

_fsopen, _wfsopen

_fullpath, _wfullpath

_ismbblead, _ismbbtrail

_ismbclegal

_ismbslead, _ismbstrail

_makepath, _wmakepath

_mbslen, strlen, wcslen, _mbstrlen

_mbsnbcmp

_mbsnbcnt, _mbsnccnt, _strncnt, _wcsncnt

_mbsnbcoll, _mbsnbicoll

_mbsnbcpy

_mbsnbicmp

_mbsnbset

_mbsninc, _strninc, _wcsninc

_mbsspnp, _strspnp, _wcsspnp

_mktemp, _wmktemp

_msize

_new_handler

_nextafter, _nextafterl

_rtl_chmod, _wrtl_chmod

_rtl_close

_rtl_creat, _wrtl_creat

_rtl_heapwalk

_rtl_open, _wrtl_open

_rtl_read

_rtl_write

_scalb, _scalbl

_searchenv, _wsearchenv

_searchstr, _wsearchstr

_splitpath, _wsplitpath

_stati64, _tstati64, stati64, _wstati64

_stdcall

_strdec, mbsdec, _wcsdec

_strerror

_strinc, mbsinc, _wcsinc

_strnextc,_mbsnextc,_wcsnextc

_strtime, _wstrtime

_sys_errlist

_sys_nerr

_TCHAR maps to (C++ option)

_unsigned __int_alignment_of( typename T )

<name> is not a valid identifier (C++)

_utime, _wutime

_version

_vsnprintf;_vsnwprintf

_wsearchenv,, _searchenv

_wsearchstr, _searchstr

_wsplitpath, _splitpath

_wtoi, atoi

+ operator

++ operator

-> (indirect Member Selector)

>, <, >=, <= Relational Operators

Abnormal program termination (C++)

abort

abort And Destructors

About Crosstabs

About The main() Function

About Web Broker and WebSnap

abs

Abstract Class Members

abstract classes

Abstracting XML Documents with the Data Binding Wizard

Accepting Dragged Items

Access Errors

Access Methods (properties)

access specifiers

access, _waccess

accessing

Accessing a Data Module from a Form

Accessing a Particular String

Accessing client request information

Accessing Client Request Information

Accessing dbExpress Schema Information

Accessing Elements Of A namespace

Accessing Field Values with a Dataset's FieldByName Method

Accessing Field Values with a Dataset's Fields Property

Accessing Field Values with the Default Dataset Property

Accessing Schema Information

Accessing the Connection Object

Accessing the Connection's Datasets

Accessing the Day, Month, and Year

Accommodating Varying Color Depths

acos, acosl

action bands

creating dynamic menus

creating most recently used lists

action editor

action lists

component writing using

Active Forms

Active Server Objects

out-of-process servers

registering

testing and debugging

Active server page

Active Server Page

ActiveX applications

ActiveX buttons

creating in a VCL form

ActiveX controls

adding additional properties

connecting with property page

creating a property page

Adapter dispatcher operation

Adapter Dispatcher Operation

Adapters

Adding a CoClass to the Type Library

Adding a Cool Bar Component

Adding a Field to a Form Object to Track Mouse Actions

Adding a Module to the Type Library

Adding a New Connection to the Data Explorer

Adding a New Index

Adding a Record or Union to the Type Library

Adding a Remote Data Module to an Application Server Project

Adding a Session to the Web Module

Adding a Speed Button to a Panel

Adding a String to a List

Adding a Tool Button

Adding a Toolbar Using a Panel Component

Adding a Toolbar Using the Toolbar Component

Adding Actions to the Dispatcher

Adding Additional Properties, Methods, and Events

Adding an Action to the Action List

Adding an Alias to the Type Library

Adding an Enumeration to the Type Library

Adding an Image Control

Adding an Image to the Image List

Adding an Interface to a CoClass

Adding an Interface to the Type Library

Adding and Sorting Strings

Adding Application-specific Information to the Data

Adding Audio and/or Video Clips to an Application

Adding Clipboard Formats

Adding Color, Patterns, or Pictures to Menus, Buttons, and Toolbars

Adding Commands to the Ribbon

Adding Component Editors

Adding Controls to a Property Page

Adding Custom Components to the Tool Palette

Adding Custom Information to Data Packets

Adding Forms

Adding Graphic Capabilities

Adding Graphical Objects to a String List

Adding Graphics to Controls

Adding Hidden Toolbars

Adding Icons to Menus and Toolbars

Adding Images to a String List

Adding Images to an Application

Adding Images to Menu Items

Adding Interface Properties

Adding Items to the Context Menu

Adding Items to the Object Repository

Adding Login Support

Adding New Capabilities to a Class

Adding New Measurement Types

Adding New Records

Adding New Web Services

Adding Properties and Methods to the Type Library

Adding Property Editors

Adding Rave Reports to RAD Studio

Adding Scroll Bars at Runtime

Adding Silent Video Clips to an Application

Adding the Clipboard Object

Adding the Data Link

Adding the Execute Method

Adding the ReadOnly property

Adding, Inserting, and Deleting Menu Items

Additional Methods

ADO

asynchronous fetching

batch updates

connecting to data stores

connection components

connection modes

connection object

recordset objects

ADO command components

SQL commands

ADO components

databases

ADO connection components

associated commands

connections

ADO Connection Events

ADO connections

Advantages of the Multi-tiered Database Model

aggregate fields

defining

Aggregating over groups of records

aggregation

alias

alignof Operator (C++0x)

alloc.h

alloca

Allowing Needed Updates

Allowing Toggle Buttons

Allowing Toggled Tool Buttons

Alternative Representations of Tokens

Ancestors, Descendants, and Class Hierarchies

and

Application Files, Listed by File Name Extension

and, &&

and_eq, &=

animation

AVI

anonymous methods

anonymous namespaces

AnsiStringT and code page

application

application files

Application is running (C++)

application servers

access and launch permissions

applications

Applying BDE-based Cached Updates

Applying Cached Updates Using a Database

Applying Cached Updates with Dataset Component Methods

Applying or Canceling a Range

Applying the Batch Updates to Base Tables

Applying Updates

Applying Updates to Datasets That do Not Represent a Single Table

Approaches to File I/O

architecture

BDE-based

single-tiered applications

Arguments to main()

arithmetic operators

Arranging Persistent Fields

Arithmetic Operators

Arranging the Order of Persistent Columns

array

fields

Array Subscript Operator

arrays

Asking the Help Manager for Information

as operator

asm

Assigning a Menu to a Tool Button

Assigning a Speed Button's Glyph

Assigning Data Directly

Assigning Images to Tool Buttons

Assigning Separate Names to Similar Threads

assignment

Associating a Data Control with a Dataset

Assignment Operators

Assignment To Enum Types

Associating a Database Component with a Session

Associating a Dataset with Database and Session Connections

Associating an Event with an Existing Event Handler

Associating Attribute Sets with Field Components

Associating Menu Events with Event Handlers

Associating Objects with a String List

Associating Property Page Controls with ActiveX Control Properties

atan, atanl

atan2, atan2l

atexit

atexit, #pragma exit, And Destructors

Attributes noreturn and final (C++0x)

audio

Automation

Automation controller

dispatch interface

Automation controllers

importing a type library

writing

Automation Interfaces

Automation server

Automation servers

avi

Avoiding Interdependencies

Avoiding Simultaneous Access

Avoiding Simultaneous Thread Access to the Same Memory

Base And Derived Class Access

base classes

BCC32, the C++ Command-Line Compiler

batch operations

batch updates

BatchMove component

BCC32.EXE

BDE

utilities

BDE Overview

BDE-based Architecture

BeforeUpdateRecord event

Bit Definitions for fnsplit

bit fields

Bit Fields

bitand

bitmaps

bitor

bitwise operators,

Blackfish SQL

Blackfish SQL Overview

BLOBs

caching

blocking connections

Blocking Connections

blocks

Blocks

bool

bool __is_abstract (typename T )

bool __is_empty( typename T )

bool __ has_nothrow_copy_constructor( typename T )

bool __has_nothrow_assign ( typename T )

bool __has_nothrow_default_constructor( typename T )

bool __has_trivial_assign( typename T )

bool __has_trivial_default_constructor(typename T )

bool __has_virtual_destructor ( typename T )

bool __is_arithmetic(Typename T)

bool __is_array( Typename T )

bool __is_base_of ( typename Base, typename Derived )

bool __is_class(T)

bool __is_complete_type(T)

bool __is_compound( typename T )

bool __is_const (typename T)

bool __is_convertible (typename From, typename To )(typename T)

bool __is_enum_type( typename T )

bool __is_floating_point( typename T )

bool __is_function( typename T )

bool __is_fundamental (typename T)

bool __is_integral( typename T )

bool __is_lvalue_expr( typename T )

bool __is_lvalue_reference(typename T)

bool __is_member_function_pointer( typename T )

bool __is_member_object_pointer( typename T )

bool __is_member_pointer( typename T )

bool __is_object( typename T )

bool __is_pod( typename T )

bool __is_pointer( Typename T )

bool __is_polymorphic( typename T )

bool __is_reference( typename T )

bool __is_rvalue_expr( typename T )

bool __is_rvalue_reference( typename T )

bool __is_same ( typename T, typename U )

bool __is_scalar( typename T )

bool __is_signed( typename T )

bool __is_standard_layout(typename T)

bool __is_trivial( typename T )

bool __is_union( typename T )

bool __is_unsigned( typename T )

bool __is_void(typename T)

bool __is_volatile( typename T )

bool, false, true

bool_has __trivial_default_constructor( typename T )

Borland Database Engine

aliases

BRC32, the Resource Shell

direct calls

BRC32.EXE

BRCC32.EXE

BRCC32.EXE, the Resource Compiler

briefcase model

Broadcast method

Broadcasting a Message to All Controls in a Form

Brokering Connections

browsing a database

Browsing a Database in the Data Explorer

brush bitmap property

Building a "Hello World" Web Services Application

Building a Multithreaded Application

Building a Multi-tiered Application

Building a VCL Forms "Hello World" Application

Building a VCL Forms ADO Database Application

Building a VCL Forms Application

Building a VCL Forms Application with Decision Support Components

Building a VCL Forms dbExpress Database Application

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

Building a VCL Forms Web Browser Application

Building a WebSnap "Hello World" Application

Building a WebSnap Application

Building a Windows "Hello World" Console Application

Building an Application with XML Components

Building an InternetExpress Application

Building Application Menus

Building applications, components, and libraries

Building Menus

Building VCL Forms Applications With Graphics

Building Web Applications Using InternetExpress

button control

Buttons and Similar Controls

C compiler preprocessor

C Runtime Library Reference

C++ Classes

C++ compiler

command line

conversion via user-defined operators

C++ Compiler Errors And Warnings (C++)

C++ compiler strictness

binding references and qualifiers

function overload resolution

initialization and conversion

string literals

template changes

C++ import library conversion tool

C++ incremental linker

C++ language

C++ Reference Declarations

C++ Language Guide

C++ namespaces

C++ Reference

C++ resource compiler

C++ resource shell

C++ Scope

C++ Scoping Rules Summary

C++ Specific Keywords

C++ Specific Operators

C++ Specifics

C++0x features

alignof operator

attributes noreturn and final

decltype specifier

explicit conversion operatorsl

extern templates

forward declaration of enums

C++0x Features (C++Builder 2009)

C++Builder Keyword Extensions

C++-Specific Keywords

cached updates

BDE

caching

Calling a Control's Message Handler Directly

Calling a Help System Directly

Calling Invokable Interfaces

Calling Methods

Calling Server Interfaces

Calling the Apply Method

Calling the Click-event Handler

Calling the Event

calloc

Canceling Batch Updates

Canceling Changes

Canceling Commands

canceling data changes

canvas

properties and methods

canvas methods

canvas object

canvases

casting, C++ style

catch

cdecl

Chaining Page Producers Together

cdecl, _cdecl, __cdecl

ceil, ceill

cgets

Change method

ChangeScale

typecasts

Changing Class Defaults to Avoid Repetition

Changing Initial Values

Changing Message Handling

Changing Other Decision Graph Series Properties

Changing Other Decision Graph Template Properties

Changing the Associated Dataset at Runtime

Changing the Brush Color

Changing the Brush Style

Changing the Default Decision Graph Type

Changing the Default Value of FReadOnly

Changing the Double-click Behavior

Changing the Drag Mouse Pointer

Changing the Name of a Component

Changing the Pen Color

Changing the Pen Mode

Changing the Pen Style

Changing the Pen Width

Changing the Series Graph Type

Changing the Standard Event Handling

Changing the Tool with Speed Buttons

Changing VCL for the Web application type

Character Constants Overview

Character Sets

character types

Checking for Termination by Other Threads

child windows

Choosing a Connection Protocol

Choosing a Default Action Item

Choosing a Threading Model

Choosing How to Apply Updates Using a Dataset Provider

Choosing How to Organize the Data

Choosing Navigator Buttons to Display

Choosing the Type of Dataset for Caching Updates

class factories

class initialization

class library

class members

class methods

specifying for a component

Class Methods

class name

Class Templates Overview

classes

removing dependencies

Classes

Classes and Pointers

classes,

classes, forward

classes, member list

classes, names

classes, objects

classes, scope

classes, types

calling server interfaces

clearerr

clicks

responding to

client applications

connecting to servers

file-based applications

grouping data

internally calculated fields

limiting records in data packets

maintained aggregates

with internal source dataset

Client Events

client sockets

ClientSocket component

multi-tiered applications

clients

COM

Clipboard

clock

clock_t

Cloning a Client Dataset Cursor

closedir, wclosedir

Closing Database Connections

Closing Server Connections

Closing the Connection

clreol

clrscr

CoClasses and Class Factories

code

editing

Code Generated by Wizards

Code Generated When You Import Type Library Information

code sharing among event handlers

CodeGuard

COFF2OMF.EXE, the Import Library Conversion Tool

columns

COM

overview of creating objects

specification and implementation

COM application parts

COM applications

DCOM applications

COM basics

COM clients

importing a type library

COM Interface Pointers

COM interfaces

COM Object Instancing Types

COM objects

choosing a threading model

COM servers

COM+ Event And Event Subscriber Objects

Command Line Utilities

CommandText

client datasets

Comments

comments,

Common Controls and XP Themes

common dialog boxes

using

Common List Operations

Common Properties and Methods of Canvas

Commonly Used Long String Routines

Commonly Used Routines for Null-terminated Strings

Communicating with Providers Using Custom Events

Communicating with the Client Dataset

Communicating with the Help Manager

compiler directives

strings

Compiler Directives for Strings

compiler options

project options

compiler options (C++)

Compiler Template Switches

Compiling and Linking from the Command Line

Compiling Applications

Compiling Components into Packages

Compiling Packages

compl

adding graphic capabilities

component

component editors

Component wizard

component wrappers

COM

Component Writer's Guide

component writing

controlling access

default property values

drawing the component image

hiding implementation details

making a control read-only

providing an OnChange event

publishing inherited properties

components

adding to the Tool palette

classes

Components Available Only on Specific OS

creating and registering

Components and Classes

Components and Ownership

Composing Client Requests

Composing Update SQL Statements

conditional compilation

Conditional Compilation

Conditional Compilation Overview

Conditional Operators

configuring

IIS

Configuring TMTSDataModule

Configuring TRemoteDataModule

Configuring TSOAPDataModule

Configuring TSQL Connection

conio.h

Connecting a Client Dataset to Another Dataset in the Same Application

Connecting a Property Page to an ActiveX Control

Connecting an ADO Dataset to a Data Store

connecting DataGrids

Connecting Directly to a Database Server

Connecting to a Data Store Using TADOConnection

Connecting to a Database Server

Connecting to a Database using the dbExpress Driver Framework

Connecting to a Server

Connecting to ADO Data Stores

Connecting to an Application Server That Uses Multiple Data Modules

Connecting to Another Dataset

Connecting to Clients

Connecting to databases

Connecting to databases with TDatabase

Connecting to Databases with TDatabase

Connecting to Databases: Overview

Connecting to the Application Server

Connecting to the Application Server using DataSnap Components

Connecting to the Database Server

Connecting to the Server

connection components

client applications

implicit

connections

ADO

asynchronous

timing out

Considerations When Dynamically Resizing Forms and Controls

Considerations When Not Dynamically Resizing

const_cast

const_cast (typecast Operator)

constant expressions

Constant Expressions

constants

Constants and Internal Representation

Constants

Constants And Internal Representation

Constants Overview

constants, character

constants, enumeration

constants, floating-point

constants, integer

constants, internal representation

constants, string

constants, wide-character

constexpr

Constraining Data Values

constraints

constructor

constructors

Constructors And Destructors

overriding

Constructors

Constructors In Exception Handling (C++)

constructors, copy

constructors, defaults

constructors, order of calling

constructors, overloading

Controlling an Automation Server Using a Dispatch Interface

Controlling an Automation Server Using a Dual Interface

Controlling an Imported Object

Controlling and Masking User Input

Controlling Application Behavior

Controlling Connections

Controlling Grid Drawing

Controlling How Child Controls Are Docked

Controlling How Child Controls Are Undocked

Controlling How Child Controls Respond to Drag-and-dock Operations

Controlling Read/Write Access to Local Tables

Controlling Read/Write Access to Tables

Controlling Server Login

Controlling Timeouts

Controlling What Information Is Included in Data Packets

Controlling When Forms Reside in Memory

controls

ancestor classes

data-aware

graphic controls

subclassing Windows controls

conversion utilities

conversions

Converting an Unnamed Thread to a Named Thread

Converting Field Values

Converting HTML-transparent Tags

Converting Measurements

Converting To Strings With #

Converting XML Documents into Data Packets

Copying a Complete String List

Copying a Complete String List (VCL)

Copying a File

Copying an Item

Copying and Clearing Custom Variants

Copying Data from Another Dataset

Copying Data from One Stream to Another

Copying Data From One Stream To Another

Copying Graphics to the Clipboard

cos, cosl

cosh, coshl

Counting the Strings in a List

cpp32 preprocessor directives

CPP32.EXE, the C Compiler Preprocessor

cprintf

cputs

creating

data browsing control

data editing controls

graphic component

Creating a Batch Move Component

Creating a Class to Enable the Custom Variant Type

Creating a Component with the Component Wizard

Creating a Custom Constraint

Creating a Customized Grid

Creating a Data Browsing Control

Creating a Data Editing Control

Creating a Form Instance Using a Local Variable

Creating a graphic component

Creating a Graphic Component

Creating a Grid That Contains Other Data-aware Controls

Creating a Group of Speed Buttons

Creating a New Component

Creating a New Dataset

Creating a New Property Page

Creating a New String List

Creating a New Type Library

Creating a New VCL Component

Creating a New VCL for the Web Application

Creating a Package

Creating a Property Page for an ActiveX Control

Creating a Simple Conversion Family and Adding Units

Creating a Unit File

Creating a VCL Form Instance Using a Local Variable

Creating a VCL Forms ActiveX Active Form

Creating a VCL Forms ActiveX Button

Creating Actions in a VCL Forms Application

Creating Active Server Pages: Overview

Creating Additional Sessions

Creating an Active Form for the Client Application

Creating an Active Server Object

Creating an Active Server Page

Creating an Application that Uses Ribbon Controls

Creating an Index with IndexFieldNames

Creating an OnUpdateRecord Event Handler

Creating and Deleting Tables

Creating and Editing Packages

Creating and Editing Standard Data Modules

Creating and Managing Menus

Creating and Managing Off-screen Bitmaps

Creating and Modifying Server Metadata

Creating and Registering the Component (Dialog Box)

Creating and registering the component (Grid)

Creating and registering the data-aware component

Creating and Registering the Graphic Component

Creating and Registering the Modified Component

Creating and Using Component Templates

Creating and Using Decision Graphs

Creating and Using Decision Grids

Creating Applications

Creating Array Properties

Creating ASPs for In-process or Out-of-process Servers

Creating Attribute Sets for Field Components

Creating Business Rules in a Data Module

Creating Clients for Servers That Do Not Have a Type Library

Creating COM clients

Creating COM Clients

Creating Components

Creating Custom Exception Classes for Web Services

Creating Customizable Toolbars and Menus

Creating Decision Datasets with the Decision Query Editor

Creating Decision Datasets with TQuery or TTable

Creating Decision Graphs

Creating Decision Grids

Creating DLLs Containing VCL Components (C++)

Creating Drawing Spaces

Creating Dynamic Menus

Creating events

Creating Events: Overview

Creating Filters

Creating Forms and Projects

Creating Forms Dynamically

Creating Frames

Creating Graphic Controls

Creating Groups of Tool Buttons

Creating Heterogenous Queries

Creating HTTP response messages

Creating HTTP Response Messages

Creating international applications

Creating International Applications: Overview

Creating Internet Applications: Overview

Creating Internet server applications

Creating Master/detail Relationships

Creating methods

Creating Methods to Store and Load Property Values

Creating Methods: Overview

Creating Modeless Forms Such as Windows

Creating Most Recently Used Lists

Creating multi-tiered applications

Creating Multi-tiered Applications: Overview

Creating New Message Handlers

Creating Nonvisual Components

Creating Original Controls

Creating packages and DLLs

Creating Packages and DLLs

Creating Persistent Columns

Creating Persistent Fields

Creating Projects

Creating properties

Creating Properties for Interfaces

Creating Properties for Subcomponents

Creating Properties: Overview

Creating reports with Rave Reports

Creating Resource DLLs

Creating simple COM servers

Creating Simple COM Servers: Overview

Creating SQL Statements for Update Components

Creating Strings

Creating Submenus

Creating the Application Server

Creating the Client Application

Creating the Component Interface

Creating the Entries

Creating the Help File

Creating Toolbars and Menus

Creating Web Broker Applications

Creating Web Pages with an InternetExpress Page Producer

Creating Web server applications

Creating Web Server Applications

Creating Web Server Applications Using IntraWeb

Creating Web Server Applications Using WebSnap

Creating Web Server Applications with Web Broker

Creating Web server applications with WebSnap

Creating Web Server Applications with WebSnap

Creating Web Services Applications

Creating WebSnap Applications

Creating, Instantiating, and Destroying Objects

crosstabs

custom interfaces

custom variants

comparison operations

Customizing a Grid: Overview

Customizing Decision Graph Series

Customizing Decision Graphs

Customizing Drag and Drop with a Drag Object

Customizing the ActiveX Control's Interface

Customizing the IDE Help System

Customizing the InternetExpress Page Producer Template

Cutting Graphics to the Clipboard

Cutting, Copying, and Pasting Text

data

data dictionary

Data Dictionary

Data Explorer

modifying connections

data formats

data grids

runtime options DBGrid component

data links

adding to components

data modules

accessing from a form

data packets

converting to XML documents

data sources

associating with datasets

disabling and enabling

associating with datasets

data-aware

controls

data-aware controls

database

Database

adding a new connection

browsing objects

executing SQL

modifying connections

BDE-based

multi-tiered applications

reports

Database architecture

Database Architecture

database connections

database navigator

database servers

databases

associating with sessions

connection components

considerations

data sources

associating with databases

DataRequest method

datasets

DataSets

DataSnap

multi-tier database support

dBASE index

dbExpress

dbExpress 4 Feature Overview

dbExpress Components

dbExpress database applications

dbExpress Framework Compatibility

dbExpress Framework

dbGo Overview

DBGrid component

DBGridColumns component

DCC32

compiling C++

DCC32.EXE

DCC32.EXE, the Delphi Command Line Compiler

DCOM

advantages

debugging

Web Application Debugger

Debugging a WebSnap Application using the Web Application Debugger

Debugging a Wizard

Debugging Applications

Debugging C++ Applications with CodeGuard Error Reporting

Debugging dbExpress Applications

Debugging dbExpress Applications using TSQLMonitor

Debugging Multi-threaded Applications

Debugging server applications

Debugging Server Applications

Debugging Service Applications

Debugging Web Applications That Are DLLs

Deciding Which Runtime Packages to Use

Decision Cube editor

design time information

dimension settings

memory control

Decision Cube Properties and Events

decision cubes

activating dimensions

binning

DecisionCube component

decision datasets

decision graphs

DecisionGraph component

Decision Graphs at Runtime

Decision Grid Properties

decision grids

expanding and collapsing dimensions

drilling

pivoting

Decision Grids at Runtime

runtime behavior

Decision Pivot Properties

decision pivots

DecisionPivot component

Decision Pivots: Runtime Behavior

runtime behaviors

decision queries

decision sources

decision support

decision support components

Decision Support Components and Memory Control

Decision Support Components at Runtime

DecisionGrid component

decision grids

Declaration and Declarators

Declaration Syntax

declarations

Declarations And Definitions

Declarations

Declarations And Prototypes

declarations, external

declarations, incomplete

declarations, namespaces

Declaring a Message Identifier

Declaring a Message-structure Type

Declaring A namespace

Declaring a New Component Class

Declaring A New Constructor (C++)

Declaring a New Message-handling Method

Declaring and Initializing Strings

declaring component types

deriving classes

declaring methods

Declaring the Access Properties

Declaring Methods

Declaring the Access Properties for a Data-aware Control

Declaring the Class Field

Declaring the Class Fields

Declaring the Event

Declaring the Property

Declaring the Property Type

Declaring the Register Procedure

Default Exception Handling in VCL

default property values

Default Runtime Libraries

Default Property Values

defined

Defined

defining

Defining a Calculated Field

Defining a COM Object's Interface

Defining a Data Field

Defining a Lookup Field

Defining a Lookup List Column

Defining A namespace

Defining an Aggregate Field

Defining And Undefining Macros

Defining and Using SOAP Headers

Defining Custom Variants

Defining New Classes

Defining New Classes (Delphi)

Defining New Persistent Fields

Defining Properties

Defining Protected Blocks

Defining the Component Interface

Defining the Component Writer's Interface

Defining the Design-time Interface

Defining the Handler Type

Defining the Runtime Interface

Defining the Thread Object

Defining thread objects

Defining Thread Objects

Defining Transformations

Defining Your Own Events

Defining Your Own Messages

Defining Your Own VCL Exceptions

definitions

Definitions

delayimp.h

delete

Deleting a String from a List

Deleting a File

Deleting and Switching Indexes

Deleting Event Handlers

Deleting Persistent Columns

Deleting Persistent Field Components

Deleting Records

Deleting Selected Text

Deleting Strings

Deleting Toolbar Buttons

delline

Delphi programming fundamentals

delta packets

editing

Demo Programs: Actions, Action Lists, Menus, and Toolbars

Deploying ActiveX Controls

Deploying applications

Deploying Applications

Deploying Applications: Overview

Deploying BDE Applications

Deploying Database Applications

Deploying dbExpress Database Applications

Deploying General Applications

Deploying Multi-tiered Database Applications (DataSnap)

Deploying On Apache Servers

Deploying Packages

Deploying Type Libraries

Deploying Web Applications

Deriving a Property-editor Class

deriving classes

property editors

Deriving New Classes

Deriving the Component

Describing sockets

Describing Sockets

Describing the Content

Describing the Host

Describing the Server Application

Designing a COM Object

Designing an ActiveX Control

Designing Applications

Designing database applications

Designing Database Applications: Overview

Designing the user interface

Designing the User Interface

Designing Toolbars and Cool Bars

Design-time Packages

destructors

Destructors

destructors, directives and

destructors, invoking

Determining Dataset States

Determining the Order of Merged Menu Items: GroupIndex Property

Determining the Source of Data

Determining What to Draw

Determining What to Store

Determining When Action Items Fire

Developing a Windows Application

Developing Applications with VCL Components

Developing COM Applications

Developing COM-based Applications

Developing Database Applications

Developing Database Applications for the Win32 Platform

Developing Dialog Boxes

Developing Interoperable Applications

Developing Reports for Your Win32 Applications

Developing the application user interface

Developing the Application User Interface: Overview

Developing Web Applications with WebSnap

Developing Web Services with Win32 Applications

Developing Windows Applications

dialog

Windows Forms

dialog box as component

dialog boxes

disable, _disable, enable, _enable

Disabling and Enabling Data Display

Disabling Menu Items

Disconnecting from a Database Server

Dispatch Interfaces

Dispatcher Components

Dispatching Action Items

Dispatching Messages

Dispatching Methods

Dispatching Request Messages

Dispatching requests and responses

Dispatching Requests and Responses

dispid

Displaying a Bitmap Image in a VCL Forms Application

Display Controls

Displaying a Full View Bitmap Image in a VCL Forms Application

Displaying a Single Record

Displaying ADT and Array Fields

Displaying an Auto-created Form

Displaying an Auto-Created VCL Form

Displaying and Coding Shared Events

Displaying and Editing a Subset of Data Using Filters

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 bitmap images

displaying data

disabling and enabling

Displaying Data as Labels

Displaying Field Component Values in Standard Controls

Displaying Fly-over Help

Displaying Keyword-based Help

Displaying Multiple Records

Displaying Tables of Contents

Displaying, Converting, and Accessing Field Values

distributed applications

Distributing a Client Application as an ActiveX Control

Distributing Database Applications

div

Divide error (C++)

division

creating that contain VCL components

DLL Locations

DLLs

dynamic link libraries, using

linking

locations

Drawing a Polygon in a VCL Forms Application

docking

dockable child controls

DOM

Document Object Model

double-byte character sets

two-byte character codes

drag-and-dock

drawing

rectangles and ellipses

round rectangles

straight lines

Drawing a Rounded Rectangle in a VCL Forms Application

Drawing Lines

Drawing Lines and Polylines

drawing objects

Drawing On a Graphic

Drawing On the Bitmap

Drawing Owner-draw Items

Drawing Owner-drawn Items

Drawing Polygons

Drawing Polylines

Drawing Rectangles and Ellipses

Drawing Rectangles and Ellipses in a VCL Forms Application

Drawing Rounded Rectangles

Drawing Shapes

Drawing Shapes (Code)

Drawing Straight Lines In a VCL Forms Application

Drawing the Component Image

drawing tools

Drilling Down for Detail in Decision Grids

drivers

dbExpress

Dropping Inactive Database Connections

Dropping Items

Dropping or Changing a Server Connection

dual interface

Automation controller

Dual Interfaces

dup

dup2

duration

Duration

Dynamic Field Components

dynamic functions

Dynamic Switching of Resource DLLs

Dynamic Functions

Dynamic Methods

dynamic_cast

typecasting, C++

dynamic_cast (typecast Operator)

Dynamically Creating a VCL Modal Form

Dynamically Creating a VCL Modeless Form

Dynamic-link Libraries

E2000: 286/287 instructions not enabled (C++)

E2001: Constructors and destructors not allowed in __automated section (C++)

E2002: Only __fastcall functions allowed in __automated section (C++)

E2003: Data member definition not allowed in __automated section (C++)

E2004: Only read or write clause allowed in property declaration in __automated section (C++)

E2005: Redeclaration of property not allowed in __automated section (C++)

E2006: CodeGuarded programs must use the large memory model and be targeted for Windows (C++)

E2007: Dispid only allowed in __automated sections (C++)

E2008: Published property access functions must use __fastcall calling convention (C++)

E2009: Attempt to grant or reduce access to 'identifier' (C++)

E2010: Cannot add or subtract relocatable symbols (C++)

E2011: Illegal to take address of bit field (C++)

E2012: Cannot take address of 'main' (C++)

E2013: 'function1' cannot be distinguished from 'function2' (C++)

E2014: Member is ambiguous: 'member1' and 'member2' (C++)

E2015: Ambiguity between 'function1' and 'function2' (C++)

E2016: Ambiguous override of virtual base member 'base_function': 'derived_function' (C++)

E2017: Ambiguous member name 'name' (C++)

E2018: Cannot catch 'identifier' -- ambiguous base class 'identifier' (C++)

E2019: 'identifier' cannot be declared in an anonymous union (C++)

E2020: Global anonymous union not static (C++)

E2021: Array must have at least one element (C++)

E2022: Array size too large (C++)

E2023: Array of references is not allowed (C++)

E2024: Cannot modify a const object (C++)

E2025: Assignment to 'this' not allowed, use X::operator new instead (C++)

E2026: Assembler statement too long (C++)

E2027: Must take address of a memory location (C++)

E2028: operator -> must return a pointer or a class (C++)

E2029: 'identifier' must be a previously defined class or struct (C++)

E2030: Misplaced break (C++)

E2031: Cannot cast from 'type1' to 'type2' (C++)

E2032: Illegal use of closure pointer (C++)

E2033: Misplaced continue (C++)

E2034: Cannot convert 'type1' to 'type2' (C++)

E2035: Conversions of class to itself or base class not allowed (C++)

E2036: Conversion operator cannot have a return type specification (C++)

E2037: The constructor 'constructor' is not allowed (C++)

E2038: Cannot declare or define 'identifier' here: wrong namespace (C++)

E2039: Misplaced decimal point (C++)

E2040: Declaration terminated incorrectly (C++)

E2041: Incorrect use of default (C++)

E2042: Declare operator delete (void*) or (void*, size_t) (C++)

E2044: operator delete must return void (C++)

E2045: Destructor name must match the class name (C++)

E2046: Bad file name format in include directive OR Bad file name format in line directive (C++)

E2047: Bad 'directive' directive syntax (C++)

E2048: Unknown preprocessor directive: 'identifier' (C++)

E2049: Class type 'type' cannot be marked as __declspec(delphireturn) (C++)

E2050: __declspec(delphireturn) class 'class' must have exactly one data member (C++)

E2051: Invalid use of dot (C++)

E2052: Dynamic function 'function' conflicts with base class 'class' (C++)

E2053: Misplaced elif directive (C++)

E2054: Misplaced else (C++)

E2055: Misplaced else directive (C++)

E2056: Misplaced endif directive (C++)

E2057: Exception specification not allowed here (C++)

E2058: Exception handling variable may not be used here (C++)

E2059: Unknown language, must be C or C++ (C++)

E2060: Illegal use of floating point (C++)

E2061: Friends must be functions or classes (C++)

E2062: Invalid indirection (C++)

E2063: Illegal initialization (C++)

E2064: Cannot initialize 'type1' with 'type2' (C++)

E2065: Using namespace symbol 'symbol' conflicts with intrinsic of the same name (C++)

E2066: Information not available (C++)

E2066: Invalid MOM inheritance (C++)

E2067: 'main' must have a return type of int (C++)

E2068: 'identifier' is not a non-static data member and can't be initialized here (C++)

E2069: Illegal use of member pointer (C++)

E2070: Invalid use of namespace 'identifier' (C++)

E2071: operator new must have an initial parameter of type size_t (C++)

E2072: Operator new[] must return an object of type void (C++)

E2073: Nothing allowed after pragma option pop (C++)

E2074: Value after -g or -j should be between 0 and 255 inclusive (C++)

E2075: Incorrect 'type' option: option (C++)

E2076: Overloadable operator expected (C++)

E2077: 'operator' must be declared with one or no parameters (C++)

E2078: 'operator' must be declared with one or two parameters (C++)

E2079: 'function' must be declared with no parameters (C++)

E2080: 'function' must be declared with one parameter (C++)

E2081: 'function' must be declared with two parameters (C++)

E2082: 'identifier' must be a member function or have a parameter of class type (C++)

E2083: Last parameter of 'operator' must have type 'int' (C++)

E2084: Parameter names are used only with a function body (C++)

E2085: Invalid pointer addition (C++)

E2086: Illegal pointer subtraction (C++)

E2087: Illegal use of pointer (C++)

E2088: Bad syntax for pure function definition (C++)

E2089: Identifier 'identifier' cannot have a type qualifier (C++)

E2090: Qualifier 'identifier' is not a class or namespace name (C++)

E2091: Functions cannot return arrays or functions (C++)

E2092: Storage class 'storage class' is not allowed here (C++)

E2093: Operator 'operator' not implemented in type 'type' for arguments of the same type (C++)

E2094: Operator 'operator' not implemented in type 'type' for arguments of type 'type' (C++)

E2095: String literal not allowed in this context (C++)

E2096: Illegal structure operation (C++)

E2097: Explicit instantiation only allowed at file or namespace scope (C++)

E2098: Explicit specialization declarator "template<>" now required (C++)

E2099: Explicit specialization only allowed at file or namespace scope (C++)

E2100: Invalid template declarator list (C++)

E2101: 'export' keyword must precede a template declaration (C++)

E2102: Cannot use template 'template' without specifying specialization parameters (C++)

E2103: Explicit instantiation must be used with a template class or function (C++)

E2104: Invalid use of template keyword (C++)

E2105: 'template' qualifier must specify a member template name (C++)

E2106: Explicit specialization must be used with a template class or function (C++)

E2107: Invalid use of template 'template' (C++)

E2108: Improper use of typedef 'identifier' (C++)

E2109: Not an allowed type (C++)

E2110: Incompatible type conversion (C++)

E2111: Type 'typename' may not be defined here (C++)

E2112: Unknown unit directive: 'directive' (C++)

E2113: Virtual function 'function1' conflicts with base class 'base' (C++)

E2114: Multiple base classes require explicit class names (C++)

E2115: Bit field too large (C++)

E2116: Bit fields must contain at least one bit (C++)

E2117: Bit fields must be signed or unsigned int (C++)

E2118: Bit fields must have integral type (C++)

E2119: User break (C++)

E2120: Cannot call 'main' from within the program (C++)

E2121: Function call missing ) (C++)

E2122: Function call terminated by unhandled exception 'value' at address 'addr' (C++)

E2123: Class 'class' may not contain pure functions (C++)

E2124: Invalid function call (C++)

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' (C++)

E2126: Case bypasses initialization of a local variable (C++)

E2127: Case statement missing : (C++)

E2128: Case outside of switch (C++)

E2129: Character constant too long (or empty) (C++)

E2130: Circular property definition (C++)

E2131: Objects of type 'type' cannot be initialized with { } (C++)

E2132: Templates and overloaded operators cannot have C linkage (C++)

E2133: Unable to execute command 'command' (C++)

E2134: Compound statement missing closing brace (C++)

E2135: Constructor/Destructor cannot be declared 'const' or 'volatile' (C++)

E2136: Constructor cannot have a return type specification (C++)

E2137: Destructor for 'class' required in conditional expression (C++)

E2138: Conflicting type modifiers (C++)

E2139: Declaration missing ; (C++)

E2140: Declaration is not allowed here (C++)

E2141: Declaration syntax error (C++)

E2142: Base class 'class' contains dynamically dispatchable functions (C++)

E2143: Matching base class function 'function' has different dispatch number (C++)

E2144: Matching base class function 'function' is not dynamic (C++)

E2145: Functions 'function1' and 'function2' both use the same dispatch number (C++)

E2146: Need an identifier to declare (C++)

E2147: 'identifier' cannot start a parameter declaration (C++)

E2148: Default argument value redeclared for parameter 'parameter' (C++)

E2149: Default argument value redeclared (C++)

E2150: Type mismatch in default argument value (C++)

E2151: Type mismatch in default value for parameter 'parameter' (C++)

E2152: Default expression may not use local variables (C++)

E2153: Define directive needs an identifier (C++)

E2154: Cannot define 'identifier' using a namespace alias (C++)

E2155: Too many default cases (C++)

E2156: Default outside of switch (C++)

E2157: Deleting an object requires exactly one conversion to pointer operator (C++)

E2158: Operand of 'delete' must be non-const pointer (C++)

E2159: Trying to derive a far class from the huge base 'base' (C++)

E2160: Trying to derive a far class from the near base 'base' (C++)

E2161: Trying to derive a huge class from the far base 'base' (C++)

E2162: Trying to derive a huge class from the near base 'base' (C++)

E2163: Trying to derive a near class from the far base 'base' (C++)

E2164: Trying to derive a near class from the huge base 'base' (C++)

E2165: Destructor cannot have a return type specification (C++)

E2166: Destructor for 'class' is not accessible (C++)

E2167: 'function' was previously declared with the language 'language' (C++)

E2168: Division by zero (C++)

E2169: 'identifier' specifies multiple or duplicate access (C++)

E2170: Base class 'class' is included more than once (C++)

E2171: Body has already been defined for function 'function' (C++)

E2172: Duplicate case (C++)

E2173: Duplicate handler for 'type1', already had 'type2' (C++)

E2174: The name handler must be last (C++)

E2175: Too many storage classes in declaration (C++)

E2176: Too many types in declaration (C++)

E2177: Redeclaration of #pragma package with different arguments (C++)

E2178: VIRDEF name conflict for 'function' (C++)

E2179: virtual specified more than once (C++)

E2180: Dispid number already used by identifier (C++)

E2181: Cannot override a 'dynamic/virtual' with a 'dynamic/virtual' function (C++)

E2182: Illegal parameter to __emit__ (C++)

E2183: File must contain at least one external declaration (C++)

E2184: Enum syntax error (C++)

E2185: The value for 'identifier' is not within the range of 'type-name' (C++)

E2186: Unexpected end of file in comment started on line 'number' (C++)

E2187: Unexpected end of file in conditional started on line 'number' (C++)

E2188: Expression syntax (C++)

E2189: extern variable cannot be initialized (C++)

E2190: Unexpected closing brace (C++)

E2191: '__far16' may only be used with '__pascal' or '__cdecl' (C++)

E2192: Too few parameters in call (C++)

E2193: Too few parameters in call to 'function' (C++)

E2194: Could not find file 'filename' (C++)

E2195: Cannot evaluate function call (C++)

E2196: Cannot take address of member function 'function' (C++)

E2197: File name too long (C++)

E2198: Not a valid expression format type (C++)

E2199: Template friend function 'function' must be previously declared (C++)

E2200: Functions may not be part of a struct or union (C++)

E2201: Too much global data defined in file (C++)

E2202: Goto into an exception handler is not allowed (C++)

E2203: Goto bypasses initialization of a local variable (C++)

E2204: Group overflowed maximum size: 'name' (C++)

E2205: Illegal type type in __automated section (C++)

E2206: Illegal character 'character' (0x'value') (C++)

E2207: Implicit conversion of 'type1' to 'type2' not allowed (C++)

E2208: Cannot access an inactive scope (C++)

E2209: Unable to open include file 'filename' (C++)

E2210: Reference member 'member' is not initialized (C++)

E2211: Inline assembly not allowed in inline and template functions (C++)

E2212: Function defined inline after use as extern (C++)

E2213: Invalid 'expression' in scope override (C++)

E2214: Cannot have a 'non-inline function/static data' in a local class (C++)

E2215: Linkage specification not allowed (C++)

E2216: Unable to create turboc.$ln (C++)

E2217: Local data exceeds segment size limit (C++)

E2218: Templates can only be declared at namespace or class scope (C++)

E2219: Wrong number of arguments in call of macro 'macro' (C++)

E2220: Invalid macro argument separator (C++)

E2221: Macro argument syntax error (C++)

E2222: Macro expansion too long (C++)

E2223: Too many decimal points (C++)

E2224: Too many exponents (C++)

E2225: Too many initializers (C++)

E2226: Extra parameter in call (C++)

E2227: Extra parameter in call to function (C++)

E2228: Too many error or warning messages (C++)

E2229: Member 'member' has the same name as its class (C++)

E2230: In-line data member initialization requires an integral constant expression (C++)

E2231: Member 'member' cannot be used without an object (C++)

E2232: Constant/Reference member 'member' in class without constructors (C++)

E2233: Cannot initialize a class member here (C++)

E2234: Memory reference expected (C++)

E2235: Member function must be called or its address taken (C++)

E2236: Missing 'identifier' in scope override (C++)

E2238: Multiple declaration for 'identifier' (C++)

E2239: 'identifier' must be a member function (C++)

E2240: Conversion of near pointer not allowed (C++)

E2241: VCL style classes need virtual destructors (C++)

E2242: Specifier requires Delphi style class type (C++)

E2243: Array allocated using 'new' may not have an initializer (C++)

E2244: 'new' and 'delete' not supported (C++)

E2245: Cannot allocate a reference (C++)

E2246: x is not abstract public single inheritance class hierarchy with no data (C++)

E2247: 'member' is not accessible (C++)

E2248: Cannot find default constructor to initialize array element of type 'class' (C++)

E2249: = expected (C++)

E2250: No base class to initialize (C++)

E2251: Cannot find default constructor to initialize base class 'class' (C++)

E2252: 'catch' expected (C++)

E2253: Calling convention must be attributed to the function type, not the closure (C++)

E2254: : expected after private/protected/private (C++)

E2255: Use :: to take the address of a member function (C++)

E2256: No : following the ? (C++)

E2257: , expected (C++)

E2258: Declaration was expected (C++)

E2259: Default value missing (C++)

E2260: Default value missing following parameter 'parameter' (C++)

E2261: Use of dispid with a property requires a getter or setter (C++)

E2262: '__except' or '__finally' expected following '__try' (C++)

E2263: Exception handling not enabled (C++)

E2264: Expression expected (C++)

E2265: No file name ending (C++)

E2266: No file names given (C++)

E2267: First base must be VCL class (C++)

E2268: Call to undefined function 'function' (C++)

E2269: The function 'function' is not available (C++)

E2270: > expected (C++)

E2271: Goto statement missing label (C++)

E2272: Identifier expected (C++)

E2273: 'main' cannot be declared as static or inline (C++)

E2274: < expected (C++)

E2275: Opening brace expected (C++)

E2276: ( expected (C++)

E2277: Lvalue required (C++)

E2278: Multiple base classes not supported for Delphi classes (C++)

E2279: Cannot find default constructor to initialize member 'identifier' (C++)

E2280: Member identifier expected (C++)

E2281: Identifier1 requires definition of Identifier2 as a pointer type (C++)

E2282: Namespace name expected (C++)

E2283: Use . or -> to call 'function' (C++)

E2284: Use . or -> to call 'member', or & to take its address (C++)

E2285: Could not find a match for 'argument(s)' (C++)

E2286: Overloaded function resolution not supported (C++)

E2287: Parameter 'number' missing name (C++)

E2288: Pointer to structure required on left side of -> or ->* (C++)

E2289: __published or __automated sections only supported for Delphi classes (C++)

E2290: 'code' missing ] (C++)

E2291: brace expected (C++)

E2292: Function should return a value (C++)

E2293: ) expected (C++)

E2294: Structure required on left side of . or .* (C++)

E2295: Too many candidate template specializations from 'specifier' (C++)

E2296: Templates not supported (C++)

E2297: 'this' can only be used within a member function (C++)

E2298: Cannot generate 'function' from template function 'template' (C++)

E2299: Cannot generate template specialization from 'specifier' (C++)

E2300: Could not generate a specialization matching type for 'specifier' (C++)

E2301: Cannot use templates in closure arguments -- use a typedef (C++)

E2302: No type information (C++)

E2303: Type name expected (C++)

E2304: 'Constant/Reference' variable 'variable' must be initialized (C++)

E2305: Cannot find 'class::class' ('class'&) to copy a vector OR Cannot find 'class'::operator=('class'&) to copy a vector (C++)

E2306: Virtual base classes not supported for Delphi classes (C++)

E2307: Type 'type' is not a defined class with virtual functions (C++)

E2308: do statement must have while (C++)

E2309: Inline assembly not allowed (C++)

E2310: Only member functions may be 'const' or 'volatile' (C++)

E2311: Non-virtual function 'function' declared pure (C++)

E2312: 'constructor' is not an unambiguous base class of 'class' (C++)

E2313: Constant expression required (C++)

E2314: Call of nonfunction (C++)

E2315: 'Member' is not a member of 'class', because the type is not yet defined (C++)

E2316: 'identifier' is not a member of 'struct' (C++)

E2317: 'identifier' is not a parameter (C++)

E2318: 'type' is not a polymorphic class type (C++)

E2319: 'identifier' is not a public base class of 'classtype' (C++)

E2320: Expression of scalar type expected (C++)

E2321: Declaration does not specify a tag or an identifier (C++)

E2322: Incorrect number format (C++)

E2323: Illegal number suffix (C++)

E2324: Numeric constant too large (C++)

E2325: Illegal octal digit (C++)

E2326: Use __declspec(spec1[, spec2]) to combine multiple __declspecs (C++)

E2327: Operators may not have default argument values (C++)

E2328: Classes with properties cannot be copied by value (C++)

E2329: Invalid combination of opcode and operands (C++)

E2330: Operator must be declared as function (C++)

E2331: Number of allowable option contexts exceeded (C++)

E2332: Variable 'variable' has been optimized and is not available (C++)

E2333: Class member 'member' declared outside its class (C++)

E2334: Namespace member 'identifier' declared outside its namespace (C++)

E2335: Overloaded 'function name' ambiguous in this context (C++)

E2336: Pointer to overloaded function 'function' doesn't match 'type' (C++)

E2337: Only one of a set of overloaded functions can be "C" (C++)

E2338: Overlays only supported in medium, large, and huge memory models (C++)

E2339: Cannot overload 'main' (C++)

E2340: Type mismatch in parameter 'number' (C++)

E2341: Type mismatch in parameter 'number' in call to 'function' (C++)

E2342: Type mismatch in parameter 'parameter' (C++)

E2343: Type mismatch in parameter 'parameter' in call to 'function' (C++)

E2344: Earlier declaration of 'identifier' (C++)

E2345: Access can only be changed to public or protected (C++)

E2346: 'x' access specifier of property 'property' must be a member function (C++)

E2347: Parameter mismatch in access specifier 'specifier' of property 'property' (C++)

E2348: Storage specifier not allowed for array properties (C++)

E2349: Nonportable pointer conversion (C++)

E2350: Cannot define a pointer or reference to a reference (C++)

E2351: Static data members not allowed in __published or __automated sections (C++)

E2352: Cannot create instance of abstract class 'class' (C++)

E2353: Class 'classname' is abstract because of 'member = 0' (C++)

E2354: Two operands must evaluate to the same type (C++)

E2355: Recursive template function: 'x' instantiated 'y' (C++)

E2356: Type mismatch in redeclaration of 'identifier' (C++)

E2357: Reference initialized with 'type1', needs lvalue of type 'type2' (C++)

E2358: Reference member 'member' needs a temporary for initialization (C++)

E2359: Reference member 'member' initialized with a non-reference parameter (C++)

E2360: Invalid register combination (e.g. [BP+BX]) (C++)

E2361: 'specifier' has already been included (C++)

E2362: Repeat count needs an lvalue (C++)

E2363: Attempting to return a reference to local variable 'identifier' (C++)

E2364: Attempting to return a reference to a local object (C++)

E2365: Member pointer required on right side of .* or ->* (C++)

E2366: Can't inherit non-RTTI class from RTTI base OR E2367 Can't inherit RTTI class from non-RTTI base (C++)

E2368: RTTI not available for expression evaluation (C++)

E2369: Cannot use the result of a property assignment as an rvalue' (C++)

E2370: Simple type name expected (C++)

E2371: sizeof may not be applied to a bit field (C++)

E2372: sizeof may not be applied to a function (C++)

E2373: Bit field cannot be static (C++)

E2374: Function 'function' cannot be static (C++)

E2375: Assembler stack overflow (C++)

E2376: statement missing (C++)

E2377: statement missing ) (C++)

E2378: do-while or for statement missing ; (C++)

E2379: Statement missing ; (C++)

E2380: Unterminated string or character constant (C++)

E2381: Structure size too large (C++)

E2382: Side effects are not allowed (C++)

E2383: Switch selection expression must be of integral type (C++)

E2384: Cannot call near class member function with a pointer of type 'type' (C++)

E2386: Cannot involve parameter 'parameter' in a complex partial specialization expression (C++)

E2387: Partial specializations may not specialize dependent non-type parameters ('parameter') (C++)

E2388: Argument list of specialization cannot be identical to the parameter list of primary template (C++)

E2389: Mismatch in kind of substitution argument and template parameter 'parameter' (C++)

E2390: Type mismatch in parameter 'number' in template class name 'template' (C++)

E2391: Type mismatch in parameter 'parameter' in template class name 'template' (C++)

E2392: Template instance 'template' is already instantiated (C++)

E2393: Cannot take the address of non-type, non-reference template parameter 'parameter' (C++)

E2394: Too few arguments passed to template 'template' (C++)

E2395: Too many arguments passed to template 'template' (C++)

E2396: Template argument must be a constant expression (C++)

E2397: Template argument cannot have static or local linkage (C++)

E2398: Template function argument 'argument' not used in argument types (C++)

E2399: Cannot reference template argument 'arg' in template class 'class' this way (C++)

E2400: Nontype template argument must be of scalar type (C++)

E2401: Invalid template argument list (C++)

E2402: Illegal base class type: formal type 'type' resolves to 'type' (C++)

E2403: Dependent call specifier yields non-function 'name' (C++)

E2404: Dependent type qualifier 'qualifier' has no member type named 'name' (C++)

E2405: Dependent template reference 'identifier' yields non-template symbol (C++)

E2406: Dependent type qualifier 'qualifier' is not a class or struct type (C++)

E2407: Dependent type qualifier 'qualifier' has no member symbol named 'name' (C++)

E2408: Default values may be specified only in primary class template declarations (C++)

E2409: Cannot find a valid specialization for 'specifier' (C++)

E2410: Missing template parameters for friend template 'template' (C++)

E2411: Declaration of member function default parameters after a specialization has already been expanded (C++)

E2412: Attempting to bind a member reference to a dependent type (C++)

E2413: Invalid template declaration (C++)

E2414: Destructors cannot be declared as template functions (C++)

E2415: Template functions may only have 'type-arguments' (C++)

E2416: Invalid template function declaration (C++)

E2417: Cannot specify template parameters in explicit specialization of 'specifier' (C++)

E2418: Maximum instantiation depth exceeded; check for recursion (C++)

E2419: Error while instantiating template 'template' (C++)

E2420: Explicit instantiation can only be used at global scope (C++)

E2421: Cannot use local type 'identifier' as template argument (C++)

E2422: Argument kind mismatch in redeclaration of template parameter 'parameter' (C++)

E2423: Explicit specialization or instantiation of non-existing template 'template' (C++)

E2424: Template class nesting too deep: 'class' (C++)

E2425: 'member' is not a valid template type member (C++)

E2426: Explicit specialization of 'specifier' requires 'template<>' declaration (C++)

E2427: 'main' cannot be a template function (C++)

E2428: Templates must be classes or functions (C++)

E2429: Not a valid partial specialization of 'specifier' (C++)

E2430: Number of template parameters does not match in redeclaration of 'specifier' (C++)

E2431: Non-type template parameters cannot be of floating point, class, or void type (C++)

E2432: 'template' qualifier must name a template class or function instance' (C++)

E2433: Specialization after first use of template (C++)

E2434: Template declaration missing template parameters ('template<...>') (C++)

E2435: Too many template parameter sets were specified (C++)

E2436: Default type for template template argument 'arg' does not name a primary template class (C++)

E2437: 'typename' should be followed by a qualified, dependent type name (C++)

E2438: Template template arguments must name a class (C++)

E2439: 'typename' is only allowed in template declarations (C++)

E2440: Cannot generate specialization from 'specifier' because that type is not yet defined (C++)

E2441: Instantiating 'specifier' (C++)

E2442: Two consecutive dots (C++)

E2443: Base class 'class' is initialized more than once (C++)

E2444: Member 'member' is initialized more than once (C++)

E2445: Variable 'identifier' is initialized more than once (C++)

E2446: Function definition cannot be a typedef'ed declaration (C++)

E2447: 'identifier' must be a previously defined enumeration tag (C++)

E2448: Undefined label 'identifier' (C++)

E2449: Size of 'identifier' is unknown or zero (C++)

E2450: Undefined structure 'structure' (C++)

E2451: Undefined symbol 'identifier' (C++)

E2452: Size of the type is unknown or zero (C++)

E2453: Size of the type 'identifier' is unknown or zero (C++)

E2454: union cannot be a base type (C++)

E2455: union cannot have a base type (C++)

E2456: Union member 'member' is of type class with 'constructor' (or destructor, or operator =) (C++)

E2457: Delphi style classes must be caught by reference (C++)

E2458: Delphi classes have to be derived from Delphi classes (C++)

E2459: Delphi style classes must be constructed using operator new (C++)

E2460: Delphi style classes require exception handling to be enabled (C++)

E2461: '%s' requires run-time initialization/finalization (C++)

E2462: 'virtual' can only be used with non-template member functions (C++)

E2463: 'base' is an indirect virtual base class of 'class' (C++)

E2464: 'virtual' can only be used with member functions (C++)

E2465: unions cannot have virtual member functions (C++)

E2466: void & is not a valid type (C++)

E2467: 'Void function' cannot return a value (C++)

E2468: Value of type void is not allowed (C++)

E2469: Cannot use tiny or huge memory model with Windows (C++)

E2470: Need to include header <typeinfo> to use typeid (C++)

E2471: pragma checkoption failed: options are not as expected (C++)

E2472: Cannot declare a member function via instantiation (C++)

E2473: Invalid explicit specialization of 'specifier' (C++)

E2474: 'function' cannot be declared as static or inline (C++)

E2475: 'function' cannot be a template function (C++)

E2476: Cannot overload 'function' (C++)

E2477: Too few template parameters were declared for template 'template' (C++)

E2478: Too many template parameters were declared for template 'template' (C++)

E2479: Cannot have both a template class and function named 'name' (C++)

E2480: Cannot involve template parameters in complex partial specialization arguments (C++)

E2481: Unexpected string constant (C++)

E2482: String constant expected (C++)

E2483: Array dimension 'specifier' could not be determined (C++)

E2484: The name of template class 'class' cannot be overloaded (C++)

E2485: Cannot use address of array element as non-type template argument (C++)

E2486: Cannot use address of class member as non-type template argument (C++)

E2487: Cannot specify default function arguments for explicit specializations (C++)

E2488: Maximum token reply depth exceeded; check for recursion (C++)

E2489: Maximum option context replay depth exceeded; check for recursion (C++)

E2490: Specialization within template classes not yet implemented (C++)

E2491: Maximum VIRDEF count exceeded; check for recursion (C++)

E2492: Properties may only be assigned using a simple statement, e.g. \"prop = value;\" (C++)

E2493: Invalid GUID string (C++)

E2494: Unrecognized __declspec modifier (C++)

E2495: Redefinition of uuid is not identical (C++)

E2496: Invalid call to uuidof(struct type|variable) (C++)

E2497: No GUID associated with type:'type' (C++)

E2498: Need previously defined struct GUID (C++)

E2499: Invalid __declspec(uuid(GuidString)) format (C++)

E2500: __declspec(selectany) is only for initialized and externally visible variables (C++)

E2501: Unable to open import file 'filename' (C++)

E2502: Error resolving #import: problem (C++)

E2503: Missing or incorrect version of TypeLibImport.dll (C++)

E2504: 'dynamic' can only be used with non-template member functions (C++)

E2505: Explicit instantiation requires an elaborated type specifier (i.e.,"class foo<int>") (C++)

E2506: Explicit specialization of 'specifier' is ambiguous: must specify template arguments (C++)

E2507: 'class' is not a direct base class of 'class' (C++)

E2508: 'using' cannot refer to a template specialization (C++)

E2509: Value out of range (C++)

E2510: Operand size mismatch (C++)

E2511: Unterminated macro argument (C++)

E2512: Cannot emit RTTI for return type of 'function' (C++)

E2513: Cannot emit RTTI for 'parameter' in 'function' (C++)

E2514: Cannot (yet) use member overload resolution during template instantiation (C++)

E2515: Cannot explicitly specialize a member of a generic template class (C++)

E2522: Non-const function 'function' called for const object (C++)

E2523: Non-volatile function 'name' called for volatile object (C++)

E2524: Anonymous structs/unions not allowed to have anonymous members in C++ (C++)

E2525: You must define _PCH_STATIC_CONST before including xstring to use this feature (C++)

E2526: Property 'name' uses another property as getter/setter; Not allowed (C++)

E2527: Option 'name' cannot be set via 'name' (C++)

E2528: Option 'name' must be set before compilation begins (C++)

E2529: Path 'path' exceeds maximum size of 'n' (C++)

E2530: Unrecognized option, or no help available (C++)

E2531: Parameter is an incomplete type (C++)

E2532: Constant in new expression requires an initializer (C++)

E2533: Parameter mismatch (wanted typename) (C++)

E2534: Integral constant expression expected (C++)

E2535: Incomplete type cannot be part of a throw specification (C++)

E2536: Incomplete type cannot be part of a exception declaration (C++)

E2537: Cannot create instance of abstract class (C++)

E2538: Static assert failed: '%s' (C++)

E2539: Constant expression expected (C++)

E2540: String literal expected (C++)

E2541: Attribute '%s' cannot be set (C++)

E2542: '%s' is marked 'final' and cannot be overriden (C++)

E2543: Combination of options 'options' is not permitted (C++)

E2544: Function exception specifications do not match (C++)

E2545: Enum underlying type must be an integral (C++)

E2546: Redeclaration of enum is not identical (C++)

E2547: ... expected (C++)

E2548: ... was unexpected; expression is not a variadic template pattern (C++)

E2549: Operand is not a parameter pack (C++)

E2550: No arguments can follow a variadic template in an argument list (C++)

E2551: Return statement not allowed in __finally block (C++)

E2552: This feature is not (yet) supported (C++)

E2553: %s mismatch in redeclaration of '%s' (C++)

edit controls

Editing an Existing Package

Editing and Updating Data

Editing Code

editing data

in grids

Editing Data

Editing Data in a Control

Editing Delta Packets Before Updating the Database

Editing in the Grid

Editing Menu Items in the Object Inspector

Editing Package Source Files Manually

editing properties

Editing the Property as a Whole

Editing Records

Editing the Main Form

EDOM, ERANGE, #defines

Elements of an ActiveX Control

Eliminating Pointers In Templates

Embedding Tables in HTML Documents

Empty Handlers Must Be Valid

Emptying Tables

Enabling and Disabling Action Items

Enabling and Disabling Filtering

Enabling and Disabling the Data Source

Enabling Application Code

Enabling BDE-based Cached Updates

Enabling C++ Applications for Unicode

Enabling Casting

Enabling Editing in Controls On User Entry

Enabling Help in applications

Enabling Help in Applications

Enabling Mouse, Keyboard, and Timer Events

Enabling Simple Data Binding with the Type Library

Encapsulating Graphics

Ending a Drag Operation

enum

enum, assignment

Enumeration Constants

enumerations

errno (C Runtime Library Reference)

eof

errno.h

Error Events

Error Numbers in errno

Errors And Overflows

escape sequences

Establishing Master/detail Relationships Using Parameters

Escape Sequences

Evaluation Order

Event handler

Event Handler Types Are Procedures

event handlers

declaring events

deleting

Event Handlers Are Optional

Event Handlers Have A Return Type of void (C++)

Event Types Are closure Types (C++)

Event Types Are Method-pointer Types

Events Are closures (C++)

Automation controllers

Events Are Method Pointers

Events Are Properties

Examining a Delphi Object

Example for "Temporary used ..." error messages (C++)

Example of Adding Audio and/or Video Clips (VCL Only)

Example of Adding Silent Video Clips

Example of Declaring Methods

Example Of Overloading Operators

Example: Message Handler

Example: Message Structure

Example: Overriding a Message Handler

Example: User-defined Messages

exception handlers

exception handling

VCL

Exception Handling Options (C++)

exception objects

classes

defining

VCL

Exception-handling Statements

exceptions

exceptions, unwinding

Excluding Blank Cells

execl, execle, execlp, execlpe, execv, execve, execvp, execvpe, _wexecl, _wexecle, _wexeclp, _wexeclpe, _wexecv, _wexecve, _wexecvp, _wexecvpe

executable files

internationalizing

Executing a Batch Move

Executing a Search with Find Methods

Executing a Search with Goto Methods

Executing an Update Statement

Executing Commands That Do Not Return Records

Executing Queries That Don't Return a Result Set

Executing SQL in the Data Explorer

Executing Stored Procedures That Don't Return a Result Set

Executing the Command

Executing the Commands using TSQLDataSet

Executing the SQL Statements

Executing thread objects

Executing Thread Objects

Explicit

implicit rules (MAKE)

Explicit Access Qualification

Explicit Conversion Operators (C++0x)

export

export,

Exporting And Importing Templates

Expression Statements

expressions

Expressions

Expressions (C++)

Expressions And C++

expressions, errors

expressions, evaluation order

Extended Types Formatted I/O

extending

Extending the Interface of the Application Server

Extending A namespace

Extending the IDE

extern

External Declarations and Definitions

extern Templates (C++0x)

F1000: Compiler table limit exceeded (C++)

F1001: Internal code generator error (C++)

F1002: Unable to create output file 'filename' (C++)

F1003: Error directive: 'message' (C++)

F1004: Internal compiler error (C++)

F1005: Include files nested too deep (C++)

F1006: Bad call of intrinsic function (C++)

F1007: Irreducible expression tree (C++)

F1008: Out of memory (C++)

F1009: Unable to open input file 'filename' (C++)

F1010: Unable to open 'filename' (C++)

F1011: Register allocation failure (C++)

F1012: Compiler stack overflow (C++)

F1013: Error writing output file (C++)

Fetching Metadata into a dbExpress Dataset

Fetching Multiple Result Sets

Fetching Records Asynchronously

Fetching the Data

Fetching the Data using TSQLDataSet

field attributes

field objects

dynamic vs. persistent

fields

File Date-time Routines

File dumping utility

File Inclusion With #include

File search utility

file stream

Filling in the Response Header

Filtering Multiple Rows Based On Update Status

Filtering Records Based On Bookmarks

filters

final attribute

Find method

findclose, _wfindclose

findfirst, _wfindfirst

Finding a File

findnext, _wfindnext

Fine-tuning a Connection

flat files

Float and Double Limits

float.h

Floating Functions

Floating functions (C++)

Floating Point Constants

Floating point error: Divide by 0 OR Floating point error: Domain OR Floating point error: Overflow (C++)

Floating point error: Partial loss of precision OR Floating point error: Underflow (C++)

Floating point error: Stack fault (C++)

fonts

for

Forcing Asynchronous Connections

Formal Parameter Declarations

formats

internationalizing

Formats and Sort Order

formatting data

data formats

Forming the Connection

forms

displaying an auto-created

layout

memory management

passing additional arguments

retrieving data from

retrieving data from modal

forms

using a local variable to create an instance

Forward Declaration of Enums (C++0x)

frame

friends, of classes

Function Call Operator

function calls

Function Calls And Argument Conversions

Function Failure Errors

Function Modifiers

Function Templates

Function Templates Overview

functions

conversion

Functions

functions, declarations

functions, parameters

Fundamental WebSnap components

Fundamental WebSnap Components

fwrite

gcvt

general applications

Generating a Handler for a Component's Default Event

Generating a New Event Handler

Generating an ActiveX Control Based On a VCL Form

Generating the content of response messages

Generating the Content of Response Messages

Generating the Day Numbers

Generating WSDL Documents for a Web Service Application

Generics

getcurdir, _wgetcurdir

Getting Information About the Client or Server Socket Connection

Getting Information About the Client Socket Connection

Getting more information

Getting More Information

Getting Parameters from the Application Server

Getting Started with InterBase Express

Getting started with IntraWeb

Getting Started with IntraWeb

Getting Started with Rave Reports

Getting the Pen Position

global routines

Granting Permission to Access and Launch the Application Server

pasting from clipboard

scrollable

shapes

using the clipboard

VCL Forms applications

graphics files

loading and saving

GREP.EXE

GREP.EXE, the text search utility

grids

group boxes

Group Boxes and Radio Groups

Grouping Controls

GUI applications

GUI Applications

Guidelines for Using Decision Support Components

Handling Batch Move Errors

Handling Boolean Field Values with Check Boxes

Handling Cached Update Errors

Handling Classes of Exceptions

Handling Command Parameters

Handling Constraints from the Server

Handling Delphi Features in C++Builder 2009

Handling Errors For The New Operator

Handling Events

Handling Events in an Automation Controller

Handling Exceptions

Handling Exceptions in the Thread Function

Handling Exceptions in VCL Applications

Handling messages

Handling Messages and System Notifications: Overview

Handling Mouse-down and Key-down Messages

Handling Multiple Drawing Objects in Your Application

Handling Palettes

Handling Server Constraints

Handling the OnPopup Event

Handling the Screen

header controls

Header Controls

Header File Search With "header_name"

Header File Search With <header_name>

headers

hello world

Help and Hint Properties

Help files for components

Help System Interfaces

Hiding and Showing Toolbars

Hiding Implementation Details

hiding names

Hiding Unused Items and Categories in Action Bands

Hiding the Main Form

hints

host environments

Hot Key Controls (VCL Only)

How Actions Find Their Targets

How Delphi Adds Events

How Delphi Adds Properties

How TApplication Processes VCL Help

How To Construct A Class Of Complex Vectors

How to Handle Delphi Anonymous Methods in C++

How to Handle Delphi AnsiString Code Page Specification in C++

How to Handle Delphi Generics in C++

How VCL Controls Process Help

HTML

HTML commands

HTML documents

HTML tag editor

HTML-transparent tags

HTTP

HTTP messages

HTTP Request Header Information

HTTP request messages

IAppServer interface

IDE

deleting toolbar buttons

extending

responding to IDE events

identifiers

Identifying Application Files

Identifiers

Identifiers Overview

Identifying Standard Events

Identifying the Database

IDL

IInterface interface

ILINK32.EXE, the Incremental Linker

image control adding

images

adding to a string list

adding to an application

IMPDEF.EXE, the Module Definition Manager

Implementing Binary Operations

Implementing COM Objects with Wizards

Implementing Commands

Implementing Comparison Operations

Implementing Drag and Dock in Controls

Implementing Drag and Drop in Controls

Implementing ICustomHelpViewer

Implementing IExtendedHelpViewer

Implementing IHelpSelector

Implementing IInterface

Implementing services

Implementing Services

Implementing the Standard Events

Implementing the Wizard Interfaces

Implementing Unary Operations

implements keyword

IMPLIB.EXE, the Import Library Tool

IMPLIB.EXE

Implicit And Explicit Template Functions

Import library tool (C++)

import, _import, __import

Importing Data from Another Table

Importing Resource Files

Importing Type Library Information

Importing WSDL Documents

Include files (C++)

Including Bi-directional Functionality in Applications

Including the Form Unit

Incomplete Declarations

Increment/decrement Operators

indexes

listing

searching for records

sorting records

specifying alternative

Indicating That a Control Is Owner-drawn

Indicating the Need for Client Action

Indicating the Response Status

Indicating the Types of Operations the Connection Supports

Indicating What Records Are Modified

Influencing How Updates Are Applied

Informational messages (C++)

inheritance

objects

Inheriting an Item

Inheriting Data and Code from an Object

initialization

Initializing After Loading

Initialization

Initializing a Thread

Initializing enumeration with type (C++)

Initializing Owned Classes

Initializing the Data Link

Initializing the Thread

inline

inline functions

In-process, Out-of-process, and Remote Servers

Inline Functions

input controls

controls

input method editor

IME

insline

Inspecting the Update Status of Individual Rows

installation programs

InstallAware Express

Installing Component Packages

Installing the Wizard Package

installing unit into a package

int

Integer Constant Without L Or U

INT_xxx #defines

Integer Constants

InterBase components

getting started

Interface Version Numbers

Internal Data Storage

Internal Representation of Numerical Types

Internal Representation Of Numerical Types

international applications

internationalization

Internationalization and Localization

Internationalizing Applications

Internet palette page

Web server applications

InternetExpress page producers

templates

Web pages

Interoperable Applications Procedures

Intervening as Updates Are Applied

IntraWeb

VCL for the Web

Introduction to component creation

Introduction To Constructors And Destructors

invokable interfaces

IP addresses

isalnum, __iscsym, iswalnum, _ismbcalnum

isalpha, __iscsymf, iswalpha, _ismbcalpha

ISAPI applications

isdigit, iswdigit, _ismbcdigit

isgraph, iswgraph, _ismbcgraph

islower, iswlower, _ismbclower

Isolating Resources

isprint, iswprint, _ismbcprint

ispunct, iswpunct, _ismbcpunct

isspace, iswspace, _ismbcspace

isupper, iswupper, _ismbcupper

isxdigit, iswxdigit

Iterating Through a Session's Database Components

Iterating Through Strings in a List

Keeping Track of Which Drawing Tool to Use

Keywords And Protected Words In Macros

Keywords

Keywords Overview

Keywords, Alphabetical Listing

Keywords, By Category

labels

lexical elements

Library manager (TLIB.EXE)

Lexical Elements

lfind

license requirements

software license requirements

Licensing ActiveX Controls

Limiting Dimension Selection in Decision Grids

Limiting Records with Parameters

Limiting Records with Ranges

Limiting What Records Appear

lines and polylines drawing

linkage

List Boxes and Check-list Boxes

List Controls

list views

List Views

listening connections

Listening Connections

Listening for Client Requests

Loading a Picture from a File

Loading and Saving Custom Variant Values

Loading and Saving Graphics Files

Loading and Saving String Lists

Loading and Storing Graphics

Loading Data from a File or Stream

Loading Data from and Saving Data to Files

loading images

files

Loading Packages in an Application

Loading Packages with the LoadPackage Function

locale.h

localeconv

Locale-specific Features

localization

definition

Localization

Localization Considerations in UI Design

Localizing Applications

localtime

Locating Event Handlers

Locating Items in a String List

logical operators

logins

long string routines

lookup fields

lookup list boxes

M_E, M_LOGxxx, M_LNxx #defines

M_SQRTxx #defines

macros

predefined (C++)

Macros With Parameters

Macros With Parameters Overview

main form

MAKE Rules (Explicit and Implicit) and Commands

MAKE.EXE

Making a Control a Dockable Child

Making a control data aware

Making a Control Data Aware

Making a dialog box a component

Making a Dialog Box a Component: Overview

Making a Windowed Control a Docking Site

Making Component Help Context-sensitive

Making components available at design time

Making Components Available at Design Time: Overview

Making Events Visible

Making Methods Virtual

Making Scrollable Graphics

Making Source Files Available

Making the Control Read-only

Making the Table a Detail of Another Dataset

malloc

malloc.h

Managing Database Connections

Managing database sessions

Managing Database Sessions

Managing Database Sessions Using TSession

Managing Events in Your Automation Object

Managing Layout

Managing Multiple Sessions

Managing Server Connections

Managing Transactions

Managing Transactions in Multi-tiered Applications

Manipulating Files

Manipulating Menu Items at Runtime

Manipulating Strings in a List

Mapping Between XML Nodes and Data Packet Fields

Mapping Data Types

Marking and Returning to Records

marshaling

mechanism

Marshaling Data

master

detail relationships/multi-tiered applications

detail relationships/queries

detail relationships/tables

detail tables/unidirectional datasets

math.h

max

MAXxxxx #defines (fnsplit)

MAXxxxx #defines (integer data types)

mblen

mbstowcs

mbtowc

MDI applications

multiple document interface

measurements

Member Access Control

member functions

Member Functions

Member Scope

members, scope

Memo and Rich Edit Controls

memo fields

displaying and editing

displaying with format information

Memory Block Comparison Warnings

memory management

interfaced objects

Memory Management of Interface Objects

Menu Designer

menu items

menus

manipulating menu items at runtime

specifying the active menu

merge modules

Merging Changes into Data

Merging Menus

message handlers

overriding message handlers

messages

metadata

Methods That Should Be Protected

Methods That Should Be Public

min

Mixed-Language Calling Conventions

Mixing and Converting String Types

modal

modal form

modeless

modifiers

modifiers, function

Modifying an existing component

Modifying a Range

Modifying an Existing Component: Overview

Modifying an Interface Using the Type Library

Modifying Connections in the Data Explorer

Modifying Data

Modifying Entire Records

Modifying Existing Controls

Modifying Shared Items

Modifying the Change Method

Modifying the Component Object

Module definition files

Module Definition Files

Module Definition Manager

IMPDEF.EXE

mouse

responding to

mouse actions

adding a field to a form

mouse events

mouse move

mouse pointer

MoveFile

movement

MTS

Multibyte Character Sets (MBCS)

Multidimensional Crosstabs

multimedia

Multiplicative Operators

multi-read exclusive write synchronizer

synchronizer

Multithread Programs

Multithread Variables

multithreaded applications

checking other threads

multi-read exclusive-write synchronizer

simultaneous thread access

synchronizing background threads

task completion

thread object

thread-local variables

waiting for threads

writing the thread function

multi-threaded applications

applications

multi-tiered applications

multiple remote data modules

overview

providers

state information

multi-tiered database applications

namespaces, overview

Naming a Data Module and Its Unit File

naming

threads

Naming a Session

Naming a Thread

naming conventions

Naming Conventions for Template Menu Items and Event Handlers

Naming Menus

Naming Methods

Naming the Menu Items

Navigating and Manipulating Records

Navigating Data in Client Datasets

Navigating Datasets

Navigating Days

Navigating Months and Years

Navigating Records in a Filtered Dataset

NDEBUG #define

nested types

Nesting Parentheses And Commas

Nested Types

nesting

new

New-style Typecasting Overview

New Field dialog box

new.h

New-style Typecasting

NFDS #define

Non-blocking connections

Non-blocking Connections

nonvisual components

noreturn attribute

not

Not Using Reference Counting

not, !

not_eq

Notifying a Wizard of IDE Events

not_eq, !=

NULL #define

null directive

Null pointer assignment (C++)

nullptr

O2237: DPMI programs must use the large memory model (C++)

null-terminated string routines

strings

O_xxxx #defines

object fields

object pooling

Object Repository

object-oriented programming

component writing

Object-oriented programming for component writers

Object-oriented Programming for Component Writers: Overview

objects

Objects, Components, and Controls

variables

Objects

Obtaining Aggregate Values

Obtaining an Editable Result Set

Obtaining Information About Indexes

Obtaining Metadata

Obtaining Tools API Services

OEM and ANSI Character Sets

OEM character sets

ANSI character sets

Off-screen Bitmaps

offsetof

OLE containers

object linking and embedding

One-Dimensional Crosstabs

OnPopup event

Open Tools API

Opening a Connection Using TDataBase

Opening an Existing Type Library

Opening and Closing Datasets

Opening and Closing Decision Grid Fields

Opening Database Connections

Opening the Dataset in Batch Update Mode

Opening the Menu Designer

Operating System Versions

operator

operator new

Operator new Placement Syntax

Operator new

Operator Overloading Overview

Operators

Operators Summary

operators, binary

operators, C++ specific

operators, equality

operators, expressions

operators, function calls

operator overloading, C++

operators, overloading

operators, relational

in C++

operators, summary

operators, unary

or, ||

or_eq

Order Of Calling Constructors

or_eq, |=

Organizing Actions for Toolbars and Menus

Other Techniques for Sharing Memory

Overloaded functions, resolution

Overloaded Operators And Inheritance

Overloading Binary Operators

Overloading Constructors

Overloading Operator Functions

Overloading Operator Functions Overview

overloading operators

Overloading The Assignment operator =

Overloading Operators

Overloading The Class Member Access Operators ->

Overloading The Function Call Operator ( )

Overloading The Operator delete

Overloading The Operator new

Overloading The Subscript Operator []

Overloading Unary Operators

Overriding A Template Function

overriding methods

Overriding the Constructor

Overriding Methods

Overriding the Constructor and Destructor

Overriding the Dataset On the Application Server

Overriding the Default Priority

Overriding the DefineProperties Method

Overriding the Handler Method

Overview of a Three-tiered Application

Overview of ADO Components

Overview of COM Technologies

Overview of Component Creation

Overview of Decision Support Components

Overview of Graphics

Overview of Graphics Programming

Overview of the Tools API

Overview of Using Cached Updates

owner-draw controls

P_xxxx #defines

package

installing units into

Package Collection Files

Package Files

Package Files Created by Compiling

packages

editing source files manually

files

installing component

loading/unloading

overview of creating and editing

packages

runtime defined

structure

using command-line compiler and linker

using in an application

packages and DLLs

Packages and Standard DLLs

Package-specific Compiler Directives

page controls

Page Controls

Page dispatcher operation

page options

WebApp

page producers

chaining

Page Producers

Pages of Type Information

paint boxes

palettes

Paradox tables

network control files

passwords

parameters

ADO command

getting from providers

ParentBiDiMode Property

Parts of a COM Application

Parts of a Uniform Resource Locator

Parts of the Type Library Editor

pascal

pascal, _pascal, __pascal

Passing a Local Variable as a PChar

Passing Additional Arguments to Forms

Passing File Information To Child Processes

Passing Parameters to the Source Dataset

Pasting Graphics from the Clipboard

Pathname Merging and Splitting Warnings

paValueList

paSubProperties

PChar local variables

Perform method

Performing Conversions

perror,_wperror

persistent columns

adding buttons

deleting in Columns editor

reordering

persistent connections

Persistent Field Components

persistent fields

picture

pictures

pixels

Placing A Bitmap Image in a Control in a VCL Forms Application

Placing and Naming Components

placing bitmap images

Placing the Control

Plus And Minus Operators

pointers

Pointers

Pointers To Functions

Pointers To Objects

pointers, constants

pointers, conversions

pointers, objects

poly, polyl

polygons

polylines

polymorphic classes

Pooling Remote Data Modules

Polymorphic Classes

Possible Declarations

Postfix Expression Operators

PostMessage method

Pragma Directives Overview

precedence

Predefined Action Classes

Precedence Of Operators

Precompiled header files

Predefined Macros

Predefined Macros Overview

Preparing Queries

Preparing Stored Procedures

Preprocessor (C

C++)

Preprocessor Directives

Primary Expression Operators

printf, wprintf

Printf/Scanf floating-point formats not linked (C++)

Printing

private

Private, Protected, Public, and Published Declarations

procedure

procedures

Processing Headers in Client Applications

Procedures

process.h

Programming a Calculated Field

Programming for Varying Host Environments

Programming with Delphi

project directory

projects

properties

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

Properties, Methods, and Events

property

Property Categories

Property Declarations

property editors

associating with ActiveX controls

property page

adding controls

updating

property page wizard

creating a new property page

protected methods

protocols

providers

XML

Providing a Pop-up Menu

Providing an OnChange Event

Providing Help for Your Component

pseudovariables

public

published

Publishing Inherited Properties

Publishing Inherited Properties (Graphic)

Publishing Inherited Properties (Grid)

Publishing the Pen and Brush

punctuators

Pure virtual function called (C++)

Punctuators

Punctuators Overview

Putting a Button in a Column

queries

setting parameters at design time

setting parameters at runtime

unidirectional cursors

update objects

updating a read-only result set

ranges

Rave component overview

Rave Component Overview

Rave Reports

Rave Reports: Overview

Rave Visual Designer

RC.EXE, the Microsoft SDK Resource Compiler

read

write

readdir, wreaddir

Reading a String and Writing It To a File

Reading and Setting Pixels

Reading and Writing Events

Reading and writing over socket connections

Reading and Writing Over Socket Connections

ReadOnly property

FReadOnly

realloc

Receiving Adapter Requests and Generating Responses

Reconciling Update Errors

records

navigating and manipulating

reference declarations

Reference/Deference Operators

reference fields

references

references, arguments

references, simple

Referential Integrity, Stored Procedures, and Triggers

Referencing

referential integrity

stored procedures

Refining Line Drawing

Refining the Shape Drawing

Refreshing Data Display

Refreshing Records

Refreshing the Screen

Refreshing the Type Library

Registering an Active Server Object

Registering a COM Object

Registering Actions

registering components

Tool palette

Registering Components

Registering Components (Introduction)

Registering Help System Objects

Registering Multiple Properties at Once

Registering Nonscalar Types

Registering One Property at a Time

Registering the Application Server

Registering the Component

Registering the Component Editor

Registering the Property Editor

Registering the Type Library

RegisterPropertyEditor

registering property editors

Registry

system registry

Regular Expression for CodeGear Grep

Regular Methods (C++)

reinterpret_cast

typecasting, C++

reinterpret_cast (typecast Operator)

relational operators

Removing Attribute Associations

Remotable Object Example

remote connections

remote data modules

Removing Dependencies

rename

Reorganizing Rows and Columns in Decision Grids

Replacing the Picture

Reporting Procedures

reports

Rave

Rave Reports

Representing a Dataset in HTML

Representing Calculated Values

Representing the Records in a Table

Representing the Results of a Query

Representing the Results of a Stored Procedure

Requesting Data from the Source Dataset or Document

resizing

resolving

influencing generated SQL

Resolving Update Errors On the Provider

resource DLLs

resource files

resources

Responding to a Mouse Move

Responding to a Mouse-down Action

Responding to a Mouse-up Action

Responding to Changes

Responding to Changes Mediated by the Data Source

Responding to Clicks

Responding to Client Data Requests

Responding to Client Requests

Responding to Client Update Requests

Responding to Client-generated Events

Responding to data changes

Responding to Data Changes

Responding to Key-down Messages

Responding to Mouse-down Messages

Responding to Palette Changes

Responding to Request Messages with Action Items

Responding to socket events

Responding to Socket Events

Responding to System Events

Responding to the Mouse

Responding to User Actions at Runtime

response messages

status

response templates

HTML templates

Restoring Default Values to a Column

restrict

Restricting Field Values with Radio Controls

Resume method

Suspend method

Retrieving Data from Forms

Retrieving Data from Modal Forms

Retrieving Data from Modeless Forms

Retrieving Information About a Session

Retrieving Result Sets with Commands

return

Returning a PChar Local Variable

reusing code

techniques

Reusing Code and Delegation

Reusing Components and Groups of Components

rewind

rewinddir, wrewinddir

Ribbon Controls

adding commands to the ribbon

creating an application

rich edit controls

RLINK32.DLL, the Resource Linker (C++)

rounded rectangles

RTTI

Running the Completed Application

rubber banding example

Rubber Banding Example

Runtime Packages

Runtime type identification

Run-time Type Identification (RTTI)

Runtime Type Identification (RTTI) Overview

Runtime Type Identification And Destructors

rvalue References (C++0x)

safecall

Saving a Menu as a Template

Saving a Picture to a File

Saving a Type Library

Saving and Registering Type Library Information

Saving Changes

Saving Data to a File or Stream

Saving Decision Graph Series Settings

scanf, wscanf

SCHAR_xxx #defines

scope

Scope of Exception Handlers

objects

Scope

Scope and Qualifiers

Scope Resolution Operator ::

scope, resolution operator

operator overloading, C++

scope, rules

Screen Resolutions and Color Depths

scoped enums

C++

screen refreshing

Screen Scaling and ChangeScale

Screening Individual Updates

SDI applications

single document interface

repeating or extending

specifying current record

search criteria

index-based searches

searching for data

Searching Datasets

Searching for a Database Connection

Searching On Partial Keys

searchpath, wsearchpath

SelectAll

Selecting a Server Type

Selecting All Text

Selecting Menu and Toolbar Styles

Selecting Text

Selecting the Current Day

Selecting Web Application Module Options

Selection Statements

Sending a Message That Does Not Execute Immediately

Sending a Message Using the Windows Message Queue

Sending Commands to the Server

sending messages

overview

Sending Messages

Sending Query or Stored Procedure Parameters

SendMessage method

server sockets

ServerSocket component

Server-side scripting in WebSnap

Server-side Scripting in WebSnap

service applications

Service Name Properties

Service Threads

services

sockets

Services and Ports

Serving Client Requests

sessions

set_new_handler

Setting a Default Value for a Field

set_new_handler function

setlocale, _wsetlocale

setmem

setmode

Setting BDE Alias Parameters

Setting Column Properties at Design Time

Setting Component Properties

Setting Decision Graph Template Defaults

Setting Dimension State

Setting Display and Edit Properties at Design Time

Setting Field Component Properties at Runtime

Setting Filter Options

Setting Grid Options

Setting IDE, Project, and Compiler Options

Setting Maximum Dimensions, Summaries, and Cells

Setting Options That Influence the Data Packets

Setting Owned Classes' Properties

Setting Pages to Require Logins

Setting Persistent Field Properties and Events

Setting Properties at Design Time

Setting Properties at Runtime

Setting Properties, Methods, and Events

Setting Text Alignment

Setting the Appearance of the Cool Bar

Setting the Brush Bitmap Property

Setting the Filter Property

Setting the Initial Bitmap Size

Setting the Initial Condition of a Speed Button

Setting the Maximum Available Dimensions and Summaries

Setting the Property Value

Setting the Response Content

Setting Tool Button Appearance and Initial Conditions

Setting Up a Simple Dataset

Setting Up Action Bands

Setting Up Action Lists

Setting Up Master/Detail Linked Relationships

Setting Up the Remote Data Module

Setting Up TSQLConnection

Setting Web Item Properties

Sharing Code Among Event Handlers

Sharing Frames

Sharing Items Within a Project

Sharing Objects in a Team Environment

short

Side Effects And Other Dangers

SHRT_xxx #defines

sizeof operator

Sizing Owner-draw Items

SOAP

SOAP application wizard

sockets

Sockets

Software License Requirements

sort order

specifying

Sorting and Indexing

Sorting Records with Indexes

spawnl, spawnle, spawnlp, spawnlpe, spawnv, spawnve, spawnvp, spawnvpe, _wspawnl, _wspawnle, _wspawnlp, _wspawnlpe, _wspawnv, _wspawnve, _wspawnvp, _wspawnvpe

Special Types

Specialized Input Controls

Specifying a Batch Move Mode

Specifying a Connection Using DCOM

Specifying a Connection Using HTTP

Specifying a Connection Using SOAP

Specifying a Connection Using Sockets

Specifying a dBASE Index File

Specifying a Palette for a Control

Specifying a Provider

Specifying Accelerator Keys and Keyboard Shortcuts

Specifying Aggregates

Specifying an Index with IndexName

Specifying Application Module Components

Specifying Default Database Connection Behavior

Specifying Default Values

Specifying Editor Attributes

Specifying Menu Items

Specifying No Default Value

Specifying Paradox Directory Locations

Specifying Property Categories

Specifying Ranges

Specifying the Active Menu: Menu Property

Specifying the Columns

Specifying the Command

Specifying the Command to Execute

Specifying the Components

Specifying the Current Record After a Successful Search

Specifying the Data to Display using TSQLDataSet

Specifying the Desired Server

Specifying the HTML Template

Specifying the New Default Property Value

Specifying the Palette Page

Specifying the Port

Specifying the Provider using TLocalConnection or TConnectionBroker

Specifying the Query

Specifying the Row Attributes

Specifying the Stream Position and Size

Specifying the Table Attributes

Specifying the Table Type for Local Tables

Specifying the Transaction Isolation Level

Specifying What Data to Display

Specifying What Fields Appear in Data Packets

Specifying Whether the Connection Automatically Initiates Transactions

speed button

adding to a panel

assigning a glyph

creating a group

setting the initial condition

splitter control

SQL

SQL statements

standard events

Starting a Drag Operation

Starting and Stopping Threads

Statement Keywords

statements

Statements

statements, expression

statements, iteration

statements, jump

statements, labeled

statements, selection

static

Static Assertions (C++0x)

static members

Static Members

Static Methods

static properties

Static Properties

Static Runtime Libraries

static_assert

static_cast (typecast Operator)

static_cast

typecasting, C++

stderr, stdin, stdout

stdio.h

stdlib.h

stime

Storage Class Specifiers

storage classes

Storage Classes And Types

stored procedures

Storing a Custom Variant Type's Data

Storing and Loading Properties

Storing and Loading Unpublished Properties

Storing the Internal Date

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

reading and writing data

strerror

strftime, wcsftime

stricmp, _mbsicmp, _wcsicmp

Stricter C++ Compiler (C++Builder 2007)

Stricter C++ Compiler: Binding of References and Qualifiers

Stricter C++ Compiler: Function Overload Resolution

Stricter C++ Compiler: Initialization and Conversion

Stricter C++ Compiler: String Literals Are Now Constants

Stricter C++ Compiler: Template Changes

String Comparison Warnings

string list

string lists

String to PChar Conversions

string types

conversions

string.h

strings

accessing in a string list

adding and sorting

declaring and initializing

deleting

enabling applications

sort list

working with

strlen, _mbslen, wcslen, _mbstrlen

strlwr, _mbslwr, _wcslwr

strncat

strncmp, _mbsncmp, wcsncmp

strncmpi, wcsncmpi

strncoll, strnicoll, _mbsncoll, _mbsnicoll, _wcsncoll, _wcsnicoll

strncpy, _mbsncpy, wcsncpy

strnicmp, _mbsnicmp, _wcsnicmp

strnset, _mbsnset, _wcsnset

Strongly Typed Enums (C++0x)

strpbrk, _mbspbrk, wcspbrk

strrchr, _mbsrchr, wcsrchr

strrev, _mbsrev, _wcsrev

strset, _mbsset, _wcsset

strspn, _mbsspn, wcsspn

strstr, _mbsstr, wcsstr

strtod, _strtold, wcstod, _wcstold

strtok, _mbstok, wcstok

Structure Member Access

Structure Member Declarations

Structure Name Spaces

structures

Structures

Structures And Functions

structures, member access

structures, member declarations

structures, name spaces

structures, untagged

Subclassing Windows Controls

structures,anonymous

strupr, _mbsupr, _wcsupr

strxfrm, wcsxfrm

Style property

brushes

subcomponents

Supplying Parameters at Design Time

Supplying Parameters at Runtime

Supporting Master/detail Relationships

Supporting Properties and Methods in Custom Variants

Supporting State Information in Remote Data Modules

swab

switch

Switching Between Menus at Design Time

system events

Table Of CodeGear C++ Register Pseudovariables

tables

decision support components

emptying

exclusive access

local table types

master/detail realtionships

TApplication

TCanvas

TComponent branch

TControl branch

TCP

IP/distributing applications

TDUMP.EXE

TDUMP.EXE, the File Dumping Utility

tell

template

Template Arguments

Template Body Parsing

Template Compiler Switches

Template Generation Semantics

templates

templates, arguments

templates, class

templates, compiler options

templates, DLLs

templates, function

templates, overriding

templates, syntax checking

Templates,in version 3.0

Terminology and standards

Temporaries, C++

TEncoding

using for Unicode

Tentative Definitions

terminate

Terminology and Standards

Testing and Debugging the Active Server Page Application

Testing and Debugging the Application

Testing Installed Components

Testing the Component

Testing Uninstalled Components

text

text viewing controls

controls

Text Viewing Controls

TFileStream

TForm

The #error Control Directive

The #line Control Directive

The Content of HTTP Request Messages

The Copy Constructor

The Data Dictionary

The Decision Graph Display

The delete Operator With Arrays

The Fundamental COM Interface, IUnknown

The Fundamental Types

The Keyword This

The main() Function

The Marshaling Mechanism

The new And delete Operators

The Operator new With Arrays

The Preprocessor

The Read Method

The Request Method Type

The Scope Resolution Operator

The structure of a Web Broker application

The Structure of a Web Broker Application

The Structure of Metadata Datasets

The Structure of the Application Server

The Structure of the Client Application

The Target URL

The Three Char Types

The Typeid Operator

The Value main() Returns

The Web Application Object

thread functions

thread objects

New Thread Object dialog

thread_local

avoiding simultaneous access

thread-local variables

threadvar

threads

multi-threaded applications

Throwing An Exception (C++)

TIniFile

TLIB.EXE, the Library Manager

Token Pasting With ##

tokens

tolower, _mbctolower, towlower

Tokens

Tokens Overview

tool buttons

setting appearance and initial conditions

tool changing with speed buttons

toolbar

adding using a panel component

adding using the toolbar component

Tools API

Tools for Working with the BDE

TOUCH.EXE

toupper, _mbctoupper, towupper

TPersistent branch

TPrinter

track bars

tracking

Tracking the Origin Point

transactions

automatic

databases

isolation levels

multi-tiered applications

Transactions

transformation files

xml mapper

translation units

Troubleshooting Custom Components (C++)

TRegistry

TRegistryIniFile

try

advantages and disadvantages

try..finally statements

finally keyword

TScreen

using

TService

TDependency

TSimpleDataSet

using

TVarData type

custom variants

TWinControl

TWidgetControl branch/overview

TWinControl/TWidgetControl Branch

type library

adding a record or union

adding an alias

adding an enumeration

adding an interface

adding CoClass members

adding properties and methods

apply updates dialog

creating a new

enabling simple data binding in an ActiveX control

modifying an interface

saving and registering information

Type Library Elements

Type Library Wizard

Type Specifier decltype (C++0x)

Type Specifiers

Type Specifiers (C++)

Type Trait Functions (C++0x)

Type trait functions and Incomplete types

C++0x features

Type trait functions and Intrinsic functions

C++0x features

Type Trait Functions Overview (C++0x)

Types of dbExpress Datasets

Types of Events

Types of Graphic Objects

Types of Properties

Types of socket connections

Types of Socket Connections

Types of Web Server Applications

types, fundamental

Understanding Database and Session Component Interactions

uChild.pas

Understanding datasets

Understanding Datasets: Overview

Understanding Invokable Interfaces

Understanding Multi-tiered Database Applications

Understanding Parameter Substitution in Update SQL Statements

Understanding Service Protocols

Understanding the component library

Understanding the Component Library

Understanding the Differences Between Ranges and Filters

Understanding the message-handling system

Understanding the Structure of a Package

Undoing Changes

unexpected

Unexpected termination during compilation [Module Seg#:offset] OR Unexpected termination during linking [Module Seg#:offset] (C++)

ungetc, ungetwc

ungetch

Unicode

Enabling C++ applications

TCHAR mapping for C++

using TEncoding

Unicode Character Types and Literals (C++0x)

Unicode for C++

Unicode TCHAR mapping

unidirectional datasets

executing SQL commands

opening

representing tables

stored procedures

unidirectional DataSets

unions

Unions

unions, anonymous

unions, declarations

unit

creating for a component

installing to a package

unnamed threads

unsigned int __array_extent( typename T, unsigned intI )

unsigned __int_array_rank( typename T )

Untagged Structures And Typedefs

Unwinding Exceptions (C++)

update errors

update objects

UpdateObject

updates

updating

Updating a Read-only Result Set

Updating Actions

Updating Records

Updating the Dataset

Updating the Field Data Link Class

Updating the Object

Updating the Property Page

Up-down Controls (VCL Only)

URLs

hosts

request targets

Use __fastcall When Overriding VCL Methods

Use of Storage Class Specifiers

User Access Rights

user interface

developing

User Interface Models

user interfaces

internationalizing

multiple records

single record

Users Can Override Default Handling

using (declaration)

Using a Class to Manage Conversions

Using a Client Dataset to Cache Updates

Using a Client Dataset with a Provider

Using a Client Dataset with File-based Data

Using a Conversion Function

Using a Dedicated File on Disk

Using a Grid Control in Its Default State

Using a Multi-Tiered Architecture

Using a Picture, Graphic, or Canvas

Using a Simple Dataset

Using a Single Navigator for Multiple Datasets

Using Action Lists

Using ActionManager to Create Actions in a VCL Forms Application

Using ActiveX controls

Using ADO datasets

Using an Item

Using an Object Repository Item in a Project

Using an Update Component's Query Property

Using an XML Broker

Using an XML Document as the Client of a Provider

Using an XML Document as the Source for a Provider

Using and Modifying Frames

Using Angle Brackets In Templates

Using Batch Updates

Using BDE

Using BDE-enabled datasets

Using BDE-enabled Datasets

Using Brushes

Using Canvas Methods to Draw Graphic Objects

Using client datasets

Using Client Datasets: Overview

Using client sockets

Using Client Sockets

Using Code That the XML Data Binding Wizard Generates

Using CodeGuard

Using COM Wizards

Using Command Objects

Using Common Data Control Features

Using Component Properties and Events in a Data Module

Using Component Wrappers

Using Critical Sections

Using data controls

Using Data Controls

Using Data Explorer to Obtain Connection Information

Using data modules

Using Data Modules

Using Database Components in Data Modules

Using database information in responses

Using Database Information in Responses

Using databases

Using Databases

Using Dataset Page Producers

Using Datasets with Decision Support Components

Using DataSnap

Using dbExpress

Using dbExpress Components

Using dbExpress Datasets

Using DCOM Connections

Using Decision Cubes

Using Decision Graphs

Using Decision Grids

Using Decision Pivots

Using Decision Sources

Using decision support components

Using Decision Support Components

Using Default Formatting for Numeric, Date, and Time Fields

using Directive

Using DLLs in RAD Studio (C++)

Using Drawing Tools

Using Editor Interfaces

Using fastmath math routines

Using File Streams

Using Forms

Using graphics in components

Using Graphics in Components: Overview

Using Help in a VCL Application

Using IHelpSystem

Using Implements for Delegation

Using Implicit Connections

Using Include Files

Using Indexes to Group Data

Using Indexes to Search for Records

Using Installation Programs

Using Interfaces

Using Interfaces Across the Hierarchy

Using Interfaces in Distributed Applications

Using Interfaces with Procedures

Using Internally Calculated Fields in Client Datasets

Using IntraWeb (VCL for the Web)

Using IntraWeb Components

Using IntraWeb with Web Broker and WebSnap

Using Local Transactions

Using Locate

Using Lookup

Using Maintained Aggregates

Using Menu Templates

Using Message Parameters

Using Module Interfaces

Using Multiple Remote Data Modules

Using Multiple Update Objects

Using Native IDE Objects

Using Nested Detail Tables

Using Nonscalar Types in Invokable Interfaces

Using Object Fields

Using Object Pascal or IDL Syntax

Using Object Variables

Using --p (Pascal Calling Conventions)

Using Page Producer Components

Using Page Producers from an Action Item

Using Paged Dimensions

Using Parameters in Queries

Using Passthrough SQL

Using Pens

Using Ports

Using Precompiled Header Files

Using Predefined HTML-transparent Tag Names

Using Project Templates

Using Property Editors

Using provider components

Using Provider Components

Using Query-type Datasets

Using Rave Reports in RAD Studio

Using Reference Counting

Using Remotable Objects

Using Resource DLLs

Using Server Constraints

Using server sockets

Using Server Sockets

Using SOAP Connections

Using socket components

Using Socket Components

Using Socket Connections

Using Stored Procedure-type Datasets

Using Streams

Using Streams to Read or Write Data

Using Table Producers

Using Table Type Datasets

Using TADODataSet

Using TBatchMove

Using TBatchMove (BDE)

Using TDatabase to Connect to Databases

Using TDataSet Descendants

Using TDataSetTableProducer

Using TDBListBox and TDBComboBox

Using Templates

Using TEncoding for Unicode Files

Using the as Operator with Interfaces

Using the ASP Intrinsics

Using the Automation Object Wizard

Using The Backslash (\) For Line Continuation

Using the BDE to cache updates

Using the BDE to Cache Updates

Using the Borland Database Engine

Using the Canvas

Using the Clipboard with Graphics

Using the COM Object Wizard

Using The -D And -U Command-line Options

Using the Decision Cube Editor

Using the Document Object Model

Using the Eof and Bof Properties

Using the Execute Method

Using the First and Last Methods

Using the HTML Tag Editor

Using the IsPropertyInCategory Function

Using the Javascript Libraries

Using the Main Form

Using the Main VCL Thread

Using the Menu Designer Context Menu

Using the MoveBy Method

Using the Multi-read Exclusive-write Synchronizer

Using the Next and Prior Methods

Using the object model

Using the Object Model

Using the Object Repository

Using the Properties of the Canvas Object

Using the RegisterComponents Function

Using the Sender Parameter

Using the Sessions Service

Using the SOAP Application Wizard

Using the Store-and-load Mechanism

Using the TCustomVariantType Descendant

Using the Type Library Editor

Using the Update SQL Editor

Using the VCL/RTL

Using the VCL/RTL: Overview

Using the Web Application Debugger

Using the Web Page Editor

Using the WSDL Importer

Using the XML Data Binding Wizard

Using Thread-local Variables

Using TIniFile and TMemIniFile

Using TOUCH.EXE

Using TQuery

Using TQuery (Procedure)

Using TQueryTableProducer

Using Transactional Data Modules

Using transactions with the BDE

Using Transactions with the BDE

Using TRegistry

Using TRegistryIniFile

Using TSimpleDataSet

Using TSimpleObjectBroker

Using TSQLQuery

Using TSQLStoredProc (Procedure)

Using TSQLTable

Using TStoredProc

Using TTable

Using TTable (Procedure)

Using TUpdateSQL to Update a Dataset

Using TXMLDocument

Using Type-safe Generic Lists In Templates

Using Unidirectional Result Sets

Using Update Objects to Update a Dataset

Using Web Broker

Using Web Connections

Using Web Services

Using WebSnap

Using Windows Common Dialog Boxes

Using XML in database applications

Using XML in Database Applications

Using XMLMapper

utime.h

Uxxxx_MAX #defines

va_arg, va_end, va_start

Valid Types

Value List Editors (VCL Only)

values.h

Variable Modifiers

variables, multithread

variants

VCL

CLX

VCL applications

VCL Class Declarations

VCL component

creating Windows application

VCL Exception Classes

VCL for the Web

VCL Forms

multithreaded applications

decision support

MDI applications

Viewing and Changing Design Options

Viewing and Changing Dimension Settings

Viewing and Editing Data with TDBGrid

Viewing Overall Decision Graph Properties

Viewing the Menu

virtual

virtual base classes

Virtual Base Classes

virtual destructors

Virtual Destructors

virtual functions

Virtual Functions

virtual methods

Virtual Methods

visibility

W8000: Ambiguous operators need parentheses (C++)

Vista

W8001: Superfluous & with function (C++)

W8002: Restarting compile using assembly (C++)

W8003: Unknown assembler instruction (C++)

W8004: 'identifier' is assigned a value that is never used (C++)

W8005: Bit fields must be signed or unsigned int (C++)

W8006: Initializing 'identifier' with 'identifier' (C++)

W8007: Hexadecimal value contains more than three digits (C++)

W8008: Condition is always true OR W8008 Condition is always false (C++)

W8009: Constant is long (C++)

W8010: Continuation character \ found in // comment (C++)

W8011: Nonportable pointer comparison (C++)

W8012: Comparing signed and unsigned values (C++)

W8013: Possible use of 'identifier' before definition (C++)

W8014: Declaration ignored (C++)

W8015: Declare 'type' prior to use in prototype (C++)

W8016: Array size for 'delete' ignored (C++)

W8017: Redefinition of 'x' is not identical (C++)

W8018: Assigning 'type' to 'enumeration' (C++)

W8019: Code has no effect (C++)

W8020: 'identifier' is declared as both external and static (C++)

W8021: Handler for 'type1' hidden by previous handler for 'type2' (C++)

W8022: 'function1' hides virtual function 'function2' (C++)

W8023: Array variable 'identifier' is near (C++)

W8024: Base class 'class1' is also a base class of 'class2' (C++)

W8025: Ill-formed pragma (C++)

W8026: Functions with exception specifications are not expanded inline (C++)

W8027: Functions containing 'statement' are not expanded inline (C++)

W8028: Temporary used to initialize 'identifier' (C++)

W8029: Temporary used for parameter '???' (C++)

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' (C++)

W8032: Temporary used for parameter 2 in call to '???' (C++)

W8033: Conversion to 'type' will fail for members of virtual base 'class' (C++)

W8034: Maximum precision used for member pointer type 'type' (C++)

W8035: User-defined message (C++)

W8036: Non-ANSI keyword used: 'keyword' (C++)

W8037: Non-const function 'function' called for const object (C++)

W8038: constant member 'identifier' is not initialized (C++)

W8039: Constructor initializer list ignored (C++)

W8040: Function body ignored (C++)

W8041: Negating unsigned value (C++)

W8042: Initializer for object 'x' ignored (C++)

W8043: Macro definition ignored (C++)

W8044: #undef directive ignored (C++)

W8045: No declaration for function 'function' (C++)

W8046: Pragma option pop with no matching option push (C++)

W8047: Declaration of static function function ignored (C++)

W8048: Use qualified name to access member type 'identifier' (C++)

W8049: Use '> >' for nested templates Instead of '>>' (C++)

W8050: No type OBJ file present; disabling external types option. (C++)

W8051: Non-volatile function 'function' called for volatile object (C++)

W8052: Base initialization without a class name is now obsolete (C++)

W8053: 'ident' is obsolete (C++)

W8054: Style of function definition is now obsolete (C++)

W8055: Possible overflow in shift operation (C++)

W8056: Integer arithmetic overflow (C++)

W8057: Parameter 'parameter' is never used (C++)

W8058: Cannot create pre-compiled header: 'reason' (C++)

W8059: Structure packing size has changed (C++)

W8060: Possibly incorrect assignment (C++)

W8061: Initialization is only partially bracketed (C++)

W8062: Previous options and warnings not restored (C++)

W8063: Overloaded prefix operator 'operator' used as a postfix operator (C++)

W8064: Call to function with no prototype (C++)

W8065: Call to function 'function' with no prototype (C++)

W8066: Unreachable code (C++)

W8067: Both return and return with a value used (C++)

W8068: Constant out of range in comparison (C++)

W8069: Nonportable pointer conversion (C++)

W8070: Function should return a value (C++)

W8071: Conversion may lose significant digits (C++)

W8072: Suspicious pointer arithmetic (C++)

W8073: Undefined structure 'structure' (C++)

W8074: Structure passed by value (C++)

W8075: Suspicious pointer conversion (C++)

W8076: Template instance 'specifier' is already instantiated (C++)

W8077: Explicitly specializing an explicitly specialized class member makes no sense (C++)

W8078: Throw expression violates exception specification (C++)

W8079: Mixing pointers to different 'char' types (C++)

W8080: 'identifier' is declared but never used (C++)

W8081: Void functions may not return a value (C++)

W8082: Division by zero (C++)

W8083: Pragma pack pop with no matching pack push (C++)

W8084: Suggest parentheses to clarify precedence (C++)

W8085: Function 'function' redefined as non-inline (C++)

W8086: Incorrect use of #pragma alias "aliasName"="substituteName" (C++)

W8087: 'operator::operator==' must be publicly visible to be contained by a 'type' (C++)

W8089: 'type::operator<' must be publicly visible to be contained by a 'type' (C++)

W8090: 'type::operator<' must be publicly visible to be used with 'type' (C++)

W8091: 'type' argument 'specifier' passed to 'function' is a 'iterator category' iterator: 'iterator category' iterator required (C++)

W8092: 'type' argument 'specifier' passed to 'function' is not an iterator: 'type' iterator required (C++)

W8093: Incorrect use of #pragma codeseg [seg_name] ["seg_class"] [group] (C++)

W8094: Incorrect use of #pragma comment( <type> [,"string"] ) (C++)

W8095: Incorrect use of #pragma message( "string" ) (C++)

W8096: Incorrect use of #pragma code_seg(["seg_name"[,"seg_class"]]) (C++)

W8097: Not all options can be restored at this time (C++)

W8098: Multi-character character constant (C++)

W8099: Static main is not treated as an entry point (C++)

W8103: Path 'path' and filename 'filename' exceed maximum size of 'n' (C++)

W8104: Local Static with constructor dangerous for multi-threaded apps (C++)

W8105: %s member '%s' in class without constructors (C++)

W8105: Reference/Constant member 'identifier' in class without constructors (C++)

W8106: %s are deprecated (C++)

W8107: Type name expected (C++)

W8108: Constant in new expression requires an initializer (C++)

W8109: Parameter '%s' is a dependent type (C++)

W8110: Duplicate '%s' attribute directive ignored (C++)

W8112: Unresolved dependencies in expression (C++)

W8113: Inline function was declared with 'extern template' (C++)

wait

Waiting for a Task to Be Completed

Waiting for a Thread to Finish Executing

Waiting for Other Threads

Web Application Debugger

Web Application Module Types

Web Application object

Web Broker

Web Application Support

Web applications

web browser

web component

Web data modules

Web items

Web page modules

Web request properties

Web server applications

Web Broker applications

Web Services

Web Services Overview

Web Services Procedure

adapter requests and responses

adding login support

dispatcher components

dispatching action items

dispatching requests and responses

server-side scripting

WebSnap applications

What Goes into a Component?

What Happens When an Action Fires

What Is an Action?

What Is an Object?

What's in a Mouse Event

What's in a Windows Message?

When to Use Packages and DLLs

When to Use TSimpleDataSet

whitespace

Wide-character And Multi-character Constants

Whitespace

Whitespace Overview

Why Create Properties?

Why Use Packages?

wide character routines

Wide Character Routines

wide characters

Unicode characters

Wide Characters

Wildcard Arguments

Win32 Developer's Guide

Win32 Web Applications Overview

windowed controls

Windows Forms

Windows VCL Forms application

Windows XP

wizards

working with files and editors

writing

Working at the Application Level

Working with ADO components

Working with ADO Components

Working with ADT Fields

Working with Array Fields

Working with Associated Datasets

Working with BDE Aliases

Working with BDE Handle Properties

Working with components

Working with Constraints

Working with controls

Working with Data Using a Client Dataset

Working with DataSet Fields

Working with Events and Event Handlers

Working with Field Component Methods at Runtime

Working with field components

Working with Field Components: Overview

Working with Files

Working with Files and Editors

Working with Frames

Working with graphics and multimedia

Working with Graphics and Multimedia: Overview

Working with ini Files and the System Registry

Working with Lists

Working with Multimedia

Working with Oracle Overloaded Stored Procedures

Working with packages and components

Working with Packages and Components: Overview

Working with Password-protected Paradox and dBASE Tables

Working with Pictures

Working with Record Sets

Working with Reference Fields

Working with sockets

Working with Sockets

Working with Stored Procedure Parameters

Working with String Lists

Working with Strings

Working with Text in Controls

Working with type libraries

Working with Type Libraries: Overview

Working with XML Components

Working with XML documents

Working with XML Documents

Working with XML Nodes

write

Writing a finally Block (C++)

Writing a Finally Block (Delphi)

Writing a Wizard Class

Writing Action Components

Writing an Event Handler for the Button

Writing an OnFilterRecord Event Handler

Writing applications using COM

Writing Applications Using COM

Writing Cleanup Code

Writing Clean-up Code

Writing Client Code Based On Type Library Definitions

Writing Clients for Web Services

Writing database applications

Writing Database Applications

Writing Exception Handlers

Writing finally Blocks

Writing Internet Applications

Writing multi-threaded applications

Writing Multi-threaded Applications

Writing Reports

Writing Servers that Support Web Services

Writing the Implementation Method

Writing the Register Procedure

Writing the Thread Function

Writing the Thread Function (Procedure)

Writing the Try Block

Writing Utilities to Work with a Custom Variant Type

Writing Web-based Client Applications

WSDL

generating

importing

WSDLIMP.EXE, the Command Line WSDL Import Tool

XML

Data Binding wizard

using Data Binding wizard

XML brokers

XML Document

XML documents

components

converting to data packets

data packets

XML mapper

defining

XML Nodes

working with

xor

xor, ^

xor_eq