7526351f80
* doc/en/file.txt
! Spelling.
by Alexey Myronenko
! some more
* doc/en/array.txt
* doc/en/binnum.txt
* doc/en/browse.txt
* formatted $EXAMPLES$
* made $EXAMPLES$ unicode-ready
607 lines
18 KiB
Plaintext
607 lines
18 KiB
Plaintext
/*
|
|
* $Id$
|
|
*/
|
|
|
|
/*
|
|
* The following parts are Copyright of the individual authors.
|
|
* www - http://harbour-project.org
|
|
*
|
|
* Copyright 1999 Chen Kedem <niki@actcom.co.il>
|
|
* Documentation for: ASORT()
|
|
*
|
|
* Copyright 1999 Luiz Rafael Culik <culik@sl.conex.net>
|
|
* Documentation for: ARRAY(), AADD(), ACLONE(), ACOPY(), ASIZE(),
|
|
* ATAIL(), AINS(), ADEL(), AFILL(), ASCAN(), AEVAL()
|
|
*
|
|
* See COPYING for licensing terms.
|
|
*
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ARRAY()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Create an uninitialized array of specified length
|
|
* $SYNTAX$
|
|
* ARRAY( <nElements> [, <nElements>...] ) --> aArray
|
|
* $ARGUMENTS$
|
|
* <nElements> is the number of elements in the specified dimension.
|
|
* $RETURNS$
|
|
* <aArray> an array of specified dimensions.
|
|
* $DESCRIPTION$
|
|
* This function returns an uninitialized array with the length of
|
|
* <nElements>.
|
|
*
|
|
* Nested arrays are uninitialized within the same array
|
|
* pointer reference if additional parameters are specified.
|
|
*
|
|
* Establishing a memory variable with the same name as the array may
|
|
* destroy the original array and release the entire contents of the
|
|
* array. This depends, of course, on the data storage type of either
|
|
* the array or the variable with the same name as the array.
|
|
* $EXAMPLES$
|
|
* PROCEDURE Main()
|
|
* LOCAL aArray := Array( 10 )
|
|
* LOCAL x
|
|
* FOR x := 1 TO Len( aArray )
|
|
* aArray[ x ] := Array( x )
|
|
* NEXT
|
|
* // Result is: { { NIL }, { NIL, NIL }, ... }
|
|
* RETURN
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C(array)
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* AADD(),ADEL(),AFILL(),AINS()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* AADD()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Dynamically add an element to an array
|
|
* $SYNTAX$
|
|
* AADD(<aArray>[, <xValue>]) --> Value
|
|
* $ARGUMENTS$
|
|
* <aArray> The name of an array
|
|
*
|
|
* <xValue> Element to add to array <aArray>
|
|
* $RETURNS$
|
|
* <Value> if specified <xValue>, <xValue> will return , otherwise this
|
|
* function returns a NIL value.
|
|
* $DESCRIPTION$
|
|
* This function dynamically increases the length of the array named
|
|
* <aArray> by one element and stores the value of <xValue> to that
|
|
* newly created element.
|
|
*
|
|
* <xValue> may be an array reference pointer, which in turn may be
|
|
* stored to an array's subscript position.
|
|
* $EXAMPLES$
|
|
* LOCAL aArray := {}
|
|
* LOCAL x
|
|
* AAdd( aArray, 10 )
|
|
* FOR x := 1 TO 10
|
|
* AAdd( aArray, x )
|
|
* NEXT
|
|
* // Result is: { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* AINS(),ASIZE()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ASIZE()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Adjust the size of an array
|
|
* $SYNTAX$
|
|
* ASIZE(<aArray>, <nLen>) --> aTarget
|
|
* $ARGUMENTS$
|
|
* <aArray> Name of array to be dynamically altered
|
|
*
|
|
* <nLen> Numeric value representing the new size of <aArray>
|
|
* $RETURNS$
|
|
* <aTarget> an array pointer reference to <aTarget>.
|
|
* $DESCRIPTION$
|
|
* This function will dynamically increase or decrease the size of
|
|
* <aArray> by adjusting the length of the array to <nLen> subscript
|
|
* positions.
|
|
*
|
|
* If the length of the array <aArray> is shortened, those former
|
|
* subscript positions are lost. If the length of the array is
|
|
* lengthened a NIL value is assigned to the new subscript position.
|
|
* $EXAMPLES$
|
|
* LOCAL aArray := { 1 } // Result: aArray is { 1 }
|
|
* ASize( aArray, 3 ) // Result: aArray is { 1, NIL, NIL }
|
|
* ASize( aArray, 1 ) // Result: aArray is { 1 }
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* If HB_COMPAT_C53 is defined, the function generates an Error,
|
|
* else it will return the array itself.
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* AADD(),ADEL(),AFILL(),AINS()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ATAIL()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Returns the rightmost element of an array
|
|
* $SYNTAX$
|
|
* ATAIL( <aArray> ) --> Element
|
|
* $ARGUMENTS$
|
|
* <aArray> is the array.
|
|
* $RETURNS$
|
|
* <Element> the expression of the last element in the array.
|
|
* $DESCRIPTION$
|
|
* This function return the value of the last element in the array
|
|
* named <aArray>. This function does not alter the size of the
|
|
* array or any of the subscript values.
|
|
* $EXAMPLES$
|
|
* LOCAL aArray := { "Harbour", "is", "Supreme", "Power" }
|
|
* ? ATail( aArray ) // Result is "Power"
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* LEN(),ARRAY(),ASIZE(),AADD()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* AINS()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Insert a NIL value at an array subscript position.
|
|
* $SYNTAX$
|
|
* AINS( <aArray>, <nPos> ) --> aTarget
|
|
* $ARGUMENTS$
|
|
* <aArray> Array name.
|
|
*
|
|
* <nPos> Subscript position in <aArray>
|
|
* $RETURNS$
|
|
* <aTarget> an array pointer reference.
|
|
* $DESCRIPTION$
|
|
* This function inserts a NIL value in the array named <aArray>
|
|
* at the <nPos>th position.
|
|
*
|
|
* All array elements starting with the <nPos>th position will be
|
|
* shifted down one subscript position in the array list and the
|
|
* last item in the array will be removed completely. In other words,
|
|
* if an array element were to be inserted at the fifth subscript
|
|
* position, the element previously in the fifth position would now
|
|
* be located at the sixth position. The length of the array <aArray>
|
|
* will remain unchanged.
|
|
* $EXAMPLES$
|
|
* LOCAL aArray := { "Harbour", "is", "Power!", "!!!" }
|
|
* AIns( aArray, 4 )
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* AADD(),ACOPY(),ADEL(),AEVAL(),AFILL(),ASIZE()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ADEL()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Delete an element form an array.
|
|
* $SYNTAX$
|
|
* ADEL(<aArray>, <nPos>) --> aTarget
|
|
* $ARGUMENTS$
|
|
* <aArray> Name of array from which an element is to be removed.
|
|
*
|
|
* <nPos> Subscript of the element to be removed.
|
|
* $RETURNS$
|
|
* <aTarget> an array pointer reference.
|
|
* $DESCRIPTION$
|
|
* This function deletes the element found at <nPos> subscript position
|
|
* in the array <aArray>. All elements in the array <aArray> below the
|
|
* given subscript position <nPos> will move up one position in the
|
|
* array. In other words, what was formerly the sixth subscript position
|
|
* will become the fifth subscript position. The length of the array
|
|
* <aArray> will remain unchanged,as the last element in the array will
|
|
* become a NIL data type.
|
|
* $EXAMPLES$
|
|
* LOCAL aArray := { "Harbour", "is", "Power" }
|
|
* ADel( aArray, 2 ) // Result: aArray is { "Harbour", "Power" }
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* ACOPY(),AINS(),AFILL()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* AFILL()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Fill an array with a specified value
|
|
* $SYNTAX$
|
|
* AFILL( <aArray>, <xValue>, [<nStart>], [<nCount>] ) --> aTarget
|
|
* $ARGUMENTS$
|
|
* <aArray> Name of array to be filled.
|
|
*
|
|
* <xValue> Expression to be globally filled in <aArray>
|
|
*
|
|
* <nStart> Subscript starting position
|
|
*
|
|
* <nCount> Number of subscript to be filled
|
|
* $RETURNS$
|
|
* <aTarget> an array pointer.
|
|
* $DESCRIPTION$
|
|
* This function will fill each element of an array named <aArray> with
|
|
* the value <xValue>. If specified, <nStart> denotes the beginning
|
|
* element to be filled and the array elements will continue to be
|
|
* filled for <nCount> positions. If Not specified, the value of
|
|
* <nStart> will be 1, and the value of <nCount> will be the value
|
|
* of LEN(<aArray>); thus, all subscript positions in the array
|
|
* <aArray> will be filled with the value of <xValue>.
|
|
*
|
|
* This function will work on only a single dimension of <aArray>.
|
|
* If there are array pointer references within a subscript <aArray>,
|
|
* those values will be lost, since this function will overwrite those
|
|
* values with new values.
|
|
* $EXAMPLES$
|
|
* LOCAL aTest := { NIL, 0, 1, 2 }
|
|
* AFill( aTest, 5 )
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* AADD(),AEVAL(),DBSTRUCT(),DIRECTORY()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ASCAN()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Scan array elements for a specified condition
|
|
* $SYNTAX$
|
|
* ASCAN( <aTarget>, <xSearch>, [<nStart>], [<nCount>] ) --> nStoppedAt
|
|
* $ARGUMENTS$
|
|
* <aTarget> Array to be scanned.
|
|
*
|
|
* <xSearch> Expression to search for in <aTarget>
|
|
*
|
|
* <nStart> Beginning subscript position at which to start the search.
|
|
*
|
|
* <nCount> Number of elements to scan with <aTarget>.
|
|
* $RETURNS$
|
|
* <nStoppedAt> A numeric value of subscript position where <xSearch>
|
|
* was found, or 0 if <xSearch> is not found.
|
|
* $DESCRIPTION$
|
|
* This function scan the content of array named <aTarget> for the
|
|
* value of <xSearch>. The return value is the position in the array
|
|
* <aTarget> in which <xSearch> was found. If it was not found, the
|
|
* return value will be 0.
|
|
*
|
|
* If specified, the beginning subscript position at which to start
|
|
* scanning may be set with the value passed as <nStart>. The default
|
|
* is 1.
|
|
*
|
|
* If specified, the number of array elements to scan may be set with
|
|
* the value passed as <nCount>. The default is the number of elements
|
|
* in the array <aTarget>.
|
|
*
|
|
* If <xSearch> is a code block, the operation of the function is
|
|
* slightly different. Each array subscript pointer reference is
|
|
* passed to the code block to be evaluated. The scanning routine
|
|
* will continue until the value obtained from the code block is a
|
|
* logical true (.T.) or until the end of the array has been reached.
|
|
* $EXAMPLES$
|
|
* LOCAL aDir := Directory( "*.prg" )
|
|
* AScan( aDir,,, {| x, y | x[ 1 ] := "test.prg" } )
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* This function is not CA-Cl*pper compatible. CA-Cl*pper ASCAN() is affected by the SET EXACT ON/OFF Condition
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* AEVAL()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* AEVAL()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Evaluates the subscript element of an array
|
|
* $SYNTAX$
|
|
* AEVAL(<aArray>, <bBlock>, [<nStart>], [<nCount>]) --> aArray
|
|
* $ARGUMENTS$
|
|
* <aArray> Is the array to be evaluated.
|
|
*
|
|
* <bBlock> Is a code block to evaluate for each element processed.
|
|
*
|
|
* <nStart> The beginning array element index to evaluate.
|
|
*
|
|
* <nCount> The number of elements to process.
|
|
* $RETURNS$
|
|
* <aArray> an array pointer reference.
|
|
* $DESCRIPTION$
|
|
* This function will evaluate and process the subscript elements
|
|
* in <aArray>. A code block passed as <bBlock> defines the operation
|
|
* to be executed on each element of the array. All elements in <aArray>
|
|
* will be evaluated unless specified by a beginning subscript position
|
|
* in <nStart> for <nCount> elements.
|
|
*
|
|
* Two parameters are passed to the code block <bBlock>. The individual
|
|
* elements in an array are the first parameter and the subscript position
|
|
* is the second.
|
|
*
|
|
* AEVAL() does not replace a FOR...NEXT loop for processing arrays. If
|
|
* an array is an autonomous unit, AEVAL() is appropriate. If the array
|
|
* is to be altered or if elements are to be reevaluated, a FOR...NEXT
|
|
* loop is more appropriate.
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* EVAL(),DBEVAL()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ACOPY()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Copy elements from one array to another
|
|
* $SYNTAX$
|
|
* ACOPY( <aSource>, <aTarget>, [<nStart>], [<nCount>], [<nTargetPos>] ) --> aTarget
|
|
* $ARGUMENTS$
|
|
* <aSource> is the array to copy elements from.
|
|
*
|
|
* <aTarget> is the array to copy elements to.
|
|
*
|
|
* <nStart> is the beginning subscript position to copy from <aSource>
|
|
*
|
|
* <nCount> the number of subscript elements to copy from <aSource>.
|
|
*
|
|
* <nTargetPos> the starting subscript position in <aTarget> to copy
|
|
* elements to.
|
|
* $RETURNS$
|
|
* <aTarget> an array pointer reference
|
|
* $DESCRIPTION$
|
|
* This function copies array elements from <aSource> to <aTarget>.
|
|
*
|
|
* <nStart> is the beginning element to be copied from <aSource>;
|
|
* the default is 1.
|
|
*
|
|
* <nCount> is the number of elements to be copied from <aSource>;
|
|
* the default is the entire array.
|
|
*
|
|
* <nTargetPos> is the subscript number in the target array,<aTarget>,
|
|
* to which array elements are to be copied; the default is 1
|
|
*
|
|
* This function will copy all data types in <aSource> to <aTarget>.
|
|
*
|
|
* If an array element in <aSource> is a pointer reference to another
|
|
* array, that array pointer will be copied to <aTarget>; not all
|
|
* subdimensions will be copied from one array to the next. This must
|
|
* be accomplished via the ACLONE() function.
|
|
*
|
|
* Note:
|
|
* If array <aSource> is larger then <aTarget>, array elements will
|
|
* start copying at <nTargetPos> and continue copying until the end
|
|
* of array <aTarget> is reached. The ACOPY() function doesn't append
|
|
* subscript positions to the target array, the size of the target
|
|
* array <aTarget> remains constant.
|
|
* $EXAMPLES$
|
|
* LOCAL nCount := 2, nStart := 1, aOne, aTwo
|
|
* aOne := { "HARBOUR", " is ", "POWER"}
|
|
* aTwo := { "CLIPPER", " was ", "POWER"}
|
|
* ACopy( aOne, aTwo, nStart, nCount )
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* ACLONE(),ADEL(),AEVAL(),AFILL(),AINS(),ASORT()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ACLONE()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Duplicate a multidimensional array
|
|
* $SYNTAX$
|
|
* ACLONE(<aSource>) --> aDuplicate
|
|
* $ARGUMENTS$
|
|
* <aSource> Name of the array to be cloned.
|
|
* $RETURNS$
|
|
* <aDuplicate> A new array pointer reference complete with nested
|
|
* array values.
|
|
* $DESCRIPTION$
|
|
* This function makes a complete copy of the array expressed as
|
|
* <aSource> and return a cloned set of array values. This provides
|
|
* a complete set of arrays values for all dimensions within the
|
|
* original array <aSource>
|
|
* $EXAMPLES$
|
|
* LOCAL aOne, aTwo
|
|
* aOne := { "Harbour"," is ","POWER" }
|
|
* aTwo := AClone( aOne ) // Result: aTwo is {"Harbour"," is ","POWER"}
|
|
* aOne[ 1 ] := "The Harbour Compiler"
|
|
* // Result:
|
|
* // aOne is { "The Harbour Compiler", " is ", "POWER" }
|
|
* // aTwo is { "Harbour"," is ","POWER" }
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* CA-Cl*pper will return NIL if the parameter is not an array.
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* ACOPY(),ADEL(),AINS(),ASIZE()
|
|
* $END$
|
|
*/
|
|
|
|
/* $DOC$
|
|
* $TEMPLATE$
|
|
* Function
|
|
* $NAME$
|
|
* ASORT()
|
|
* $CATEGORY$
|
|
* API
|
|
* $SUBCATEGORY$
|
|
* Array
|
|
* $ONELINER$
|
|
* Sort an array
|
|
* $SYNTAX$
|
|
* ASORT( <aArray>, [<nStart>], [<nCount>], [<bSort>] ) --> aArray
|
|
* $ARGUMENTS$
|
|
* <aArray> Array to be sorted.
|
|
*
|
|
* <nStart> The first element to start the sort from, default is 1.
|
|
*
|
|
* <nCount> Number of elements starting from <nStart> to sort, default
|
|
* is all elements.
|
|
*
|
|
* <bSort> Code block for sorting order, default is ascending order
|
|
* {| x, y | x < y }. The code block should accept two parameters and
|
|
* must return .T. if the sort is in order, .F. if not.
|
|
* $RETURNS$
|
|
* <aArray> reference to the now sorted <aArray> or NIL if the
|
|
* passed <aArray> is not an array.
|
|
* $DESCRIPTION$
|
|
* ASORT() sort all or part of a given array. If <bSort> is omitted,
|
|
* the function expect <aArray> to be one dimensional array containing
|
|
* single data type (one of: Character, Date, Logical, Numeric) and sort
|
|
* this array in ascending order: Character are sorted by their ASCII
|
|
* value, Dates are sorted chronologically, Logical put .F. values before
|
|
* .T., Numeric are sorted by their value.
|
|
*
|
|
* If <bSort> is specified, it is used to handle the sorting order. With
|
|
* each time the block is evaluate, two array elements are passed to the
|
|
* code block, and <bSort> must return a logical value that state if
|
|
* those elements are in order (.T.) or not (.F.). Using this block you
|
|
* can sort multidimensional array, descending orders or even (but why
|
|
* would you want to do that) sort array that contain different data
|
|
* type.
|
|
* $EXAMPLES$
|
|
* // sort numeric values in ascending order
|
|
* ASort( { 3, 1, 4, 42, 5, 9 } ) // result: { 1, 3, 4, 5, 9, 42 }
|
|
*
|
|
* // sort character strings in descending lexical order
|
|
* aKeys := { "Ctrl", "Alt", "Delete" }
|
|
* bSort := {| x, y | Upper( x ) > Upper( y ) }
|
|
* ASort( aKeys,,, bSort ) // result: { "Delete", "Ctrl", "Alt" }
|
|
*
|
|
* // sort two-dimensional array according to 2nd element of each pair
|
|
* aPair := { { "Sun", 8 }, { "Mon", 1 }, { "Tue", 57 }, { "Wed", -6 } }
|
|
* ASort( aPair,,, {| x, y | x[ 2 ] < y[ 2 ] } )
|
|
* // result: { { "Wed", -6 }, { "Mon", 1 }, { "Sun", 8 }, { "Tue", 57 } }
|
|
* $STATUS$
|
|
* R
|
|
* $COMPLIANCE$
|
|
* C(arrayblock)
|
|
* $FILES$
|
|
* Library is vm
|
|
* $SEEALSO$
|
|
* ASCAN(),EVAL(),SORT
|
|
* $END$
|
|
*/
|