ValType()

Retrieves the data type of an expression

Syntax

      ValType( <xExp> ) --> <cRetType>

Arguments

<xExp> is any valid expression.

Returns

<cRetType> a character indicating the type of the passed expression.

        <cRetType>   Meaning
        ------------ ----------------------- 
        "A"          Array
        "B"          Block
        "C"          Character (string)
        "D"          Date
        "H"          Hash
        "L"          Logical
        "M"          Memo
        "N"          Numeric
        "O"          Object
        "P"          Pointer
        "S"          Symbol
        "T"          Date & Time Stamp 
        "U"          NIL

Description

This function returns one character which represents the data type of the argument.

Examples

PROCEDURE Main()
LOCAL aStru := { { 'AINCR', '+', 4, 0 },; // Auto increment
 { 'LMODT', '=', 8, 0 },; // Last modified date & time of this record
 { 'RVERS', '^', 8, 0 },; // Row version number; modification count of this record
 { 'DT_TM', '@', 8, 0 },; // Date & Time
 { 'DOUBL', 'B', 8, 0 },; // Double Floating point / 64 bit binary
 { 'CHARA', 'C', 6, 0 },; // Character
 { 'ODATE', 'D', 8, 0 },; // Only Date 
 { 'LOGIC', 'L', 1, 0 },; // Logical
 { 'MEMOR', 'M', 8, 0 },; // Memo 
 { 'NUMER', 'N', 5, 0 },; // Numeric 
 { 'INTEG', 'I', 2, 0 },; // Integer 
 { 'OTIME', 'T', 8, 0 },; // Only Time
 { 'VARIA', 'V', 8, 0 },; // Variant 
 { 'CURRE', 'Y', 8, 0 } } // Currency 64 bit integer with implied 4 decimal

 LOCAL aArray := {},; 
 bBlock := { || .T. },; 
 cString := 'This is a string',;
 cDate := DATE(),; 
 hHash := { => },;
 lLogic := ( 1 = 1 ),;
 nNumber := 1,;
 oObject := TBrowse(),;
 pPointer := hb_idleAdd( {|| 1 + 1 } ),;
 sSymbol := ( @STR() ),; 
 uUndef := NIL,;
 xTest

 DBCREATE( 'VT_Test', aStru, , .T., 'TEST' )
 DBAPPEND()

 * Types of FIELDS:
 ? ValType( TEST->AINCR ) // N 
 ? ValType( TEST->LMODT ) // T 
 ? ValType( TEST->RVERS ) // N 
 ? ValType( TEST->DT_TM ) // T 
 ? ValType( TEST->DOUBL ) // N 
 ? ValType( TEST->CHARA ) // C 
 ? ValType( TEST->ODATE ) // D 
 ? ValType( TEST->LOGIC ) // L 
 ? ValType( TEST->MEMOR ) // M 
 ? ValType( TEST->NUMER ) // N 
 ? ValType( TEST->INTEG ) // N 
 ? ValType( TEST->OTIME ) // T 
 ? ValType( TEST->VARIA ) // C 
 ? ValType( TEST->CURRE ) // N 
 ? 
 * Types of variables assigned value from FIELDS:
 ? ValType( xTest := TEST->AINCR ) // N 
 ? ValType( xTest := TEST->LMODT ) // T 
 ? ValType( xTest := TEST->RVERS ) // N 
 ? ValType( xTest := TEST->DT_TM ) // T 
 ? ValType( xTest := TEST->DOUBL ) // N 
 ? ValType( xTest := TEST->CHARA ) // C 
 ? ValType( xTest := TEST->ODATE ) // D 
 ? ValType( xTest := TEST->LOGIC ) // L 
 ? ValType( xTest := TEST->MEMOR ) // M 
 ? ValType( xTest := TEST->NUMER ) // N 
 ? ValType( xTest := TEST->INTEG ) // N 
 ? ValType( xTest := TEST->OTIME ) // T 
 ? ValType( xTest := TEST->VARIA ) // C 
 ? ValType( xTest := TEST->CURRE ) // N 
 ? 
 * Types of Variables 
 ? ValType( aArray ) // A
 ? ValType( bBlock ) // B
 ? ValType( cString ) // C
 ? ValType( cDate ) // D
 ? ValType( hHash ) // H
 ? ValType( lLogic ) // L
 ? ValType( nNumber ) // N
 ? ValType( oObject ) // O
 ? ValType( pPointer ) // P
 ? ValType( sSymbol ) // S
 ? ValType( uUndef ) // U 

RETURN


Compliance

ValType() is CA-Cl*pper compliant, with the addition of the new Harbour types: Hash, Date & Time Stamp, Pointer and Symbol.

Files

Library is core

Seealso

Type()

Type()

Retrieves the type of an expression

Syntax

      Type( <cExp> ) --> <cRetType>

Arguments

<cExp> must be a character expression.

Returns

<cRetType> a string indicating the type of the passed expression.

        <cRetType>   Meaning

        "A"          Array
        "B"          Block
        "C"          Character (string)
        "D"          Date
        "L"          Logical
        "M"          Memo
        "N"          Numeric
        "O"          Object
        "P"          Pointer
        "S"          Symbol
        "U"          NIL, local or static variable, or not linked-in function
        "UE"         syntax error in the expression or invalid arguments
        "UI"         function with non-reserved name was requested

Description

This function returns a string which represents the data type of the argument. The argument can be any valid Harbour expression. If there is a syntax error in passed expression then “UE” is returned. If there is a call for any non-reserved Harbour function then “UI” is returned (in other words there is no call for passed UDF function during a data type determination – this is CA-Cl*pper compatible behavior). Additionally if requested user defined function is not linked into executable then “U” is returned.

The data type of expression is checked by invoking a macro compiler and by evaluation of generated code (if there is no syntax errors). This causes that Type() cannot determine a type of local or static variables – only symbols visible at runtime can be checked.

Notice the subtle difference between TYPE and VALTYPE functions. ValType() function doesn’t call a macro compiler – it simply checks the type of passed argument of any type. Type() requires a string argument with a valid Harbour expression – the data type of this expression is returned.

Examples

      ? Type( "{ 1, 2 }" )                                // prints "A"
      ? Type( "iif( .T., SubStr( "TYPE", 2, 1 ), .F. )" ) // prints "C"
      ? Type( "At( "OK", MyUDF() ) > 0" )                 // prints "UI"
      ? Type( "{ 1, 2 }[ 5 ]" )                           // prints "UE"

      //--------------------------------------------------------

      LOCAL c
      PRIVATE a := "A", b := "B"
      ? Type( "a + b + c" )     // prints: "U" ('C' variable is a local one)

      //--------------------------------------------------------

      LOCAL cFilter := Space( 60 )
      ACCEPT "Enter filter expression:" TO cFilter
      IF Type( cFilter ) $ "CDLMN"
         // this is a valid expression
         SET FILTER TO &cFilter
      ENDIF

Compliance

– Incompatibility with CA-Cl*pper: In the following code:

PRIVATE lCond := 0 ? Type( "iof( lCond, 'true', MyUDF() )" )

CA-Cl*pper will print “UE” – in Harbour the output will be “UI”

– If “UI” is returned then the syntax of the expression is correct. However invalid arguments can be passed to function/procedure that will cause runtime errors during evaluation of expression.

– Harbour supports two new types (Pointer and Symbol) which does not exists in CA-Cl*pper.

Files

Library is core

Seealso

ValType()