CVI

Converts a floating-point number or string to an integer variable using a 
binary copy

Syntax
   32-bit:
   Declare Function CVI ( ByVal f As Single ) As Integer
   64-bit:
   Declare Function CVI ( ByVal f As Double ) As Integer

   Declare Function CVI ( ByRef str As Const String ) As Integer
   Declare Function CVI<bits> ( expr As DataType ) As Integer<bits>

Usage
   result = CVI( sng )
   result = CVI( str )
   result = CVI<bits>( expr )

Parameters
   f
      A floating-point number with a binary copy of an integer variable 
      stored in it.  Its precision (Single or Double) depends on the size 
      of Integer on the current platform
   str
      A String with a binary copy of an integer variable stored in it.
   bits
      Specifies a size of integer type to return.  The types and sizes of 
      expr accepted will depend on the corresponding function called.
   expr
      An expression that will be copied into an Integer<bits>.

Return Value
   An Integer or Integer<bits> variable containing a binary copy of the 
   input expression.

Description
   Returns an integer value using the binary data contained in a 
   floating-point value, or a String.  A value of zero (0) is returned if 
   the string contains fewer characters than the size of the return type.

   CVI can be used to convert strings created with MKI.

   This function can also be used to convert Integer-sized values from a 
   memory or file buffer without the need for a Type structure.  However, 
   just as with the type structure, special care should be taken when using 
   CVI to convert strings that have been read from a buffer.

   CVI supports an optional <bits> parameter before the argument.  If bits 
   is 16, CVShort will be called instead; if bits is 32, CVL will be 
   called; if bits is 64, CVLongInt will be called.  The return type and 
   accepted argument types will depend on which function is called.  See 
   each function's page for more information.

   CVI's behaviour changes depending on the size of the Integer data type 
   on the current platform.
   * For 16-bit Integer (-lang qb), a 16-bit value is returned, and no 
     floating-point types are accepted.
   * For 32-bit Integer, a 32-bit value is returned, and numeric arguments 
     are interpreted as Single precision values.
   * For 64-bit Integer, a 64-bit value is returned, and numeric arguments 
     are interpreted as Double precision values.

Example
   Dim i As Integer, s As String
   s = "ABCD"
   i = CVI(s)
   Print Using "s = ""&"""; s
   Print Using "i = _&H&"; Hex(i)

Dialect Differences
   * In the -lang qb dialect, CVI expects a 2-byte string, since a QB 
     integer is only 16 bits.  Only the first two bytes of the string are 
     used, even if the string happens to be longer than two bytes.
   * In the -lang qb dialect, CVI will not take a floating-point argument, 
     since a QB integer is only 16 bits and there is no 16-bit 
     floating-point data type.  Instead, CVI<32>/CVI<64> or CVL/CVLongInt 
     may be used.

Differences from QB
   * In QB an error occurs if the string passed is fewer than two bytes in 
     length.
   * QB did not support floating-point arguments.
   * QB did not support a <bits> parameter.

See also
   * MKI
   * CVShort
   * CVL
   * CVLongInt
   * Integer

