X2c provides a complex data object that operates according to Xbase variable rules. Specifics of these characteristics is enumerated in subsequent sections.

In Xbase: variables are created 'on the fly' and they exist for a period of time during program execution. PUBLIC and PRIVATE declarations only effect when the variables are removed.

In C: variables are declared in the compiled code and exist for all functions for all time (global), or only within a single function (local).

In X2c: Global variable 'hooks' contain references to the current instance of the Xbase variable. C 'access' functions are used to access all variables so Xbase field, PUBLIC, PRIVATE and PARAMETERS characteristics perform as expected.

Xbase keeps the names of variables at run-time, C does not. In C, once the compiler is done, all variables are referenced only by numeric address. In Xbase, a macro reference to a variable (&X=1) works because of the run-time names.

In X2c: names can be kept for all variables and functions and so full Xbase macros can be executed. Functions are called using a standard calling convention so the expression evaluator can call any user functions.

All variables in Xbase change to the data type of the value they are assigned.

In C, the type of a variable can not change. The only way for the same variable name to have different types is to be in different name scopes of a program, ie, PUBLIC and PRIVATE. Simple arrays can only be of one type. Expressions must be of explicit types.

In X2c: the type of a variable or array element is set when the variable occurs on the left hand side of an assignment. This follows full Xbase rules. Expressions of known type are compiled to that type. Expressions of unknown type are compiled using special function calls operating on ANY-type variable objects.

X2c optimizes numeric expressions in a way that causes the following to require recoding: (date_variable)+/-(numeric_constant). The function DAYADJ(date_variable, [-]numeric_constant) needs to be used.

Xbase passes a parameter to a PROCEDURE, (DO..WITH...) by name. If the parameter is changed in the procedure, the new value gets passed back. Scalar parameters to FUNCTIONs are passed by values, arrays are passed by reference and the Clipper '@' operator allows passing scalar parameters by reference.

In C, numeric and logical parameters are passed by value and character, date and array parameters by address. This means only character and array parameters have changes returned to the upper level. Character constants can be changed by lower level operations.

X2c follows Xbase, in all aspects, including the Clipper '@' operator.

C globals names include function names, global database structures, and PUBLIC variable names. No two can have the same name, (case sensitivitity depending on the linker). Global database structures often are named by the database root name. The database root name is the center part of the filename: in file C:\DATA\BASEPART.DBF the root name is BASEPART.

X2c uses C names that are the same as the corresponding Xbase name, forced to lower case, for all functions and procedures. PUBLIC variables are uniquely named with a preceding 'V'.

The standard X2c file manager does not use database structures and so produces no conflicts on database root names.

All C functions and libraries share the same 'name space', so no two can have the same name. This includes all user global names, X2c library names and C system library names.

C does not allow use of keywords as variable names. Examples are 'double' and 'sizeof'.

X2c limits use of variables whose names match Xbase type names, including the 4 character abbreviation rules. This specifically applies to declaration statements: DECLARE, DIMENSION, PUBLIC, PRIVATE and VAR. For example, CHAR, CHARA, and CHARAC all conflict with CHARACTER. The keywords are: ANY, CHARACTER, DATE, LOGICAL, MEMO, NUMERIC.

In X2c macros in strings and for string or filename replacement are handled automatically.

X2c supports variable name references fully, for all variables so enabled. The default is 'all variables enabled'.

X2c automatically calls the expression evaluator when macros are used.

For X2c macros are not allowed in keywords, except for SET statements where ON/OFF and color settings are handled automatically. The limits approximate Clipper's handling of these statements.

Some SYS() functions as listed below.

FOR clause of INDEX ON statement

All functions are supported, including user functions for DBEDIT(), MEMOEDIT() and ACHOICE(). dBx has differences or limits in usage, eg. PCOUNT() can only be used in functions or procedures with VAR FUNCTION statements declaring PCOUNT() enabled and called using name() format. X2c enables PCOUNT() for all user functions.

The F1 help function (from SET key 28 TO ) calls a function help() with no parameters. Resetting SET KEY redefines this.

C does not support a standard method of passing a variable number of parameters. In X2c, PCOUNT() is supported the same as optional parameters are: by filling all missing parameters with a dummy value. This is transparent to the X2c user.

X2c requires the kernals of all libraries (these four and any logic) to be always loaded. Specific functions are loaded as needed.

X2c does not preserve any pre-sort condition. INDEX ON places all records with the same key in the index in record number order.

Regardless that they are created using the MicroSoft C compiler, the Clipper libraries or other addon libraries are NOT standard C functions. They can not be linked directly into a C program. It is necessary to change their calling sequencing to remove references to the Clipper extend system.

This is supported by both X2c and dBx.

Allows RESULT = &xEXPR

where xEXPR is a string containing an expression of type 'x'

For expressions Logical, Char, Date, and Numeric

levexpr, cevexpr, devexpr, nevexpr

Function are included for handling functions of unknown type.

X2c does not support these, unless noted,