/* * $Id$ */ /* * Harbour Project source code: * CT3 string functions * - CHARADD() * - CHARSUB() (NEW) * - CHARAND() * - CHARNOT() * - CHAROR() * - CHARXOR() * - CHARSHL() (NEW) * - CHARSHR() (NEW) * - CHARRLL() (NEW) * - CHARRLR() (NEW) * * Copyright 2001 IntTec GmbH, Neunlindenstr 32, 79106 Freiburg, Germany * Author: Martin Vogel * * www - http://www.harbour-project.org * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this software; see the file COPYING. If not, write to * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). * * As a special exception, the Harbour Project gives permission for * additional uses of the text contained in its release of Harbour. * * The exception is that, if you link the Harbour libraries with other * files to produce an executable, this does not by itself cause the * resulting executable to be covered by the GNU General Public License. * Your use of that executable is in no way restricted on account of * linking the Harbour library code into it. * * This exception does not however invalidate any other reasons why * the executable file might be covered by the GNU General Public License. * * This exception applies only to the code released by the Harbour * Project under the name Harbour. If you copy code from other * Harbour Project or Free Software Foundation releases into a copy of * Harbour, as the General Public License permits, the exception does * not apply to the code that you add in this way. To avoid misleading * anyone as to the status of such modified files, you must delete * this exception notice from them. * * If you write modifications of your own for Harbour, it is your choice * whether to permit this exception to apply to your modifications. * If you do not wish that, delete this exception notice. * */ #include "ct.h" #define DO_CHAROP_CHARADD 0 #define DO_CHAROP_CHARSUB 1 /* new: character subtraction */ #define DO_CHAROP_CHARAND 2 #define DO_CHAROP_CHARNOT 3 #define DO_CHAROP_CHAROR 4 #define DO_CHAROP_CHARXOR 5 #define DO_CHAROP_CHARSHL 6 /* new: shift left */ #define DO_CHAROP_CHARSHR 7 /* new: shift right */ #define DO_CHAROP_CHARRLL 8 /* new: left rotation */ #define DO_CHAROP_CHARRLR 9 /* new: right rotation */ /* helper function */ static void do_charop (int iSwitch) { int iNoRet; /* suppressing return value ? */ iNoRet = ct_getref(); if (ISCHAR (1)) { size_t sStrLen = hb_parclen (1); size_t sPos; unsigned char *pucString = ( unsigned char * ) hb_parc (1); unsigned char *pucResult = ( unsigned char * ) hb_xgrab (sStrLen); switch (iSwitch) { /* NOT */ case DO_CHAROP_CHARNOT: { for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = ~pucString[sPos]; }; break; /* SHL */ case DO_CHAROP_CHARSHL: { int iSHL = (hb_parni (2))%8; /* defaults to 0 */ if (iSHL == 0) hb_xmemcpy (pucResult, pucString, sStrLen); else for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = pucString[sPos] << iSHL; }; break; /* SHR */ case DO_CHAROP_CHARSHR: { int iSHR = (hb_parni (2))%8; /* defaults to 0 */ if (iSHR == 0) hb_xmemcpy (pucResult, pucString, sStrLen); else for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = pucString[sPos] >> iSHR; }; break; /* RLL */ case DO_CHAROP_CHARRLL: { int iRLL = (hb_parni (2))%8; /* defaults to 0 */ hb_xmemcpy (pucResult, pucString, sStrLen); if (iRLL != 0) for (sPos = 0; sPos < sStrLen; sPos++) { int iRLLCnt; for (iRLLCnt = 0; iRLLCnt < iRLL; iRLLCnt++) if (pucResult[sPos]&0x80) /* most left bit set -> roll over */ { pucResult[sPos] <<= 1; pucResult[sPos] |= 0x01; } else { pucResult[sPos] <<= 1; } } }; break; /* RLR */ case DO_CHAROP_CHARRLR: { int iRLR = (hb_parni (2))%8; /* defaults to 0 */ hb_xmemcpy (pucResult, pucString, sStrLen); if (iRLR != 0) for (sPos = 0; sPos < sStrLen; sPos++) { int iRLRCnt; for (iRLRCnt = 0; iRLRCnt < iRLR; iRLRCnt++) if (pucResult[sPos]&0x01) /* most right bit set -> roll over */ { pucResult[sPos] >>= 1; pucResult[sPos] |= 0x80; } else { pucResult[sPos] >>= 1; } } }; break; /* ADD */ case DO_CHAROP_CHARADD: { if (ISCHAR (2)) { char *pucString2 = hb_parc (2); size_t sStrLen2 = hb_parclen (2); for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = (char)(pucString[sPos]+pucString2[sPos%sStrLen2]); } else { int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { ct_error ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARADD, NULL, "CHARADD", 0, EF_CANDEFAULT, 2, hb_paramError (1), hb_paramError (2)); } hb_xmemcpy (pucResult, pucString, sStrLen); } }; break; /* SUB */ case DO_CHAROP_CHARSUB: { if (ISCHAR (2)) { char *pucString2 = hb_parc (2); size_t sStrLen2 = hb_parclen (2); for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = (char)(pucString[sPos]-pucString2[sPos%sStrLen2]); } else { int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { ct_error ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARSUB, NULL, "CHARSUB", 0, EF_CANDEFAULT, 2, hb_paramError (1), hb_paramError (2)); } hb_xmemcpy (pucResult, pucString, sStrLen); } }; break; /* AND */ case DO_CHAROP_CHARAND: { if (ISCHAR (2)) { char *pucString2 = hb_parc (2); size_t sStrLen2 = hb_parclen (2); for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = (char)(pucString[sPos] & pucString2[sPos%sStrLen2]); } else { int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { ct_error ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARAND, NULL, "CHARAND", 0, EF_CANDEFAULT, 2, hb_paramError (1), hb_paramError (2)); } hb_xmemcpy (pucResult, pucString, sStrLen); } }; break; /* OR */ case DO_CHAROP_CHAROR: { if (ISCHAR (2)) { char *pucString2 = hb_parc (2); size_t sStrLen2 = hb_parclen (2); for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = (char)(pucString[sPos] | pucString2[sPos%sStrLen2]); } else { int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { ct_error ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHAROR, NULL, "CHAROR", 0, EF_CANDEFAULT, 2, hb_paramError (1), hb_paramError (2)); } hb_xmemcpy (pucResult, pucString, sStrLen); } }; break; /* XOR */ case DO_CHAROP_CHARXOR: { if (ISCHAR (2)) { char *pucString2 = hb_parc (2); size_t sStrLen2 = hb_parclen (2); for (sPos = 0; sPos < sStrLen; sPos++) pucResult[sPos] = (char)(pucString[sPos] ^ pucString2[sPos%sStrLen2]); } else { int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { ct_error ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARXOR, NULL, "CHARXOR", 0, EF_CANDEFAULT, 2, hb_paramError (1), hb_paramError (2)); } hb_xmemcpy (pucResult, pucString, sStrLen); } }; break; }; /* endswitch (iSwitch) */ if (ISBYREF (1)) hb_storclen (( char * ) pucResult, sStrLen, 1); if (!iNoRet) hb_retclen (( char * ) pucResult, sStrLen); hb_xfree (pucResult); } else /* if (ISCHAR (1)) */ { PHB_ITEM pSubst = NULL; int iArgErrorMode = ct_getargerrormode(); if (iArgErrorMode != CT_ARGERR_IGNORE) { switch (iSwitch) { case DO_CHAROP_CHARADD: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARADD, NULL, "CHARADD", 0, EF_CANSUBSTITUTE, 2, hb_paramError (1), hb_paramError (2)); }; break; case DO_CHAROP_CHARSUB: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARSUB, NULL, "CHARSUB", 0, EF_CANSUBSTITUTE, 2, hb_paramError (1), hb_paramError (2)); }; break; case DO_CHAROP_CHARAND: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARAND, NULL, "CHARAND", 0, EF_CANSUBSTITUTE, 2, hb_paramError (1), hb_paramError (2)); }; break; case DO_CHAROP_CHARNOT: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARNOT, NULL, "CHARNOT", 0, EF_CANSUBSTITUTE, 1, hb_paramError (1)); }; break; case DO_CHAROP_CHAROR: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHAROR, NULL, "CHAROR", 0, EF_CANSUBSTITUTE, 2, hb_paramError (1), hb_paramError (2)); }; break; case DO_CHAROP_CHARXOR: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARXOR, NULL, "CHARXOR", 0, EF_CANSUBSTITUTE, 2, hb_paramError (1), hb_paramError (2)); }; break; case DO_CHAROP_CHARSHL: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARSHL, NULL, "CHARSHL", 0, EF_CANSUBSTITUTE, 1, hb_paramError (1)); }; break; case DO_CHAROP_CHARSHR: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARSHR, NULL, "CHARSHR", 0, EF_CANSUBSTITUTE, 1, hb_paramError (1)); }; break; case DO_CHAROP_CHARRLL: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARRLL, NULL, "CHARRLL", 0, EF_CANSUBSTITUTE, 1, hb_paramError (1)); }; break; case DO_CHAROP_CHARRLR: { pSubst = ct_error_subst ((USHORT)iArgErrorMode, EG_ARG, CT_ERROR_CHARRLR, NULL, "CHARRLR", 0, EF_CANSUBSTITUTE, 1, hb_paramError (1)); }; break; } } if (pSubst != NULL) { hb_itemReturn (pSubst); hb_itemRelease (pSubst); } else { hb_ret(); } } return; } /* $DOC$ * $FUNCNAME$ * CHARADD() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Adds corresponding ASCII value of two strings * $SYNTAX$ * CHARADD (<[@]cString1>, ) --> cAddString * $ARGUMENTS$ * <[@]cString1> first string * second string * $RETURNS$ * string with added ASCII values * $DESCRIPTION$ * The CHARADD() function constructs a new string from the two strings * passed as parameters. To do this, it adds the ASCII values of the * corresponding characters of both strings and places a character in * the resulting string whose ASCII value equals to that sum (modulo 256). * If the first string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * If is shorter than and the last character of * has been processed, the function restarts with the first * character of . * $EXAMPLES$ * ? charadd ("012345678", chr(1)) --> "123456789" * ? charadd ("123456789", chr(255)) --> "012345678" * ? charadd ("0000", chr(0)+chr(1)+chr(2)+chr(3)) --> "0123" * $TESTS$ * charadd ("012345678", chr(1)) == "123456789" * charadd ("012345678", chr(1)+chr(2)) == "133557799" * charadd ("123456789", chr(255)) == "012345678" * charadd ("123456789", chr(255)+chr(254)) == "002244668" * $STATUS$ * Ready * $COMPLIANCE$ * CHARADD() is compatible with CT3's CHARADD(). * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARSUB() CHARAND() CHARNOT() * CHAROR() CHARXOR() CHARSHL() * CHARSHR() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARADD) { do_charop (DO_CHAROP_CHARADD); return; } /* $DOC$ * $FUNCNAME$ * CHARSUB() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Subtracts corresponding ASCII value of two strings * $SYNTAX$ * CHARSUB (<[@]cString1>, ) --> cSubString * $ARGUMENTS$ * <[@]cString1> first string * second string * $RETURNS$ * string with subtracted ASCII values * $DESCRIPTION$ * The CHARSUB() function constructs a new string from the two strings * passed as parameters. To do this, it subtracts the ASCII values of the * corresponding characters of both strings and places a character in * the resulting string whose ASCII value equals to that difference (modulo 256). * If the first string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * If is shorter than and the last character of * has been processed, the function restarts with the first * character of . * $EXAMPLES$ * ? charsub ("012345678", chr(1)) --> "/01234567" * ? charsub ("123456789", chr(255)) --> "23456789:" * ? charsub ("9999", chr(0)+chr(1)+chr(2)+chr(3)) --> "9876" * $TESTS$ * charsub ("123456789", chr(1)) == "012345678" * charsub ("123456789", chr(1)+chr(2)) == "002244668" * charsub ("012345678", chr(255)) == "123456789" * charsub ("012345678", chr(255)+chr(254)) == "133557799" * $STATUS$ * Ready * $COMPLIANCE$ * CHARSUB() is a new function that is only available in Harbour's CT3 lib. * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARAND() CHARNOT() * CHAROR() CHARXOR() CHARSHL() * CHARSHR() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARSUB) { do_charop (DO_CHAROP_CHARSUB); return; } /* $DOC$ * $FUNCNAME$ * CHARAND() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Combine corresponding ASCII value of two strings with bitwise AND * $SYNTAX$ * CHARAND (<[@]cString1>, ) --> cAndString * $ARGUMENTS$ * <[@]cString1> first string * second string * $RETURNS$ * string with bitwise AND combined ASCII values * $DESCRIPTION$ * The CHARAND() function constructs a new string from the two strings * passed as parameters. To do this, it combines the ASCII values of the * corresponding characters of both strings with a bitwise AND-operation * and places a character in the resulting string whose ASCII value * equals to the result of that operation. * If the first string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * If is shorter than and the last character of * has been processed, the function restarts with the first * character of . * $EXAMPLES$ * // clear the LSB * ? charand ("012345678", chr(254)) --> "002244668" * ? charand ("012345678", chr(254)+chr(252)) --> "002044648" * $TESTS$ * charand ("012345678", chr(254)) == "002244668" * charand ("012345678", chr(254)+chr(252)) == "002044648" * $STATUS$ * Ready * $COMPLIANCE$ * CHARAND() is compatible with CT3's CHARAND(). * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARNOT() * CHAROR() CHARXOR() CHARSHL() * CHARSHR() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARAND) { do_charop (DO_CHAROP_CHARAND); return; } /* $DOC$ * $FUNCNAME$ * CHARNOT() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Process each character in a string with bitwise NOT operation * $SYNTAX$ * CHARNOT (<[@]cString>) --> cNotString * $ARGUMENTS$ * <[@]cString> string to be processed * $RETURNS$ * string with bitwise negated characters * $DESCRIPTION$ * The CHARNOT() function constructs a new string from the string * passed as parameter. To do this, it performs a bitwise NOT operation * to the characters of the string and places a character in * the resulting string whose ASCII value equals to the result of that * operation. It can be easily seen that the resulting ASCII-value equals * 255 minus input ASCII value. * If the string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * $EXAMPLES$ * ? charnot (chr(85)+chr(128)+chr(170)+chr(1)) --> chr(170)+chr(127)+chr(85)+chr(254) * ? charnot (charnot ("This is a test!")) --> "This is a test!" * $TESTS$ * charnot (chr(85)+chr(128)+chr(170)+chr(1)) == chr(170)+chr(127)+chr(85)+chr(254) * charnot (charnot ("This is a test!")) == "This is a test!" * $STATUS$ * Ready * $COMPLIANCE$ * CHARNOT() is compatible with CT3's CHARNOT(). * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARAND() * CHAROR() CHARXOR() CHARSHL() * CHARSHR() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARNOT) { do_charop (DO_CHAROP_CHARNOT); return; } /* $DOC$ * $FUNCNAME$ * CHAROR() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Combine corresponding ASCII value of two strings with bitwise OR * $SYNTAX$ * CHAROR (<[@]cString1>, ) --> cOrString * $ARGUMENTS$ * <[@]cString1> first string * second string * $RETURNS$ * string with bitwise OR combined ASCII values * $DESCRIPTION$ * The CHAROR() function constructs a new string from the two strings * passed as parameters. To do this, it combines the ASCII values of the * corresponding characters of both strings with a bitwise OR-operation * and places a character in the resulting string whose ASCII value * equals to the result of that operation. * If the first string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * If is shorter than and the last character of * has been processed, the function restarts with the first * character of . * $EXAMPLES$ * // set the LSB * ? charor ("012345678", chr(1)) --> "113355779" * ? charor ("012345678", chr(1)+chr(3)) --> "133357779" * $TESTS$ * charor ("012345678", chr(1)) == "113355779" * charor ("012345678", chr(1)+chr(3)) == "133357779" * $STATUS$ * Ready * $COMPLIANCE$ * CHAROR() is compatible with CT3's CHAROR(). * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARNOT() * CHARAND() CHARXOR() CHARSHL() * CHARSHR() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHAROR) { do_charop (DO_CHAROP_CHAROR); return; } /* $DOC$ * $FUNCNAME$ * CHARXOR() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Combine corresponding ASCII value of two strings with bitwise XOR * $SYNTAX$ * CHARXOR (<[@]cString1>, ) --> cXOrString * $ARGUMENTS$ * <[@]cString1> first string * second string * $RETURNS$ * string with bitwise XOR combined ASCII values * $DESCRIPTION$ * The CHARXOR() function constructs a new string from the two strings * passed as parameters. To do this, it combines the ASCII values of the * corresponding characters of both strings with a bitwise XOR-operation * and places a character in the resulting string whose ASCII value * equals to the result of that operation. * If the first string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * If is shorter than and the last character of * has been processed, the function restarts with the first * character of . * $EXAMPLES$ * // easy encryption * ? charxor ("This is top secret !", "My Password") --> * $TESTS$ * charxor (charxor ("This is top secret !", "My Password"), "My Password") == "This is top secret !" * $STATUS$ * Ready * $COMPLIANCE$ * CHARXOR() is compatible with CT3's CHARXOR(). * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARNOT() * CHARAND() CHAROR() CHARSHL() * CHARSHR() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARXOR) { do_charop (DO_CHAROP_CHARXOR); return; } /* $DOC$ * $FUNCNAME$ * CHARSHL() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Process each character in a string with bitwise SHIFT LEFT operation * $SYNTAX$ * CHARSHL (<[@]cString>, ) --> cSHLString * $ARGUMENTS$ * <[@]cString> string to be processed * number of bit positions to be shifted to the left * $RETURNS$ * string with bitwise shifted left characters * $DESCRIPTION$ * The CHARSHL() function constructs a new string from the string * passed as parameter. To do this, it performs a bitwise SHIFT LEFT * (SHL) operation to the characters of the string and places a character in * the resulting string whose ASCII value equals to the result of that * operation. * Be aware that bits shifted out of the byte are lost. If you need * a bit rotation, use the CHARRLL() function instead. * If the string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * $EXAMPLES$ * ? charshl (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) * --> chr(8)+chr(16)+chr(32)+chr(64)+chr(128)+chr(0)+chr(0)+chr(0) * $TESTS$ * charshl (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) == chr(8)+chr(16)+chr(32)+chr(64)+chr(128)+chr(0)+chr(0)+chr(0) * $STATUS$ * Ready * $COMPLIANCE$ * CHARSHL() is a new function that is only available in Harbour's CT3 lib. * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARAND() * CHAROR() CHARXOR() CHARNOT() * CHARSHR() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARSHL) { do_charop (DO_CHAROP_CHARSHL); return; } /* $DOC$ * $FUNCNAME$ * CHARSHR() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Process each character in a string with bitwise SHIFT RIGHT operation * $SYNTAX$ * CHARSHR (<[@]cString>, ) --> cSHRString * $ARGUMENTS$ * <[@]cString> string to be processed * number of bit positions to be shifted to the right * $RETURNS$ * string with bitwise shifted right characters * $DESCRIPTION$ * The CHARSHR() function constructs a new string from the string * passed as parameter. To do this, it performs a bitwise SHIFT RIGHT * (SHR) operation to the characters of the string and places a character in * the resulting string whose ASCII value equals to the result of that * operation. * Be aware that bits shifted out of the byte are lost. If you need * a bit rotation, use the CHARRLR() function instead. * If the string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * $EXAMPLES$ * ? charshr (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) * --> chr(0)+chr(0)+chr(0)+chr(1)+chr(2)+chr(4)+chr(8)+chr(16) * $TESTS$ * charshr (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) == chr(0)+chr(0)+chr(0)+chr(1)+chr(2)+chr(4)+chr(8)+chr(16) * $STATUS$ * Ready * $COMPLIANCE$ * CHARSHR() is a new function that is only available in Harbour's CT3 lib. * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARAND() * CHAROR() CHARXOR() CHARNOT() * CHARSHL() CHARRLL() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARSHR) { do_charop (DO_CHAROP_CHARSHR); return; } /* $DOC$ * $FUNCNAME$ * CHARRLL() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Process each character in a string with bitwise ROLL LEFT operation * $SYNTAX$ * CHARRLL (<[@]cString>, ) --> cRLLString * $ARGUMENTS$ * <[@]cString> string to be processed * number of bit positions to be rolled to the left * $RETURNS$ * string with bitwise rolled left characters * $DESCRIPTION$ * The CHARRLL() function constructs a new string from the string * passed as parameter. To do this, it performs a bitwise ROLL LEFT * (RLL) operation to the characters of the string and places a character in * the resulting string whose ASCII value equals to the result of that * operation. * Be aware that, in contrast to CHARSHL(), bits rolled out on * the left are put in again on the right. * If the string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * $EXAMPLES$ * ? charrll (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) * --> chr(8)+chr(16)+chr(32)+chr(64)+chr(128)+chr(1)+chr(2)+chr(4) * $TESTS$ * charrll (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) == chr(8)+chr(16)+chr(32)+chr(64)+chr(128)+chr(1)+chr(2)+chr(4) * $STATUS$ * Ready * $COMPLIANCE$ * CHARRLL() is a new function that is only available in Harbour's CT3 lib. * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARAND() * CHAROR() CHARXOR() CHARNOT() * CHARSHL() CHARSHR() CHARRLR() * CSETREF() * $END$ */ HB_FUNC (CHARRLL) { do_charop (DO_CHAROP_CHARRLL); return; } /* $DOC$ * $FUNCNAME$ * CHARRLR() * $CATEGORY$ * CT3 string functions * $ONELINER$ * Process each character in a string with bitwise ROLL RIGHT operation * $SYNTAX$ * CHARRLR (<[@]cString>, ) --> cRLRString * $ARGUMENTS$ * <[@]cString> string to be processed * number of bit positions to be rolled to the right * $RETURNS$ * string with bitwise rolled right characters * $DESCRIPTION$ * The CHARRLR() function constructs a new string from the string * passed as parameter. To do this, it performs a bitwise ROLL RIGHT * (RLR) operation to the characters of the string and places a character in * the resulting string whose ASCII value equals to the result of that * operation. * Be aware that, in contrast to CHARSHR(), bits rolled out on * the right are put in again on the left. * If the string is passed by reference, the resulting string is * stored in , too. By setting the CSETREF()-switch to .T., * the return value can be omitted. * $EXAMPLES$ * ? charrlr (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) * --> chr(32)+chr(64)+chr(128)+chr(1)+chr(2)+chr(4)+chr(8)+chr(16) * $TESTS$ * charrlr (chr(1)+chr(2)+chr(4)+chr(8)+chr(16)+chr(32)+chr(64)+chr(128), 3) == chr(32)+chr(64)+chr(128)+chr(1)+chr(2)+chr(4)+chr(8)+chr(16) * $STATUS$ * Ready * $COMPLIANCE$ * CHARRLR() is a new function that is only available in Harbour's CT3 lib. * $PLATFORMS$ * All * $FILES$ * Source is charop.c, library is ct3. * $SEEALSO$ * CHARADD() CHARSUB() CHARAND() * CHAROR() CHARXOR() CHARNOT() * CHARSHL() CHARSHR() CHARRLL() * CSETREF() * $END$ */ HB_FUNC (CHARRLR) { do_charop (DO_CHAROP_CHARRLR); return; }