FoxRing Functions Reference
A class contains functions similar to FoxPro functions.
FoxRing functions
Function Name |
Description |
|---|---|
frAbs() |
Returns the absolute value of the specified numeric expression. |
frAddBs() |
Adds a backslash (if needed) to a path expression. |
frALines() |
Creates an Array with the content of the specified string. |
frAllTrim() |
Removes all leading and trailing spaces of the specified string. |
frAsc() |
Returns the ANSI value for the leftmost character in a character expression. |
frAt() |
Searches a character expression for the occurrence |
of another character expression. |
|
frAtC() |
Searches a character expression for the occurrence of another character expression without |
regard for the case of these two expressions. |
|
frBetween() |
Determines whether the value of an expression is inclusively between the values of two |
expressions of the same type. |
|
frChr() |
Returns the character associated with the specified numeric ANSI code. |
frEmpty() |
Determines whether an expression evaluates to empty. |
frFile() |
Checks if a file exists on disk. |
frFileToStr() |
Returns the contents of a file as a character string. |
frForceExt() |
Returns a string with the old file name extension replaced by a new extension. |
frForcePath() |
Returns a file name with a new path name substituted for the old one. |
frIif() |
Returns one of two values depending on the value of a logical expression. |
frInList() |
Determines whether an expression matches another expression in a list. |
frInt() |
Evaluates a numeric expression and returns the integer portion of the expression. |
frJustDrive() |
Returns the drive letter from a complete path. |
frJustExt() |
Returns the characters of a file extension from a complete path. |
frJustFName() |
Returns the file name portion of a complete path and file name. |
frJustPath() |
Returns the path portion of a complete path and file name. |
frJustStem() |
Returns the stem name (the file name before the extension) |
from a complete path and file name. |
|
frLen() |
Determines the number of characters in a character expression, |
indicating the length of the expression. |
|
frListToString() |
Creates a string with the string elements of an Array. |
frLTrim() |
Removes all leading spaces or parsing characters from the |
specified character expression. |
|
frPadL() |
Returns a string from an expression, padded with spaces or characters to a |
specified length on the left side. |
|
frPadR() |
Returns a string from an expression, padded with spaces or characters to a |
specified length on the right side. |
|
frProper() |
Returns from a character expression a string capitalized as |
appropriate for proper names. |
|
frReplicate() |
Returns a character string that contains a specified character |
expression repeated a specified number of times. |
|
frRTrim() |
Removes all trailing spaces or parsing characters from |
the specified character expression. |
|
frSetIfEmpty() |
Set a Value into a variable if the variable value is empty, null or zero. |
frSetSeparatorTo() |
Specifies the character for the numeric place separator. |
frSpace() |
Returns a character string composed of a specified number of spaces. |
frStr() |
Returns the character equivalent of a numeric expression. |
frStringToList() |
Creates a List with the content of the specified string. |
frStrTran() |
Searches a character expression for a second character expression and |
replaces each occurrence with a third character expression. |
|
frStuff() |
Returns a new character string replaced by a specified number of |
characters in a character expression with another character expression. |
|
frSubStr() |
Returns a character string from the given character expression, |
starting at a specified position in the character |
|
expression and continuing for a specified number of characters. |
|
frTransform() |
Returns a character string from an expression in a |
format determined by a format code. |
|
frVal() |
Returns a numeric value from a character expression composed of numbers. |
frVarType() |
Returns the data type of an expression. |
frAbs() function
* Syntax : lnReturnValue = frAbs(tnExpression)
* Description : Returns the absolute value of the specified numeric expression.
* :
* Arguments : <tnExpression>
* : Specifies the numeric expression whose absolute value frAbs()
* : returns.
* Returns : <lnReturnValue>
* : Returns the absolute value of the specified numeric expression.
frAsc() function
* Syntax : lnReturnValue = frAsc(tcExpression)
* Description : Returns the ANSI value for the leftmost character in
* : a character expression.
* Arguments : <tcExpression>
* : Specifies the character expression containing the character
* : whose ANSI value frAsc()
* : returns. Any characters after the first character in
* : tcExpression are ignored by frAsc().
* Returns : <lnReturnValue>
* : returns the position of the character in the character
* : table of the current code page.
* : Every character has a unique ANSI value in the
* : range from 0 to 255.
frAddBs() function
* Syntax : lcReturnValue = frAddBs(tcPath)
* Description : Adds a backslash (if needed) to a path expression.
* :
* Arguments : <tcPath>
* : Specifies the path name to which to add the backslash.
* :
* Returns : <lcReturnValue> The path with the backslash.
frAt() function
* Syntax : lnPos = frAt(tcToSearch, tcString, tnOccurrence)
* Description : Searches a character expression for the occurrence of
* : another character expression.
* : The search performed by frAt() is case-sensitive.
* :
* Arguments : <tcToSearch>
* : Specifies the character expression to search
* : for in <tcString>.
* : <tcString>
* : Specifies the character expression to search
* : for <tcToSearch>.
* : <tnOccurrence>
* : Specifies which occurrence, first, second, third,
* : and so on, of <tcToSearch> to search for
* : in <tcString>.
* : By default, frAt() searches for the first occurrence
* : of <tcToSearch> (tnOccurrence = 1).
* Returns : Numeric. frAt() returns an integer indicating the
* : position of the first character for a
* : character expression or memo field within another
* : character expression or memo field,
* : beginning from the leftmost character. If the
* : expression or field is not found, or if
* : <tnOccurrence> is greater than the number of
* : times <tcToSearch> occurs in <tcString>, frAt()
* : returns 0.
frAtC() function
* Syntax : lnPos = frAtC(tcToSearch, tcString, tnOccurrence)
* Description : Searches a character expression for the occurrence
* : of another character expression
* : without regard for the case of these two expressions.
* :
* Arguments : <tcToSearch>
* : Specifies the character expression to search
* : for in <tcString>.
* : <tcString>
* : Specifies the character expression to search
* : for <tcToSearch>.
* : <tnOccurrence>
* : Specifies which occurrence, first, second, third,
* : and so on, of <tcToSearch> to search for
* : in tcString.
* : By default, frAtC() searches for the first occurrence
* : of <tcToSearch> (tnOccurrence = 1).
* Returns : Numeric. frAtC() returns an integer indicating the
* : position of the first character for a
* : character expression or memo field within
* : another character expression or memo field,
* : beginning from the leftmost character. If the
* : expression or field is not found, or if
* : <tnOccurrence> is greater than the number of
* : times <tcToSearch> occurs in <tcString>, frAtC()
* : returns 0.
frChr() function
* Syntax : lcReturnValue = frChr(tnExpression)
* Description : Returns the character associated with the specified numeric
* : ANSI code.
* Arguments : <tnExpression>
* : Specifies a number between 0 and 255 whose equivalent ANSI
* : character frChr() returns.
* Returns : <lcReturnValue>
* : Returns a single character corresponding to the numeric
* : position of the character in the
* : character table of the current code page.
* :
* Remarks : tnExpression must be between 0 and 255
frEmpty() function
* Syntax : llReturnValue = frEmpty(tuExpression)
* Description : Determines whether an expression evaluates to empty.
* :
* Arguments : <tuExpression>
* : Specifies the expression that EMPTY() evaluates.
* : You can specify an expression with Character,
* : Numeric, or logical type.
* :
* Returns : <llReturnValue> Logical
frFile() function
* Syntax : llReturnValue = frFile(tcFileName, tnFlag)
* Description : Checks if the specified file exists on disk.
* :
* Arguments : <tcFileName>
* : Specifies the name of the file to check.
* : tcFileName must include
* : the file extension. You can include a path with
* : the file name to
* : search for a file in a directory or on a drive
* : other than the current directory or drive.
* :
* : <tnFlag>
* : tnFlag was included for future compatibility.
* : In this version, It always returns true whenever
* : the file exists on disk.
* Returns : <llReturnValue> Logical
* : True if file exists on disk.
* : False if file doesn't exist on disk.
frFileToStr() function
* Syntax : lcReturnValue = frFileToStr(tcFileName)
* Description : Returns the contents of a file as a character string.
* :
* Arguments : <tcFileName>
* : Specifies the name of the file whose contents are
* : returned as a character
* : string. If the file is in a directory other than
* : the current default directory,
* : include a path with the file name.
* :
* Returns : <lcReturnValue>
* : A character string with the content of the specified file.
* :
frStr() function
* Syntax : lcReturnValue = frStr(tnValue, tnLen, tnDec)
* Description : Returns the character equivalent of a numeric expression.
* :
* Arguments : <tnValue>
* : Specifies the numeric expression to evaluate.
* :
* : <tnLen>
* : Specifies the length of the character string returned.
* : If tnLen is 0, tnLen defaults to 10 characters.
* : If tnLen < 0 returns one string with same length as the number.
* : Note
* : If the expression contains a decimal point,
* : the length includes one character for
* : the decimal point and one character
* : for each digit in the character string.
* :
* : <tnDec>
* : Specifies the number of decimal places in the
* : character string returned.
* : To specify the number of decimal places using
* : tnDec, you must include nLength. If nDecimalPlaces is omitted,
* : the number of decimal places defaults to zero (0).
* :
* Returns : Character data type. frStr() returns a character string
* : equivalent to the specified numeric expression.
* : Depending on certain conditions, frStr() can return the following:
* : If you specify fewer decimal places than exist in tnValue,
* : the return value is rounded up. To round results to the nearest
* : decimal place instead of upward, include the ROUND( ) function.
* : For more information, see ROUND( ) Function.
* : If nExpression is an integer, and nLength is less than
* : the number of digits in nExpression, frStr( ) returns a string of
* : asterisks, indicating numeric overflow.
* : If nExpression contains a decimal point, and nLength is equal
* : to or less than the number of digits to the left of the decimal
* : point, frStr( ) returns a string of asterisks,
* : indicating numeric overflow.
* : If nLength is greater than the length of the value evaluated
* : by nExpression, frStr( ) returns a character string padded with
* : leading spaces.
* : If nExpression has Numeric or Float type, and nLength
* : is less than the number of digits in nExpression, and , frStr( )
* : returns a value using scientific notation.
frSetIfEmpty() function
* Syntax : tuReturnValue = frSetIfEmpty(tuValue, tuNewValue)
* Description : Set a Value into a variable if the variable
* : value is empty, null or zero.
* Arguments : <tuValue>
* : The value to evaluate.
* :
* : <tuNewValue>
* : The value to set if tuValue is empty.
* :
* Returns : tuNewValue if tuValue is empty, otherwise
* : returns the original value.
* Remarks : This function doesn't exist in VFP.
frSpace() function
* Syntax : lcReturnValue = frSpace(tnSpaces)
* Description : Returns a character string composed of a
* : specified number of spaces.
* Arguments : <tnSpaces>
* : Specifies the number of spaces that frSpace() returns.
* :
* Returns : <lcReturnValue>
* : Character
frInList() function
* Syntax : llReturnValue = frInList(tuExpression, taList)
* Description : Determines whether an expression matches another
* : expression in a set of expressions.
* Arguments : <tuExpression>
* : Specifies the expression frInList() searches for in the List.
* :
* : <taList>
* : Specifies the List of expressions to search.
* : You must include at least one element in the list.
* : The expressions in the list of expressions needn't to be
* : of the same data type.
* :
* Returns : <luReturnValue> Null or logical value.
frForcePath() function
* Syntax : lcReturnValue = frForcePath(tcFileName, tcPath)
* Description : Returns a file name with a new path name
* : substituted for the old one.
* Arguments : <tcFileName>
* : Specifies the file name (with or without a path or extension),
* : which will get a new path.
* : <tcPath>
* : Specifies the new path for tcFileName.
* :
* Returns : <lcReturnValue>
* : Returns a file name with a new path name
* : substituted for the old one.
frAllTrim() function
Syntax : lcReturnValue = frAllTrim(tcExpression, tcCharacter)
frLTrim() function
Syntax : lcRet = frLTrim(tcExpression, tcCharacter)
frJustDrive() function
* Syntax : lcReturnValue = frJustDrive(tcPath)
* Description : Returns the drive letter from a complete path.
* :
* Arguments : <tcPath>
* : Specifies the complete path name for
* : which you want only the drive.
* Returns : <lcReturnValue>
* : Returns the drive letter from a complete path.
frJustExt() function
* Syntax : lcReturnValue = frJustExt(tcPath)
* Description : Returns the characters of a file extension
* : from a complete path.
* Arguments : <tcPath>
* : Specifies the name, which may include the full path,
* : of the file for which you want only the extension.
* Returns : <lcReturnValue>
* : Returns the drive characters of a file extension
* : from a complete path.
frJustStem() function
* Syntax : lcReturnValue = frJustStem(tcPath)
* Description : Returns the stem name (the file name before the extension)
* : from a complete path and file name.
* Arguments : <tcPath>
* : Specifies the name (including path) of the file
* : for which you want only the stem.
* Returns : <lcReturnValue>
* : Returns the stem name of a file from a complete path.
frRTrim() function
Syntax : lcRet = frRTrim(tcExpression, tcCharacter)
frJustPath() function
Syntax : tcReturnValue = frJustPath(tcExpression)
frForceExt() function
Syntax : tcReturnValue = frForceExt(tcFileName, tcNewExtension)
frALines() function
Syntax : tnReturnValue = frALines(taList, tcExpression, tcSeparator)
frJustFName() function
Syntax : tcReturnValue = frJustFName(tcExpression)
frPadL() function
Syntax : tcReturnValue = frPadL(tcString, tnLen, tcChar)
frPadR() function
Syntax : tcReturnValue = frPadR(tcString, tnLen, tcChar)
frProper() function
* Syntax : tcReturnValue = frProper(tcExpression)
* Description : Returns from a character expression a string
* : capitalized as appropriate for proper names.
* Arguments : <tcExpression>
* : Specifies the character expression from which
* : frProper() returns a capitalized character string.
* Returns : <tcReturnValue>
frReplicate() function
Syntax : tcReturnValue = frReplicate(tcString, tnTimes)
frLen() function
Syntax : tnReturnValue = frLen(tcString)
frStuff() function
* Syntax : tcReturnValue = frStuff(tcExpression, tnStartRep,
tnCharRep, tcToReplace)
* Description : Returns a new character string replaced by a
* : specified number of characters in a character
* : expression with another character expression.
* :
* Arguments : <tcExpression>
* : Specify the character expression in which the replacement occurs.
* :
* : <tnStartRep>
* : Specify the position in <tcExpression> where the replacement begins.
* :
* : <tnCharRep>
* : Specifies the number of characters to be replaced.
* : If <tnCharRep> is 0, the replacement string
* : <tcToReplace> is inserted into <tcExpression>.
* :
* : <tcToReplace>
* : Specifies the replacement character expression.
* : If <tcToReplace> is an empty string, the number of
* : characters specified by <tnCharRep> are removed from <tcExpression>.
* :
* Returns : Character
frSubStr() function
Syntax : tcReturnValue = frSubStr(tcString, tnInitialPosition, tnNumberBytes)
frStrTran() function
Syntax : tcReturnValue = frStrTran(tcString, tcOldString, tcNewString)
frListToString() function
* Syntax : lcRet = frListToString(taList)
* Remarks : This function doesn't exist in VFP.
frInt() function
Syntax : lnInt = frInt(tnExpression)
frStringToList() function
* Syntax : laList = frStringToList(tcExpression)
* Remarks : This function doesn't exist in VFP.
frIIf() function
* Syntax : luReturnValue = frIIf(tlExpression, tuReturnIfTrue, tuReturnIfFalse)
* Description : Returns one of two values depending on the
* : value of a logical expression.
* Arguments : <tlExpression>
* : Specifies the logical expression that frIIf() evaluates.
* :
* : <tuReturnTrue>, <tuReturnFalse>
* : If tlExpression evaluates to True, tuReturnIfTrue is
* : returned and tuReturnIfFalse is not evaluated.
* : If tlExpression evaluates to False or Null, tuReturnIfFalse is
* : returned and tuReturnIfTrue is not evaluated.
* :
* Returns : <luReturnValue> Defined by <tuReturnIfTrue> or <tuReturnIfFalse>
frVal() function
* Syntax : luReturnValue = frVal(tcExpression)
* Description : Returns a numeric value from a character expression
* : composed of numbers
* Arguments : <tcExpression>
* : Specifies a character expression composed of up to 16 numbers.
* :
* Returns : <tnValue>
* : Return a numeric value.
frBetween() function
* Syntax : luReturnValue = frBetween(tuTestValue, tuLowValue, tuHighValue)
* Description : Determines whether the value of an expression
* : is inclusively between the
* : values of two expressions of the same type.
* :
* Arguments : <tuTestValue>
* : Specifies an expression to evaluate.
* :
* : <tuLowValue>
* : Specifies the lower value in the range.
* :
* : <tuHighValue>
* : Specifies the higher value in the range.
* :
* Returns : <luReturnValue>
* : Returns a logical order null value.
frSetSeparatorTo() function
* Syntax : frSetSeparatorTo(tuExpression)
* Description : Specifies the character for the numeric place separator.
* :
* Arguments : <tuExpression>
* : Specifies the character for the numeric place separator.
* :
* : Use frSetSeparatorTo() to change the numeric place
* : separator from default, for example space " " or a comma ",".
* : Issue frSetSeparatorTo(Null) to reset the value to its default.
* :
* Returns : None
frTransform() function
* Syntax : tcReturnValue = frTransform(tuExpression, tcFormatCodes)
* Description : Returns a character string from an expression in a
* : format determined by a format code.
* Arguments : <tuExpression>
* : Specifies the expression to format.
* :
* : <tcFormatCodes>
* : Specifies one or more format codes that determine how to
* : format the expression.
* :
* Returns : <tcReturnValue>
The following table lists the available format codes for tcFormatCodes.
--------------------------------------------------------------------------
Format Code Description
--------------------------------------------------------------------------
@! Converts an entire character string to uppercase.
@T Trims leading and trailing spaces from character values.
@B Left-justifies Numeric data within the display region.
@L Pads numeric and string data with leading zeros.
@C Appends CR to positive numeric values to indicate a credit.
@X Appends DB to negative numeric values to indicate a debit.
--------------------------------------------------------------------------
frVarType() function
* Syntax : lcRet = frVarType(tuExpression)
* Description : Returns the data type of an expression.
* :
* Arguments : <tuExpression>
* : Specifies the expression for which the data type is returned.
* : frVartype() returns a
* : single character indicating the data type of the expression.
* : The following table lists the characters that frVarType()
* : returns for each data type.
* :
* : ------------------- -------------------------------------
* : Return Value Data Type
* : ------------------- -------------------------------------
* : C Character
* : N Numeric
* : A List
* : O Object
* : U Undefined type
* : ------------------- -------------------------------------
* :
* Returns : Character
Example
Load "foxring.ring"
mf = new frFunctions
/*----------------------------------------------------------*/
* frProper() samples
/*----------------------------------------------------------*/
lcStr1 = "ring is a good language"
?mf.frProper(lcStr1)
?mf.frProper(Upper(lcStr1))
/*----------------------------------------------------------*/
* frStuff() samples
/*----------------------------------------------------------*/
lcStr1 = "abcdefghijklm"
lcStr2 = "12345"
// insert
?mf.frStuff(lcStr1, 4, 0, lcStr2)
// replace
?mf.frStuff(lcStr1, 4, 3, lcStr2)
// delete
?mf.frStuff(lcStr1, 4, 6, "")
// replace and insert
?mf.frStuff(lcStr1, 4, 1, lcStr2)
// replace and delete
?mf.frStuff(lcStr1, 4, 4, lcStr2)
// replace, delete rest
?mf.frStuff(lcStr1, 4, Len(lcStr1), lcStr2)
/*----------------------------------------------------------*/
?mf.frAbs(-45)
?mf.frAbs(10-30)
?mf.frAbs(30-10)
lcNumber1 = 40
lcNumber2 = 2
?mf.frAbs(lcNumber2-lcNumber1)
lcCompletFileName = "C:\ring\docs\source\contribute.txt"
?mf.frFile(lcCompletFileName, Null)
if mf.frFile(lcCompletFileName, Null) {
?mf.frFileToStr(lcCompletFileName)
else
?"File does not exist"
}
lcNewPath = "C:\ring_2\docs\source\"
?mf.frJustExt(lcCompletFileName)
?mf.frJustDrive(lcCompletFileName)
?mf.frJustStem(lcCompletFileName)
?mf.frForcePath(lcCompletFileName, lcNewPath)
?mf.frTransform(" Ring is a good language ",
"@! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
?mf.frAllTrim(" Ring is a good language ", Null)
?mf._version
lnValue = 3125.54
?mf.frTransform(lnValue, "@B")+ "Euros"
?mf.frTransform(lnValue, "@C 9999,999,999,999.999")
mf.frSetSeparatorTo(" ")
?mf.frTransform(lnValue, "9999,999,999,999.999")
?mf.frInt(lnValue)
?mf.frForceExt("teste", "dbf")
// Format "@L" Added into frTransform() function
?mf.frTransform("123", "@L 999999")
?mf.frTransform(123, "@L 999999")