Function Set() Foundation

SET ALTERNATE TO <file> => _SET_ALTFILE    => _SET_EXTRAFILE 
SET ALTERNATE ON|OFF    => _SET_ALTERNATE  => _SET_EXTRA 

Set( _SET_HASH, 160 ) // Select the SHA1 algorithm 
Set( _SET_HASH, 256 ) // Select the SHA2-256 algorithm 
Set( _SET_HASH, 512 ) // Select the SHA3-512 algorithm 

// The example sends data from a customer file to the 
// printer, and the output is diverted to a file. The output 
// channel (printer) as well as the output file are set by 
// Set(). The example further shows that Set() settings should 
// be saved when they are redefined and reset to the old 
// value before terminating a function/procedure. 

#include "Set.ch" 

PROCEDURE Main 
   LOCAL cPrintFile, lPrinterOn 

   cPrintFile := Set(_SET_PRINTFILE,"OUTPUT.TXT") 
   lPrinterOn := Set(_SET_PRINTER  , .T. ) 

   USE Customer NEW 
   DO WHILE ! Eof() 
      ? Lastname, Firstname 
      DbSkip() 
   ENDDO 

   Set(_SET_PRINTFILE, cPrintFile ) 
   Set(_SET_PRINTER  , lPrinterOn ) 

   USE 

RETURN 

// This example does the same as the previous example 
/ "Saves and sets Set() settings", except that the values for 
// the Set() settings are programmed at the beginning in a 
// two-dimensional array. This array is passed to the function 
// ASet() where the new settings are set and the old are 
// saved in the array. Before termination of the procedure 
// Main, the old settings are reset when the array is 
// repassed to the function ASet(). 

#include "Set.ch" 

PROCEDURE Main 
   LOCAL aSets := { ; 
                    { _SET_PRINTFILE,"OUTPUT.TXT"}, ; 
                    { _SET_PRINTER  , .T.        }  ; 
                  } 

   ASet( aSets )          // Set/save Set() settings 

   USE Customer NEW 
   DO WHILE ! Eof() 
      ? Lastname, Firstname 
      DbSkip() 
   ENDDO 

   ASet( aSets )          // restore Set() settings 

   USE 
RETURN 

FUNCTION ASet( aSets ) 
RETURN AEval( aSets, {|a| a[2] := Set(a[1], a[2]) } ) 

// In the example, a case-insensitive collation table is activated 
// where umlauts are sorted in correct lexical order. 
// Strings can then be compared without using Upper() or Lower(). 

PROCEDURE Main 
   LOCAL aCollation[256] 
   LOCAL cUpperCase := "A BCDEFGHIJKLMNO PQRS TU VWXYZ" 
   LOCAL cLowerCase := "a bcdefghijklmno pqrs tu vwxyz" 
   LOCAL nAscii, i, imax := Len( cLowerCase ), nSortOrder := 0 
   LOCAL aOldCollation 

   AFill( aCollation, 256 ) 

   // Upper and lower case letters receive identical weighing 
   // factors. The factors must be assigned to the array 
   // element nAscii+1 because ASCII codes start at 0 
   // and the array index starts with 1 
   FOR i:=1 TO imax 
      nAscii := Asc( SubStr( cUpperCase, i, 1 ) ) 
      IF nAscii <> 32 
         aCollation[ nAscii+1 ] := nSortOrder 
      ENDIF 
      nAscii := Asc( SubStr( cLowerCase, i, 1 ) ) 
      aCollation[ nAscii+1 ] := nSortOrder ++ 
   NEXT 

   // Sort all other characters after letters 
   i := 0 
   DO WHILE i < 256 .AND. ; 
          ( i := AScan( aCollation, 256, i+1 ) ) > 0 
      aCollation[ i ] := nSortOrder ++ 
   ENDDO 

   ? "lower" = "LOWER"              // Result: .F. 
   ? "UppER" = "uPPer"              // Result: .F. 
   ? "B"     < " "                  // Result: .T. 

   aOldCollation := Set( _SET_COLLATION, aCollation ) 

   ? "lower" = "LOWER"              // Result: .T. 
   ? "UppER" = "uPPer"              // Result: .T. 
   ? "B"     < " "                  // Result: .F. 

   Set( _SET_COLLATION, aOldCollation ) 
RETURN