diff --git a/harbour/ChangeLog b/harbour/ChangeLog index f586fee96f..b983c13ab1 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,43 @@ The license applies to all entries newer than 2009-04-28. */ +2012-05-02 12:30 UTC+0200 Viktor Szakats (harbour syenar.net) + * include/hbcompdf.h + * include/hbexprop.h + * include/hbexprb.c + * src/common/funcid.c + * src/common/expropt2.c + + added compile-time optimization for HB_BCHAR() + and HB_BCODE(). + + * contrib/hbct/hbct.hbp + * contrib/hbct/hbct.hbx + + contrib/hbct/ctscan.ch + + contrib/hbct/kxlat.prg + * contrib/hbct/ctdummy.prg + * contrib/hbct/dummy.c + + added CT compatiblity functions: SETKXLAT(), GETKXLAT(), + SETKXTAB(), GETKXTAB(). Former two replaces existing + dummy implementations. Check CT documentation for syntax. + NOTES: - KS_PAD[0-9] and KS_PAD_DECIMAL are not supported in + Harbour, because they have no corresponding inkey.ch + value. + - Harbour uses HB_GTI_INKEYFILTER to implement these + functions, and due to this, they will gracefully + fail if the application has already set + HB_GTI_INKEYFILTER to a custom value. + + added: + HBCT_GETKXLAT( [, ] ) -> + HBCT_GETKXTAB( ) -> + HBCT_SETKXLAT( ) -> + HBCT_SETKXTAB() -> + Same as above, but they use standard inkey() values. + ; USE AT YOUR OWN RISK. NO GUARANTEES. + + * contrib/hbct/showtime.prg + * contrib/hbct/screen2.c + * internal fn renamed: _HB_CTDSPTIME() -> __HBCT_DSPTIME() + 2012-05-01 20:50 UTC+0200 Viktor Szakats (harbour syenar.net) * src/rtl/hbregex.c % deleted unnecessary protection around PCRE_CONFIG_UTF8 diff --git a/harbour/contrib/hbct/ctdummy.prg b/harbour/contrib/hbct/ctdummy.prg index a37f55359c..1a68954a8b 100644 --- a/harbour/contrib/hbct/ctdummy.prg +++ b/harbour/contrib/hbct/ctdummy.prg @@ -50,19 +50,6 @@ * */ -#include "common.ch" - -FUNCTION getkxlat( nKeyValue ) - RETURN nKeyValue - -FUNCTION setkxlat( nOrgKeyValue, nNewKeyValue ) - LOCAL lAccepted := .F. - - HB_SYMBOL_UNUSED( nOrgKeyValue ) - HB_SYMBOL_UNUSED( nNewKeyValue ) - - RETURN lAccepted - FUNCTION dsetkbios( lNewKeyboardMode ) THREAD STATIC t_lKeyboardMode := .T. diff --git a/harbour/contrib/hbct/ctscan.ch b/harbour/contrib/hbct/ctscan.ch new file mode 100644 index 0000000000..ec0177f7b7 --- /dev/null +++ b/harbour/contrib/hbct/ctscan.ch @@ -0,0 +1,331 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * CT keyboard codes + * + * Copyright 2012 {list of individual authors and e-mail addresses} + * www - http://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. + * + */ + +#define KS_DISABLE hb_BChar( 255 ) + hb_BChar( 255 ) + +#define KS_A hb_BChar( 65 ) + hb_BChar( 16 ) +#define KS_B hb_BChar( 66 ) + hb_BChar( 48 ) +#define KS_C hb_BChar( 67 ) + hb_BChar( 46 ) +#define KS_D hb_BChar( 68 ) + hb_BChar( 32 ) +#define KS_E hb_BChar( 69 ) + hb_BChar( 18 ) +#define KS_F hb_BChar( 70 ) + hb_BChar( 33 ) +#define KS_G hb_BChar( 71 ) + hb_BChar( 34 ) +#define KS_H hb_BChar( 72 ) + hb_BChar( 35 ) +#define KS_I hb_BChar( 73 ) + hb_BChar( 23 ) +#define KS_J hb_BChar( 74 ) + hb_BChar( 36 ) +#define KS_K hb_BChar( 75 ) + hb_BChar( 37 ) +#define KS_L hb_BChar( 76 ) + hb_BChar( 38 ) +#define KS_M hb_BChar( 77 ) + hb_BChar( 39 ) +#define KS_N hb_BChar( 78 ) + hb_BChar( 49 ) +#define KS_O hb_BChar( 79 ) + hb_BChar( 24 ) +#define KS_P hb_BChar( 80 ) + hb_BChar( 25 ) +#define KS_Q hb_BChar( 81 ) + hb_BChar( 30 ) +#define KS_R hb_BChar( 82 ) + hb_BChar( 19 ) +#define KS_S hb_BChar( 83 ) + hb_BChar( 31 ) +#define KS_T hb_BChar( 84 ) + hb_BChar( 20 ) +#define KS_U hb_BChar( 85 ) + hb_BChar( 22 ) +#define KS_V hb_BChar( 86 ) + hb_BChar( 47 ) +#define KS_W hb_BChar( 87 ) + hb_BChar( 44 ) +#define KS_X hb_BChar( 88 ) + hb_BChar( 45 ) +#define KS_Y hb_BChar( 89 ) + hb_BChar( 21 ) +#define KS_Z hb_BChar( 90 ) + hb_BChar( 17 ) + +#define KS_a hb_BChar( 97 ) + hb_BChar( 16 ) +#define KS_b hb_BChar( 98 ) + hb_BChar( 48 ) +#define KS_c hb_BChar( 99 ) + hb_BChar( 46 ) +#define KS_d hb_BChar( 100 ) + hb_BChar( 32 ) +#define KS_e hb_BChar( 101 ) + hb_BChar( 18 ) +#define KS_f hb_BChar( 102 ) + hb_BChar( 33 ) +#define KS_g hb_BChar( 103 ) + hb_BChar( 34 ) +#define KS_h hb_BChar( 104 ) + hb_BChar( 35 ) +#define KS_i hb_BChar( 105 ) + hb_BChar( 23 ) +#define KS_j hb_BChar( 106 ) + hb_BChar( 36 ) +#define KS_k hb_BChar( 107 ) + hb_BChar( 37 ) +#define KS_l hb_BChar( 108 ) + hb_BChar( 38 ) +#define KS_m hb_BChar( 109 ) + hb_BChar( 39 ) +#define KS_n hb_BChar( 110 ) + hb_BChar( 49 ) +#define KS_o hb_BChar( 111 ) + hb_BChar( 24 ) +#define KS_p hb_BChar( 112 ) + hb_BChar( 25 ) +#define KS_q hb_BChar( 113 ) + hb_BChar( 30 ) +#define KS_r hb_BChar( 114 ) + hb_BChar( 19 ) +#define KS_s hb_BChar( 115 ) + hb_BChar( 31 ) +#define KS_t hb_BChar( 116 ) + hb_BChar( 20 ) +#define KS_u hb_BChar( 117 ) + hb_BChar( 22 ) +#define KS_v hb_BChar( 118 ) + hb_BChar( 47 ) +#define KS_w hb_BChar( 119 ) + hb_BChar( 44 ) +#define KS_x hb_BChar( 120 ) + hb_BChar( 45 ) +#define KS_y hb_BChar( 121 ) + hb_BChar( 21 ) +#define KS_z hb_BChar( 122 ) + hb_BChar( 17 ) + +#define KS_1 hb_BChar( 49 ) + hb_BChar( 2 ) +#define KS_2 hb_BChar( 50 ) + hb_BChar( 3 ) +#define KS_3 hb_BChar( 51 ) + hb_BChar( 4 ) +#define KS_4 hb_BChar( 52 ) + hb_BChar( 5 ) +#define KS_5 hb_BChar( 53 ) + hb_BChar( 6 ) +#define KS_6 hb_BChar( 54 ) + hb_BChar( 7 ) +#define KS_7 hb_BChar( 55 ) + hb_BChar( 8 ) +#define KS_8 hb_BChar( 56 ) + hb_BChar( 9 ) +#define KS_9 hb_BChar( 57 ) + hb_BChar( 10 ) +#define KS_0 hb_BChar( 48 ) + hb_BChar( 11 ) + +#define KS_DOT hb_BChar( 46 ) + hb_BChar( 52 ) +#define KS_COMMA hb_BChar( 44 ) + hb_BChar( 51 ) + +#define KS_CTRL_A hb_BChar( 1 ) + hb_BChar( 30 ) +#define KS_CTRL_B hb_BChar( 2 ) + hb_BChar( 48 ) +#define KS_CTRL_C hb_BChar( 3 ) + hb_BChar( 46 ) +#define KS_CTRL_D hb_BChar( 4 ) + hb_BChar( 32 ) +#define KS_CTRL_E hb_BChar( 5 ) + hb_BChar( 18 ) +#define KS_CTRL_F hb_BChar( 6 ) + hb_BChar( 33 ) +#define KS_CTRL_G hb_BChar( 7 ) + hb_BChar( 34 ) +#define KS_CTRL_H hb_BChar( 8 ) + hb_BChar( 35 ) +#define KS_CTRL_I hb_BChar( 9 ) + hb_BChar( 23 ) +#define KS_CTRL_M hb_BChar( 13 ) + hb_BChar( 50 ) +#define KS_CTRL_N hb_BChar( 14 ) + hb_BChar( 49 ) +#define KS_CTRL_R hb_BChar( 18 ) + hb_BChar( 19 ) +#define KS_CTRL_S hb_BChar( 19 ) + hb_BChar( 31 ) +#define KS_CTRL_T hb_BChar( 20 ) + hb_BChar( 20 ) +#define KS_CTRL_U hb_BChar( 21 ) + hb_BChar( 22 ) +#define KS_CTRL_V hb_BChar( 22 ) + hb_BChar( 47 ) +#define KS_CTRL_W hb_BChar( 23 ) + hb_BChar( 17 ) +#define KS_CTRL_X hb_BChar( 24 ) + hb_BChar( 45 ) +#define KS_CTRL_Y hb_BChar( 25 ) + hb_BChar( 21 ) +#define KS_CTRL_Z hb_BChar( 26 ) + hb_BChar( 44 ) + +#define KS_ALT_A hb_BChar( 0 ) + hb_BChar( 30 ) +#define KS_ALT_B hb_BChar( 0 ) + hb_BChar( 48 ) +#define KS_ALT_C hb_BChar( 0 ) + hb_BChar( 46 ) +#define KS_ALT_D hb_BChar( 0 ) + hb_BChar( 32 ) +#define KS_ALT_E hb_BChar( 0 ) + hb_BChar( 18 ) +#define KS_ALT_F hb_BChar( 0 ) + hb_BChar( 33 ) +#define KS_ALT_G hb_BChar( 0 ) + hb_BChar( 34 ) +#define KS_ALT_H hb_BChar( 0 ) + hb_BChar( 35 ) +#define KS_ALT_I hb_BChar( 0 ) + hb_BChar( 23 ) +#define KS_ALT_J hb_BChar( 0 ) + hb_BChar( 36 ) +#define KS_ALT_K hb_BChar( 0 ) + hb_BChar( 37 ) +#define KS_ALT_L hb_BChar( 0 ) + hb_BChar( 38 ) +#define KS_ALT_M hb_BChar( 0 ) + hb_BChar( 50 ) +#define KS_ALT_N hb_BChar( 0 ) + hb_BChar( 49 ) +#define KS_ALT_O hb_BChar( 0 ) + hb_BChar( 24 ) +#define KS_ALT_P hb_BChar( 0 ) + hb_BChar( 25 ) +#define KS_ALT_Q hb_BChar( 0 ) + hb_BChar( 16 ) +#define KS_ALT_R hb_BChar( 0 ) + hb_BChar( 19 ) +#define KS_ALT_S hb_BChar( 0 ) + hb_BChar( 31 ) +#define KS_ALT_T hb_BChar( 0 ) + hb_BChar( 20 ) +#define KS_ALT_U hb_BChar( 0 ) + hb_BChar( 22 ) +#define KS_ALT_V hb_BChar( 0 ) + hb_BChar( 47 ) +#define KS_ALT_W hb_BChar( 0 ) + hb_BChar( 17 ) +#define KS_ALT_X hb_BChar( 0 ) + hb_BChar( 45 ) +#define KS_ALT_Y hb_BChar( 0 ) + hb_BChar( 21 ) +#define KS_ALT_Z hb_BChar( 0 ) + hb_BChar( 44 ) + +#define KS_ALT_1 hb_BChar( 0 ) + hb_BChar( 120 ) +#define KS_ALT_2 hb_BChar( 0 ) + hb_BChar( 121 ) +#define KS_ALT_3 hb_BChar( 0 ) + hb_BChar( 122 ) +#define KS_ALT_4 hb_BChar( 0 ) + hb_BChar( 123 ) +#define KS_ALT_5 hb_BChar( 0 ) + hb_BChar( 124 ) +#define KS_ALT_6 hb_BChar( 0 ) + hb_BChar( 125 ) +#define KS_ALT_7 hb_BChar( 0 ) + hb_BChar( 126 ) +#define KS_ALT_8 hb_BChar( 0 ) + hb_BChar( 127 ) +#define KS_ALT_9 hb_BChar( 0 ) + hb_BChar( 128 ) +#define KS_ALT_0 hb_BChar( 0 ) + hb_BChar( 129 ) + +#define KS_F1 hb_BChar( 0 ) + hb_BChar( 59 ) +#define KS_F2 hb_BChar( 0 ) + hb_BChar( 60 ) +#define KS_F3 hb_BChar( 0 ) + hb_BChar( 61 ) +#define KS_F4 hb_BChar( 0 ) + hb_BChar( 62 ) +#define KS_F5 hb_BChar( 0 ) + hb_BChar( 63 ) +#define KS_F6 hb_BChar( 0 ) + hb_BChar( 64 ) +#define KS_F7 hb_BChar( 0 ) + hb_BChar( 65 ) +#define KS_F8 hb_BChar( 0 ) + hb_BChar( 66 ) +#define KS_F9 hb_BChar( 0 ) + hb_BChar( 67 ) +#define KS_F10 hb_BChar( 0 ) + hb_BChar( 68 ) +#define KS_F11 hb_BChar( 0 ) + hb_BChar( 133 ) +#define KS_F12 hb_BChar( 0 ) + hb_BChar( 134 ) + +#define KS_SH_F1 hb_BChar( 0 ) + hb_BChar( 84 ) +#define KS_SH_F2 hb_BChar( 0 ) + hb_BChar( 85 ) +#define KS_SH_F3 hb_BChar( 0 ) + hb_BChar( 86 ) +#define KS_SH_F4 hb_BChar( 0 ) + hb_BChar( 87 ) +#define KS_SH_F5 hb_BChar( 0 ) + hb_BChar( 88 ) +#define KS_SH_F6 hb_BChar( 0 ) + hb_BChar( 89 ) +#define KS_SH_F7 hb_BChar( 0 ) + hb_BChar( 90 ) +#define KS_SH_F8 hb_BChar( 0 ) + hb_BChar( 91 ) +#define KS_SH_F9 hb_BChar( 0 ) + hb_BChar( 92 ) +#define KS_SH_F10 hb_BChar( 0 ) + hb_BChar( 93 ) +#define KS_SH_F11 hb_BChar( 0 ) + hb_BChar( 135 ) +#define KS_SH_F12 hb_BChar( 0 ) + hb_BChar( 136 ) + +#define KS_CTRL_F1 hb_BChar( 0 ) + hb_BChar( 94 ) +#define KS_CTRL_F2 hb_BChar( 0 ) + hb_BChar( 95 ) +#define KS_CTRL_F3 hb_BChar( 0 ) + hb_BChar( 96 ) +#define KS_CTRL_F4 hb_BChar( 0 ) + hb_BChar( 97 ) +#define KS_CTRL_F5 hb_BChar( 0 ) + hb_BChar( 98 ) +#define KS_CTRL_F6 hb_BChar( 0 ) + hb_BChar( 99 ) +#define KS_CTRL_F7 hb_BChar( 0 ) + hb_BChar( 100 ) +#define KS_CTRL_F8 hb_BChar( 0 ) + hb_BChar( 101 ) +#define KS_CTRL_F9 hb_BChar( 0 ) + hb_BChar( 102 ) +#define KS_CTRL_F10 hb_BChar( 0 ) + hb_BChar( 103 ) +#define KS_CTRL_F11 hb_BChar( 0 ) + hb_BChar( 137 ) +#define KS_CTRL_F12 hb_BChar( 0 ) + hb_BChar( 138 ) + +#define KS_ALT_F1 hb_BChar( 0 ) + hb_BChar( 104 ) +#define KS_ALT_F2 hb_BChar( 0 ) + hb_BChar( 105 ) +#define KS_ALT_F3 hb_BChar( 0 ) + hb_BChar( 106 ) +#define KS_ALT_F4 hb_BChar( 0 ) + hb_BChar( 107 ) +#define KS_ALT_F5 hb_BChar( 0 ) + hb_BChar( 108 ) +#define KS_ALT_F6 hb_BChar( 0 ) + hb_BChar( 109 ) +#define KS_ALT_F7 hb_BChar( 0 ) + hb_BChar( 110 ) +#define KS_ALT_F8 hb_BChar( 0 ) + hb_BChar( 111 ) +#define KS_ALT_F9 hb_BChar( 0 ) + hb_BChar( 112 ) +#define KS_ALT_F10 hb_BChar( 0 ) + hb_BChar( 113 ) +#define KS_ALT_F11 hb_BChar( 0 ) + hb_BChar( 139 ) +#define KS_ALT_F12 hb_BChar( 0 ) + hb_BChar( 140 ) + +#define KS_BS hb_BChar( 8 ) + hb_BChar( 14 ) +#define KS_ESC hb_BChar( 27 ) + hb_BChar( 1 ) +#define KS_TAB hb_BChar( 9 ) + hb_BChar( 15 ) +#define KS_SH_TAB hb_BChar( 0 ) + hb_BChar( 15 ) + +#define KS_ALT_BS hb_BChar( 0 ) + hb_BChar( 14 ) +#define KS_ALT_ESC hb_BChar( 0 ) + hb_BChar( 1 ) +#define KS_ALT_TAB hb_BChar( 0 ) + hb_BChar( 165 ) + +#define KS_ENTER hb_BChar( 13 ) + hb_BChar( 28 ) +#define KS_CTRL_ENTER hb_BChar( 10 ) + hb_BChar( 28 ) +#define KS_ALT_ENTER hb_BChar( 0 ) + hb_BChar( 28 ) +#define KS_PAD_ENTER hb_BChar( 13 ) + hb_BChar( 224 ) +#define KS_PAD_CTRL_ENTER hb_BChar( 10 ) + hb_BChar( 224 ) +#define KS_PAD_ALT_ENTER hb_BChar( 0 ) + hb_BChar( 166 ) + +#define KS_INS hb_BChar( 224 ) + hb_BChar( 82 ) +#define KS_DEL hb_BChar( 224 ) + hb_BChar( 83 ) +#define KS_HOME hb_BChar( 224 ) + hb_BChar( 71 ) +#define KS_END hb_BChar( 224 ) + hb_BChar( 79 ) +#define KS_PGUP hb_BChar( 224 ) + hb_BChar( 73 ) +#define KS_PGDN hb_BChar( 224 ) + hb_BChar( 81 ) +#define KS_UP hb_BChar( 224 ) + hb_BChar( 72 ) +#define KS_LEFT hb_BChar( 224 ) + hb_BChar( 75 ) +#define KS_DOWN hb_BChar( 224 ) + hb_BChar( 80 ) +#define KS_RIGHT hb_BChar( 224 ) + hb_BChar( 77 ) + +#define KS_CTRL_INS hb_BChar( 224 ) + hb_BChar( 146 ) +#define KS_CTRL_DEL hb_BChar( 224 ) + hb_BChar( 147 ) +#define KS_CTRL_HOME hb_BChar( 224 ) + hb_BChar( 119 ) +#define KS_CTRL_END hb_BChar( 224 ) + hb_BChar( 117 ) +#define KS_CTRL_PGUP hb_BChar( 224 ) + hb_BChar( 132 ) +#define KS_CTRL_PGDN hb_BChar( 224 ) + hb_BChar( 118 ) +#define KS_CTRL_UP hb_BChar( 224 ) + hb_BChar( 141 ) +#define KS_CTRL_LEFT hb_BChar( 224 ) + hb_BChar( 115 ) +#define KS_CTRL_DOWN hb_BChar( 224 ) + hb_BChar( 145 ) +#define KS_CTRL_RIGHT hb_BChar( 224 ) + hb_BChar( 116 ) + +#define KS_ALT_INS hb_BChar( 0 ) + hb_BChar( 162 ) +#define KS_ALT_DEL hb_BChar( 0 ) + hb_BChar( 163 ) +#define KS_ALT_HOME hb_BChar( 0 ) + hb_BChar( 151 ) +#define KS_ALT_END hb_BChar( 0 ) + hb_BChar( 159 ) +#define KS_ALT_PGUP hb_BChar( 0 ) + hb_BChar( 153 ) +#define KS_ALT_PGDN hb_BChar( 0 ) + hb_BChar( 161 ) +#define KS_ALT_UP hb_BChar( 0 ) + hb_BChar( 152 ) +#define KS_ALT_LEFT hb_BChar( 0 ) + hb_BChar( 155 ) +#define KS_ALT_DOWN hb_BChar( 0 ) + hb_BChar( 160 ) +#define KS_ALT_RIGHT hb_BChar( 0 ) + hb_BChar( 157 ) + +#define KS_PAD_INS hb_BChar( 0 ) + hb_BChar( 82 ) +#define KS_PAD_DEL hb_BChar( 0 ) + hb_BChar( 83 ) +#define KS_PAD_HOME hb_BChar( 0 ) + hb_BChar( 71 ) +#define KS_PAD_END hb_BChar( 0 ) + hb_BChar( 79 ) +#define KS_PAD_PGUP hb_BChar( 0 ) + hb_BChar( 73 ) +#define KS_PAD_PGDN hb_BChar( 0 ) + hb_BChar( 81 ) +#define KS_PAD_UP hb_BChar( 0 ) + hb_BChar( 72 ) +#define KS_PAD_LEFT hb_BChar( 0 ) + hb_BChar( 75 ) +#define KS_PAD_DOWN hb_BChar( 0 ) + hb_BChar( 80 ) +#define KS_PAD_RIGHT hb_BChar( 0 ) + hb_BChar( 77 ) + +#define KS_CTRL_PAD_INS hb_BChar( 0 ) + hb_BChar( 146 ) +#define KS_CTRL_PAD_DEL hb_BChar( 0 ) + hb_BChar( 147 ) +#define KS_CTRL_PAD_HOME hb_BChar( 0 ) + hb_BChar( 119 ) +#define KS_CTRL_PAD_END hb_BChar( 0 ) + hb_BChar( 117 ) +#define KS_CTRL_PAD_PGUP hb_BChar( 0 ) + hb_BChar( 132 ) +#define KS_CTRL_PAD_PGDN hb_BChar( 0 ) + hb_BChar( 118 ) +#define KS_CTRL_PAD_UP hb_BChar( 0 ) + hb_BChar( 141 ) +#define KS_CTRL_PAD_LEFT hb_BChar( 0 ) + hb_BChar( 115 ) +#define KS_CTRL_PAD_DOWN hb_BChar( 0 ) + hb_BChar( 145 ) +#define KS_CTRL_PAD_RIGHT hb_BChar( 0 ) + hb_BChar( 116 ) + +#define KS_PAD_DIV hb_BChar( 47 ) + hb_BChar( 224 ) +#define KS_PAD_MUL hb_BChar( 42 ) + hb_BChar( 55 ) +#define KS_PAD_MINUS hb_BChar( 45 ) + hb_BChar( 74 ) +#define KS_PAD_PLUS hb_BChar( 43 ) + hb_BChar( 78 ) + +#define KS_CTRL_PAD_DIV hb_BChar( 0 ) + hb_BChar( 149 ) +#define KS_CTRL_PAD_MUL hb_BChar( 0 ) + hb_BChar( 150 ) +#define KS_CTRL_PAD_MINUS hb_BChar( 0 ) + hb_BChar( 142 ) +#define KS_CTRL_PAD_PLUS hb_BChar( 0 ) + hb_BChar( 144 ) + +#define KS_ALT_PAD_DIV hb_BChar( 0 ) + hb_BChar( 164 ) +#define KS_ALT_PAD_MUL hb_BChar( 0 ) + hb_BChar( 55 ) +#define KS_ALT_PAD_MINUS hb_BChar( 0 ) + hb_BChar( 74 ) +#define KS_ALT_PAD_PLUS hb_BChar( 0 ) + hb_BChar( 78 ) + +#define KS_PAD_1 hb_BChar( 49 ) + hb_BChar( 79 ) +#define KS_PAD_2 hb_BChar( 50 ) + hb_BChar( 80 ) +#define KS_PAD_3 hb_BChar( 51 ) + hb_BChar( 81 ) +#define KS_PAD_4 hb_BChar( 52 ) + hb_BChar( 75 ) +#define KS_PAD_5 hb_BChar( 53 ) + hb_BChar( 76 ) +#define KS_PAD_6 hb_BChar( 54 ) + hb_BChar( 77 ) +#define KS_PAD_7 hb_BChar( 55 ) + hb_BChar( 71 ) +#define KS_PAD_8 hb_BChar( 56 ) + hb_BChar( 72 ) +#define KS_PAD_9 hb_BChar( 57 ) + hb_BChar( 73 ) +#define KS_PAD_0 hb_BChar( 48 ) + hb_BChar( 82 ) + +#define KS_PAD_DECIMAL hb_BChar( 46 ) + hb_BChar( 83 ) diff --git a/harbour/contrib/hbct/dummy.c b/harbour/contrib/hbct/dummy.c index 591640cd58..7eff483d16 100644 --- a/harbour/contrib/hbct/dummy.c +++ b/harbour/contrib/hbct/dummy.c @@ -65,7 +65,6 @@ HB_FUNC( FIRSTCOL ) {;} HB_FUNC( FIRSTROW ) {;} HB_FUNC( GETBOXGROW ) {;} HB_FUNC( GETCURSOR ) {;} -HB_FUNC( GETKXTAB ) {;} HB_FUNC( GETLINES ) {;} HB_FUNC( GETMODE ) {;} HB_FUNC( GETPAGE ) {;} @@ -86,7 +85,6 @@ HB_FUNC( PRINTERROR ) {;} HB_FUNC( SETBELL ) {;} HB_FUNC( SETBOXGROW ) {;} HB_FUNC( SETCURSOR ) {;} -HB_FUNC( SETKXTAB ) {;} HB_FUNC( SETLINES ) {;} HB_FUNC( SETMAXCOL ) {;} HB_FUNC( SETMAXROW ) {;} diff --git a/harbour/contrib/hbct/hbct.hbp b/harbour/contrib/hbct/hbct.hbp index c24c17681a..e02aa1122a 100644 --- a/harbour/contrib/hbct/hbct.hbp +++ b/harbour/contrib/hbct/hbct.hbp @@ -127,6 +127,7 @@ getsecrt.prg keysave.prg keysec.prg keytime.prg +kxlat.prg screen3.prg scrmark.prg showtime.prg diff --git a/harbour/contrib/hbct/hbct.hbx b/harbour/contrib/hbct/hbct.hbx index 32aa0be774..ba0b867134 100644 --- a/harbour/contrib/hbct/hbct.hbx +++ b/harbour/contrib/hbct/hbct.hbx @@ -204,10 +204,15 @@ DYNAMIC GETFLDROW DYNAMIC GETFLDVAR DYNAMIC GETINPUT DYNAMIC GETKXLAT +DYNAMIC GETKXTAB DYNAMIC GETPREC DYNAMIC GETSECRET +DYNAMIC HBCT_GETKXLAT +DYNAMIC HBCT_GETKXTAB DYNAMIC HBCT_MAXCOL DYNAMIC HBCT_MAXROW +DYNAMIC HBCT_SETKXLAT +DYNAMIC HBCT_SETKXTAB DYNAMIC HB_GT_CTW DYNAMIC INFINITY DYNAMIC INTNEG @@ -322,6 +327,7 @@ DYNAMIC SETFCREATE DYNAMIC SETFDATI DYNAMIC SETFONT DYNAMIC SETKXLAT +DYNAMIC SETKXTAB DYNAMIC SETLASTKEY DYNAMIC SETPREC DYNAMIC SETRC @@ -401,7 +407,9 @@ DYNAMIC XMOCHECK DYNAMIC XTOC DYNAMIC ZEROINSERT DYNAMIC ZEROREMOVE -DYNAMIC _HB_CTDSPTIME +DYNAMIC __HBCT_DSPTIME +DYNAMIC __HBCT_KEY_C_TO_N +DYNAMIC __HBCT_KEY_N_TO_C #if defined( __HBEXTREQ__ ) .OR. defined( __HBEXTERN__HBCT__REQUEST ) #uncommand DYNAMIC => EXTERNAL diff --git a/harbour/contrib/hbct/kxlat.prg b/harbour/contrib/hbct/kxlat.prg new file mode 100644 index 0000000000..68b0b11048 --- /dev/null +++ b/harbour/contrib/hbct/kxlat.prg @@ -0,0 +1,485 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * [S|G]ETKX[LAT|TAB] CA-Tools functions (USE IT AT YOUR OWN RISK) + * + * Copyright 2012 Viktor Szakats (harbour syenar.net) + * www - http://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 "common.ch" +#include "inkey.ch" + +#include "hbgtinfo.ch" +#include "hbinkey.ch" + +#include "ctscan.ch" + +/* Trick to make it work in the STATIC initializer. + It's safe because it's only used with ASCII chars. */ +#define hb_keyCode( x ) Asc( x ) + +STATIC s_hTrs := { => } +STATIC s_hMutex := hb_mutexCreate() + +STATIC sc_hCnv := {; + KS_DISABLE => 0 ,; + KS_A => hb_keyCode( "A" ) ,; + KS_B => hb_keyCode( "B" ) ,; + KS_C => hb_keyCode( "C" ) ,; + KS_D => hb_keyCode( "D" ) ,; + KS_E => hb_keyCode( "E" ) ,; + KS_F => hb_keyCode( "F" ) ,; + KS_G => hb_keyCode( "G" ) ,; + KS_H => hb_keyCode( "H" ) ,; + KS_I => hb_keyCode( "I" ) ,; + KS_J => hb_keyCode( "J" ) ,; + KS_K => hb_keyCode( "K" ) ,; + KS_L => hb_keyCode( "L" ) ,; + KS_M => hb_keyCode( "M" ) ,; + KS_N => hb_keyCode( "N" ) ,; + KS_O => hb_keyCode( "O" ) ,; + KS_P => hb_keyCode( "P" ) ,; + KS_Q => hb_keyCode( "Q" ) ,; + KS_R => hb_keyCode( "R" ) ,; + KS_S => hb_keyCode( "S" ) ,; + KS_T => hb_keyCode( "T" ) ,; + KS_U => hb_keyCode( "U" ) ,; + KS_V => hb_keyCode( "V" ) ,; + KS_W => hb_keyCode( "W" ) ,; + KS_X => hb_keyCode( "X" ) ,; + KS_Y => hb_keyCode( "Y" ) ,; + KS_Z => hb_keyCode( "Z" ) ,; + KS_a => hb_keyCode( "a" ) ,; + KS_b => hb_keyCode( "b" ) ,; + KS_c => hb_keyCode( "c" ) ,; + KS_d => hb_keyCode( "d" ) ,; + KS_e => hb_keyCode( "e" ) ,; + KS_f => hb_keyCode( "f" ) ,; + KS_g => hb_keyCode( "g" ) ,; + KS_h => hb_keyCode( "h" ) ,; + KS_i => hb_keyCode( "i" ) ,; + KS_j => hb_keyCode( "j" ) ,; + KS_k => hb_keyCode( "k" ) ,; + KS_l => hb_keyCode( "l" ) ,; + KS_m => hb_keyCode( "m" ) ,; + KS_n => hb_keyCode( "n" ) ,; + KS_o => hb_keyCode( "o" ) ,; + KS_p => hb_keyCode( "p" ) ,; + KS_q => hb_keyCode( "q" ) ,; + KS_r => hb_keyCode( "r" ) ,; + KS_s => hb_keyCode( "s" ) ,; + KS_t => hb_keyCode( "t" ) ,; + KS_u => hb_keyCode( "u" ) ,; + KS_v => hb_keyCode( "v" ) ,; + KS_w => hb_keyCode( "w" ) ,; + KS_x => hb_keyCode( "x" ) ,; + KS_y => hb_keyCode( "y" ) ,; + KS_z => hb_keyCode( "z" ) ,; + KS_1 => hb_keyCode( "1" ) ,; + KS_2 => hb_keyCode( "2" ) ,; + KS_3 => hb_keyCode( "3" ) ,; + KS_4 => hb_keyCode( "4" ) ,; + KS_5 => hb_keyCode( "5" ) ,; + KS_6 => hb_keyCode( "6" ) ,; + KS_7 => hb_keyCode( "7" ) ,; + KS_8 => hb_keyCode( "8" ) ,; + KS_9 => hb_keyCode( "9" ) ,; + KS_0 => hb_keyCode( "0" ) ,; + KS_DOT => hb_keyCode( "." ) ,; + KS_COMMA => hb_keyCode( "," ) ,; + KS_CTRL_A => K_CTRL_A ,; + KS_CTRL_B => K_CTRL_B ,; + KS_CTRL_C => K_CTRL_C ,; + KS_CTRL_D => K_CTRL_D ,; + KS_CTRL_E => K_CTRL_E ,; + KS_CTRL_F => K_CTRL_F ,; + KS_CTRL_G => K_CTRL_G ,; + KS_CTRL_H => K_CTRL_H ,; + KS_CTRL_I => K_CTRL_I ,; + KS_CTRL_M => K_CTRL_M ,; + KS_CTRL_N => K_CTRL_N ,; + KS_CTRL_R => K_CTRL_R ,; + KS_CTRL_S => K_CTRL_S ,; + KS_CTRL_T => K_CTRL_T ,; + KS_CTRL_U => K_CTRL_U ,; + KS_CTRL_V => K_CTRL_V ,; + KS_CTRL_W => K_CTRL_W ,; + KS_CTRL_X => K_CTRL_X ,; + KS_CTRL_Y => K_CTRL_Y ,; + KS_CTRL_Z => K_CTRL_Z ,; + KS_ALT_A => K_ALT_A ,; + KS_ALT_B => K_ALT_B ,; + KS_ALT_C => K_ALT_C ,; + KS_ALT_D => K_ALT_D ,; + KS_ALT_E => K_ALT_E ,; + KS_ALT_F => K_ALT_F ,; + KS_ALT_G => K_ALT_G ,; + KS_ALT_H => K_ALT_H ,; + KS_ALT_I => K_ALT_I ,; + KS_ALT_J => K_ALT_J ,; + KS_ALT_K => K_ALT_K ,; + KS_ALT_L => K_ALT_L ,; + KS_ALT_M => K_ALT_M ,; + KS_ALT_N => K_ALT_N ,; + KS_ALT_O => K_ALT_O ,; + KS_ALT_P => K_ALT_P ,; + KS_ALT_Q => K_ALT_Q ,; + KS_ALT_R => K_ALT_R ,; + KS_ALT_S => K_ALT_S ,; + KS_ALT_T => K_ALT_T ,; + KS_ALT_U => K_ALT_U ,; + KS_ALT_V => K_ALT_V ,; + KS_ALT_W => K_ALT_W ,; + KS_ALT_X => K_ALT_X ,; + KS_ALT_Y => K_ALT_Y ,; + KS_ALT_Z => K_ALT_Z ,; + KS_ALT_1 => K_ALT_1 ,; + KS_ALT_2 => K_ALT_2 ,; + KS_ALT_3 => K_ALT_3 ,; + KS_ALT_4 => K_ALT_4 ,; + KS_ALT_5 => K_ALT_5 ,; + KS_ALT_6 => K_ALT_6 ,; + KS_ALT_7 => K_ALT_7 ,; + KS_ALT_8 => K_ALT_8 ,; + KS_ALT_9 => K_ALT_9 ,; + KS_ALT_0 => K_ALT_0 ,; + KS_F1 => K_F1 ,; + KS_F2 => K_F2 ,; + KS_F3 => K_F3 ,; + KS_F4 => K_F4 ,; + KS_F5 => K_F5 ,; + KS_F6 => K_F6 ,; + KS_F7 => K_F7 ,; + KS_F8 => K_F8 ,; + KS_F9 => K_F9 ,; + KS_F10 => K_F10 ,; + KS_F11 => K_F11 ,; + KS_F12 => K_F12 ,; + KS_SH_F1 => K_SH_F1 ,; + KS_SH_F2 => K_SH_F2 ,; + KS_SH_F3 => K_SH_F3 ,; + KS_SH_F4 => K_SH_F4 ,; + KS_SH_F5 => K_SH_F5 ,; + KS_SH_F6 => K_SH_F6 ,; + KS_SH_F7 => K_SH_F7 ,; + KS_SH_F8 => K_SH_F8 ,; + KS_SH_F9 => K_SH_F9 ,; + KS_SH_F10 => K_SH_F10 ,; + KS_SH_F11 => K_SH_F11 ,; + KS_SH_F12 => K_SH_F12 ,; + KS_CTRL_F1 => K_CTRL_F1 ,; + KS_CTRL_F2 => K_CTRL_F2 ,; + KS_CTRL_F3 => K_CTRL_F3 ,; + KS_CTRL_F4 => K_CTRL_F4 ,; + KS_CTRL_F5 => K_CTRL_F5 ,; + KS_CTRL_F6 => K_CTRL_F6 ,; + KS_CTRL_F7 => K_CTRL_F7 ,; + KS_CTRL_F8 => K_CTRL_F8 ,; + KS_CTRL_F9 => K_CTRL_F9 ,; + KS_CTRL_F10 => K_CTRL_F10 ,; + KS_CTRL_F11 => K_CTRL_F11 ,; + KS_CTRL_F12 => K_CTRL_F12 ,; + KS_ALT_F1 => K_ALT_F1 ,; + KS_ALT_F2 => K_ALT_F2 ,; + KS_ALT_F3 => K_ALT_F3 ,; + KS_ALT_F4 => K_ALT_F4 ,; + KS_ALT_F5 => K_ALT_F5 ,; + KS_ALT_F6 => K_ALT_F6 ,; + KS_ALT_F7 => K_ALT_F7 ,; + KS_ALT_F8 => K_ALT_F8 ,; + KS_ALT_F9 => K_ALT_F9 ,; + KS_ALT_F10 => K_ALT_F10 ,; + KS_ALT_F11 => K_ALT_F11 ,; + KS_ALT_F12 => K_ALT_F12 ,; + KS_BS => K_BS ,; + KS_ESC => K_ESC ,; + KS_TAB => K_TAB ,; + KS_SH_TAB => K_SH_TAB ,; + KS_ALT_BS => K_ALT_BS ,; + KS_ALT_ESC => K_ALT_ESC ,; + KS_ALT_TAB => K_ALT_TAB ,; + KS_ENTER => K_ENTER ,; + KS_CTRL_ENTER => K_CTRL_ENTER ,; + KS_ALT_ENTER => K_ALT_ENTER ,; + KS_PAD_ENTER => HB_KP_ENTER ,; + KS_PAD_CTRL_ENTER => HB_KP_CTRL_ENTER ,; + KS_PAD_ALT_ENTER => KP_ALT_ENTER ,; + KS_INS => K_INS ,; + KS_DEL => K_DEL ,; + KS_HOME => K_HOME ,; + KS_END => K_END ,; + KS_PGUP => K_PGUP ,; + KS_PGDN => K_PGDN ,; + KS_UP => K_UP ,; + KS_LEFT => K_LEFT ,; + KS_DOWN => K_DOWN ,; + KS_RIGHT => K_RIGHT ,; + KS_CTRL_INS => K_CTRL_INS ,; + KS_CTRL_DEL => K_CTRL_DEL ,; + KS_CTRL_HOME => K_CTRL_HOME ,; + KS_CTRL_END => K_CTRL_END ,; + KS_CTRL_PGUP => K_CTRL_PGUP ,; + KS_CTRL_PGDN => K_CTRL_PGDN ,; + KS_CTRL_UP => K_CTRL_UP ,; + KS_CTRL_LEFT => K_CTRL_LEFT ,; + KS_CTRL_DOWN => K_CTRL_DOWN ,; + KS_CTRL_RIGHT => K_CTRL_RIGHT ,; + KS_ALT_INS => K_ALT_INS ,; + KS_ALT_DEL => K_ALT_DEL ,; + KS_ALT_HOME => K_ALT_HOME ,; + KS_ALT_END => K_ALT_END ,; + KS_ALT_PGUP => K_ALT_PGUP ,; + KS_ALT_PGDN => K_ALT_PGDN ,; + KS_ALT_UP => K_ALT_UP ,; + KS_ALT_LEFT => K_ALT_LEFT ,; + KS_ALT_DOWN => K_ALT_DOWN ,; + KS_ALT_RIGHT => K_ALT_RIGHT ,; + KS_PAD_INS => HB_KP_INS ,; + KS_PAD_DEL => HB_KP_DEL ,; + KS_PAD_HOME => HB_KP_HOME ,; + KS_PAD_END => HB_KP_END ,; + KS_PAD_PGUP => HB_KP_PG_UP ,; + KS_PAD_PGDN => HB_KP_PG_DN ,; + KS_PAD_UP => HB_KP_UP ,; + KS_PAD_LEFT => HB_KP_LEFT ,; + KS_PAD_DOWN => HB_KP_DOWN ,; + KS_PAD_RIGHT => HB_KP_RIGHT ,; + KS_CTRL_PAD_INS => HB_KP_CTRL_INS ,; + KS_CTRL_PAD_DEL => HB_KP_CTRL_DEL ,; + KS_CTRL_PAD_HOME => HB_KP_CTRL_HOME ,; + KS_CTRL_PAD_END => HB_KP_CTRL_END ,; + KS_CTRL_PAD_PGUP => HB_KP_CTRL_PG_UP ,; + KS_CTRL_PAD_PGDN => HB_KP_CTRL_PG_DN ,; + KS_CTRL_PAD_UP => HB_KP_CTRL_UP ,; + KS_CTRL_PAD_LEFT => HB_KP_CTRL_LEFT ,; + KS_CTRL_PAD_DOWN => HB_KP_CTRL_DOWN ,; + KS_CTRL_PAD_RIGHT => HB_KP_CTRL_RIGHT ,; + KS_PAD_DIV => KP_ALT_SLASH ,; + KS_PAD_MUL => KP_ALT_ASTERISK ,; + KS_PAD_MINUS => KP_ALT_MINUS ,; + KS_PAD_PLUS => KP_ALT_PLUS ,; + KS_CTRL_PAD_DIV => KP_CTRL_SLASH ,; + KS_CTRL_PAD_MUL => KP_CTRL_ASTERISK ,; + KS_CTRL_PAD_MINUS => KP_CTRL_MINUS ,; + KS_CTRL_PAD_PLUS => KP_CTRL_PLUS ,; + KS_ALT_PAD_DIV => HB_KP_ALT_SLASH ,; + KS_ALT_PAD_MUL => HB_KP_ALT_STAR ,; + KS_ALT_PAD_MINUS => HB_KP_ALT_MINUS ,; + KS_ALT_PAD_PLUS => HB_KP_ALT_PLUS ,; + KS_PAD_1 => 0 ,; /* no Harbour equivalent */ + KS_PAD_2 => 0 ,; /* no Harbour equivalent */ + KS_PAD_3 => 0 ,; /* no Harbour equivalent */ + KS_PAD_4 => 0 ,; /* no Harbour equivalent */ + KS_PAD_5 => 0 ,; /* no Harbour equivalent */ + KS_PAD_6 => 0 ,; /* no Harbour equivalent */ + KS_PAD_7 => 0 ,; /* no Harbour equivalent */ + KS_PAD_8 => 0 ,; /* no Harbour equivalent */ + KS_PAD_9 => 0 ,; /* no Harbour equivalent */ + KS_PAD_0 => 0 ,; /* no Harbour equivalent */ + KS_PAD_DECIMAL => 0 } /* no Harbour equivalent */ + +FUNCTION __hbct_key_c_to_n( cKey ) + + IF hb_isString( cKey ) + RETURN hb_HGetDef( sc_hCnv, cKey, 0 ) + ENDIF + + RETURN NIL + +FUNCTION __hbct_key_n_to_c( nKey ) + LOCAL hKey + + IF hb_isNumeric( nKey ) + FOR EACH hKey IN sc_hCnv + IF hKey:__enumValue() == nKey + RETURN hKey:__enumKey() + ENDIF + NEXT + ENDIF + + RETURN hb_BChar( 0 ) + hb_BChar( 0 ) + +FUNCTION setkxlat( cOrgKeyValue, cNewKeyValue ) + + SWITCH PCount() + CASE 0 ; RETURN hbct_setkxlat() + CASE 1 ; RETURN hbct_setkxlat( __hbct_key_c_to_n( cOrgKeyValue ) ) + ENDSWITCH + + RETURN hbct_setkxlat( __hbct_key_c_to_n( cOrgKeyValue ), __hbct_key_c_to_n( cNewKeyValue ) ) + +FUNCTION getkxlat( cKeyValue ) + LOCAL xKey := hbct_getkxlat( __hbct_key_c_to_n( cKeyValue ) ) + + /* doc is unclear. should this return a numeric in these cases? */ + IF hb_isNumeric( xKey ) + RETURN xKey + ENDIF + + RETURN __hbct_key_n_to_c( xKey ) + +FUNCTION setkxtab( cTrs ) + LOCAL hTrs := { => } + LOCAL tmp + + IF hb_isString( cTrs ) + FOR tmp := 1 TO hb_BLen( cTrs ) STEP 4 + hTrs[ __hbct_key_c_to_n( hb_BSubStr( cTrs, tmp, 2 ) ) ] := __hbct_key_c_to_n( hb_BSubStr( cTrs, tmp + 2, 2 ) ) + NEXT + ENDIF + + RETURN hbct_setkxtab( hTrs ) + +FUNCTION getkxtab() + LOCAL cTrs := "" + LOCAL hTrs := hbct_getkxtab() + LOCAL hKey + + FOR EACH hKey IN hTrs + cTrs += __hbct_key_n_to_c( hKey:__enumKey() ) + __hbct_key_n_to_c( hKey:__enumValue() ) + NEXT + + RETURN cTrs + +/* Harbour extensions using standard numeric key values */ + +FUNCTION hbct_setkxlat( nOrgKeyValue, nNewKeyValue ) + LOCAL lAccepted := .F. + + IF PCount() == 0 + IF hb_mutexLock( s_hMutex ) + lAccepted := .T. + IF ! Empty( s_hTrs ) + hb_HClear( s_hTrs ) + hb_gtInfo( HB_GTI_INKEYFILTER, NIL ) + ENDIF + hb_mutexUnlock( s_hMutex ) + ENDIF + ELSE + IF hb_isNumeric( nOrgKeyValue ) .AND. nOrgKeyValue != 0 + IF hb_mutexLock( s_hMutex ) + IF PCount() == 1 + IF nOrgKeyValue $ s_hTrs + lAccepted := .T. + hb_HDel( s_hTrs, nOrgKeyValue ) + IF Empty( s_hTrs ) + hb_gtInfo( HB_GTI_INKEYFILTER, NIL ) + ENDIF + ENDIF + ELSEIF hb_isNumeric( nNewKeyValue ) + /* refuse overwriting custom HB_GTI_INKEYFILTER */ + IF hb_gtInfo( HB_GTI_INKEYFILTER ) == NIL .OR. ! Empty( s_hTrs ) + lAccepted := .T. + IF Empty( s_hTrs ) + hb_gtInfo( HB_GTI_INKEYFILTER, {| nKey | __hbct_kxlat( nKey ) } ) + ENDIF + s_hTrs[ nOrgKeyValue ] := nNewKeyValue + ENDIF + ENDIF + hb_mutexUnlock( s_hMutex ) + ENDIF + ENDIF + ENDIF + + RETURN lAccepted + +FUNCTION hbct_getkxlat( nKeyValue ) + LOCAL nNewValue := 0 + + IF hb_isNumeric( nKeyValue ) + IF hb_mutexLock( s_hMutex ) + IF nKeyValue $ s_hTrs + nNewValue := s_hTrs[ nKeyValue ] + IF nNewValue == 0 + nNewValue := -1 + ENDIF + ENDIF + hb_mutexUnlock( s_hMutex ) + ENDIF + ENDIF + + RETURN nNewValue + +FUNCTION hbct_setkxtab( hTrs ) + LOCAL lAccepted := .F. + + IF hb_isHash( hTrs ) + IF hb_mutexLock( s_hMutex ) + IF hb_gtInfo( HB_GTI_INKEYFILTER ) == NIL .OR. ! Empty( s_hTrs ) + lAccepted := .T. + IF Empty( s_hTrs ) .AND. ! Empty( hTrs ) + hb_gtInfo( HB_GTI_INKEYFILTER, {| nKey | __hbct_kxlat( nKey ) } ) + ELSEIF ! Empty( s_hTrs ) .AND. Empty( hTrs ) + hb_gtInfo( HB_GTI_INKEYFILTER, NIL ) + ENDIF + hb_HClear( s_hTrs ) + hb_HCopy( hTrs, s_hTrs ) + ENDIF + hb_mutexUnlock( s_hMutex ) + ENDIF + ENDIF + + RETURN lAccepted + +FUNCTION hbct_getkxtab() + LOCAL xRetVal + + IF hb_mutexLock( s_hMutex ) + xRetVal := hb_HClone( s_hTrs ) + hb_mutexUnlock( s_hMutex ) + ENDIF + + RETURN xRetVal + +STATIC FUNCTION __hbct_kxlat( nKey ) + + IF hb_mutexLock( s_hMutex ) + nKey := hb_HGetDef( s_hTrs, nKey, nKey ) + hb_mutexUnlock( s_hMutex ) + ENDIF + + RETURN nKey diff --git a/harbour/contrib/hbct/screen2.c b/harbour/contrib/hbct/screen2.c index fb6449cb34..8875ae2d33 100644 --- a/harbour/contrib/hbct/screen2.c +++ b/harbour/contrib/hbct/screen2.c @@ -402,9 +402,9 @@ HB_FUNC( STRSCREEN ) } /* - * _HB_CTDSPTIME() is helper functions for SHOWTIME() + * __HBCT_DSPTIME() is helper functions for SHOWTIME() */ -HB_FUNC( _HB_CTDSPTIME ) +HB_FUNC( __HBCT_DSPTIME ) { int iRow, iCol; int iColor, iLen; diff --git a/harbour/contrib/hbct/showtime.prg b/harbour/contrib/hbct/showtime.prg index 2170826394..39aeed09e9 100644 --- a/harbour/contrib/hbct/showtime.prg +++ b/harbour/contrib/hbct/showtime.prg @@ -60,8 +60,8 @@ FUNCTION SHOWTIME( nRow, nCol, lNoSec, cColor, l12, lAmPm ) IF t_hTimer != NIL HB_IDLEDEL( t_hTimer ) ENDIF - t_hTimer := HB_IDLEADD( {|| _HB_CTDSPTIME( nRow, nCol, lNoSec, cColor, ; - l12, lAmPm ) } ) + t_hTimer := HB_IDLEADD( {|| __HBCT_DSPTIME( nRow, nCol, lNoSec, cColor, ; + l12, lAmPm ) } ) ELSEIF t_hTimer != NIL HB_IDLEDEL( t_hTimer ) t_hTimer := NIL diff --git a/harbour/include/hbcompdf.h b/harbour/include/hbcompdf.h index 0458ccb472..73c47932ae 100644 --- a/harbour/include/hbcompdf.h +++ b/harbour/include/hbcompdf.h @@ -321,6 +321,8 @@ typedef enum HB_F_WORD, HB_F_YEAR, + HB_F_BCHAR, + HB_F_BCODE, HB_F_BITAND, HB_F_BITOR, HB_F_BITXOR, diff --git a/harbour/include/hbexprb.c b/harbour/include/hbexprb.c index a6e75e3deb..797fbe7f0a 100644 --- a/harbour/include/hbexprb.c +++ b/harbour/include/hbexprb.c @@ -1793,6 +1793,15 @@ static HB_EXPR_FUNC( hb_compExprUseFunCall ) hb_compExprReduceCTOD( pSelf, HB_COMP_PARAM ); break; + case HB_F_BCHAR: + if( usCount ) + hb_compExprReduceBCHAR( pSelf, HB_COMP_PARAM ); + break; + case HB_F_BCODE: + if( usCount ) + hb_compExprReduceBCODE( pSelf, HB_COMP_PARAM ); + break; + case HB_F_BITAND: case HB_F_BITOR: case HB_F_BITXOR: diff --git a/harbour/include/hbexprop.h b/harbour/include/hbexprop.h index 776e680489..db9ccf33e1 100644 --- a/harbour/include/hbexprop.h +++ b/harbour/include/hbexprop.h @@ -188,8 +188,10 @@ extern HB_EXPORT_INT HB_EXPR_PTR hb_compExprReduceIIF( HB_EXPR_PTR, HB_COMP_DECL extern HB_EXPORT_INT HB_BOOL hb_compExprReduceAT( HB_EXPR_PTR, HB_COMP_DECL ); extern HB_EXPORT_INT HB_BOOL hb_compExprReduceCHR( HB_EXPR_PTR, HB_COMP_DECL ); +extern HB_EXPORT_INT HB_BOOL hb_compExprReduceBCHAR( HB_EXPR_PTR, HB_COMP_DECL ); extern HB_EXPORT_INT HB_BOOL hb_compExprReduceLEN( HB_EXPR_PTR, HB_COMP_DECL ); extern HB_EXPORT_INT HB_BOOL hb_compExprReduceASC( HB_EXPR_PTR, HB_COMP_DECL ); +extern HB_EXPORT_INT HB_BOOL hb_compExprReduceBCODE( HB_EXPR_PTR, HB_COMP_DECL ); extern HB_EXPORT_INT HB_BOOL hb_compExprReduceINT( HB_EXPR_PTR, HB_COMP_DECL ); extern HB_EXPORT_INT HB_BOOL hb_compExprReduceEMPTY( HB_EXPR_PTR, HB_COMP_DECL ); extern HB_EXPORT_INT HB_BOOL hb_compExprReduceSTOT( HB_EXPR_PTR, HB_USHORT usCount, HB_COMP_DECL ); diff --git a/harbour/src/common/expropt2.c b/harbour/src/common/expropt2.c index 7eca6e605c..82f43863a3 100644 --- a/harbour/src/common/expropt2.c +++ b/harbour/src/common/expropt2.c @@ -2036,6 +2036,39 @@ HB_BOOL hb_compExprReduceCHR( HB_EXPR_PTR pSelf, HB_COMP_DECL ) return HB_FALSE; } +HB_BOOL hb_compExprReduceBCHAR( HB_EXPR_PTR pSelf, HB_COMP_DECL ) +{ + HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms; + HB_EXPR_PTR pArg = pParms->value.asList.pExprList; + + if( pArg->ExprType == HB_ET_NUMERIC ) + { + HB_EXPR_PTR pExpr = HB_COMP_EXPR_NEW( HB_ET_STRING ); + + pExpr->ValType = HB_EV_STRING; + if( pArg->value.asNum.NumType == HB_ET_LONG ) + { + pExpr->value.asString.string = ( char * ) hb_szAscii[ ( int ) pArg->value.asNum.val.l & 0xff ]; + pExpr->value.asString.dealloc = HB_FALSE; + pExpr->nLength = 1; + } + else + { + pExpr->value.asString.string = ( char * ) hb_szAscii[ ( unsigned int ) pArg->value.asNum.val.d & 0xff ]; + pExpr->value.asString.dealloc = HB_FALSE; + pExpr->nLength = 1; + } + + HB_COMP_EXPR_FREE( pParms ); + HB_COMP_EXPR_FREE( pSelf->value.asFunCall.pFunName ); + memcpy( pSelf, pExpr, sizeof( HB_EXPR ) ); + HB_COMP_EXPR_CLEAR( pExpr ); + return HB_TRUE; + } + + return HB_FALSE; +} + HB_BOOL hb_compExprReduceLEN( HB_EXPR_PTR pSelf, HB_COMP_DECL ) { HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms; @@ -2142,6 +2175,25 @@ HB_BOOL hb_compExprReduceASC( HB_EXPR_PTR pSelf, HB_COMP_DECL ) return HB_FALSE; } +HB_BOOL hb_compExprReduceBCODE( HB_EXPR_PTR pSelf, HB_COMP_DECL ) +{ + HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms; + HB_EXPR_PTR pArg = pParms->value.asList.pExprList; + + if( pArg->ExprType == HB_ET_STRING ) + { + HB_EXPR_PTR pExpr = hb_compExprNewLong( + ( HB_UCHAR ) pArg->value.asString.string[0], HB_COMP_PARAM ); + + HB_COMP_EXPR_FREE( pParms ); + HB_COMP_EXPR_FREE( pSelf->value.asFunCall.pFunName ); + memcpy( pSelf, pExpr, sizeof( HB_EXPR ) ); + HB_COMP_EXPR_CLEAR( pExpr ); + return HB_TRUE; + } + return HB_FALSE; +} + HB_BOOL hb_compExprReduceINT( HB_EXPR_PTR pSelf, HB_COMP_DECL ) { HB_EXPR_PTR pParms = pSelf->value.asFunCall.pParms; diff --git a/harbour/src/common/funcid.c b/harbour/src/common/funcid.c index 65570968a8..9bd25e73cf 100644 --- a/harbour/src/common/funcid.c +++ b/harbour/src/common/funcid.c @@ -92,6 +92,8 @@ static _HB_FUNCID s_funcId[] = { "FLOCK", 4, HB_FN_RESERVED, HB_F_FLOCK }, { "FOUND", 4, HB_FN_RESERVED, HB_F_FOUND }, { "HB_ARRAYTOPARAMS", 0, HB_FN_UDF, HB_F_ARRAYTOPARAMS }, + { "HB_BCHAR", 0, HB_FN_UDF, HB_F_BCHAR }, + { "HB_BCODE", 0, HB_FN_UDF, HB_F_BCODE }, { "HB_BITAND", 0, HB_FN_UDF, HB_F_BITAND }, { "HB_BITNOT", 0, HB_FN_UDF, HB_F_BITNOT }, { "HB_BITOR", 0, HB_FN_UDF, HB_F_BITOR },