fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2006-06-14 13:05 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

Browse Source 
* harbour/config/linux/dir.cf
  * harbour/config/linux/gcc.cf
    * formatting

  * harbour/config/linux/global.cf
  * harbour/config/linux/install.cf
    * added -ldl to linked library list and RANLIB executing after library
      creation

  * harbour/contrib/ole/ole2.c
    * added #include "hbapicls.h"

  + harbour/include/hbapicls.h
  * harbour/include/hbapi.h
    + added HB_IT_ENUM item
    + added collect member to HB_IT_POINTER structure for POINTER items
      inspected by GC
    * changed the order of HB_CODEBLOCK members to safe few bytes on
      alignment
    * removed counters from HB_CODEBLOCK and HB_BASEARRAY structure
    + added hb_xRefInc(), hb_xRefDec(), hb_xRefFree(), hb_xRefCount(),
      hb_xRefResize() functions. They are internal Harbour VM functions
      and covered by internal API macro. Should not be used by 3-rd
      party code because we may change them in the future or even remove.
    + added hb_gcRefInc(), hb_gcRefDec(), hb_gcRefFree(), hb_gcRefCount()
      functions. These are also internal function which corresponds to the
      above hb_x*() ones.
    - removed hb_arrayRelease() function. This function is not longer
      necessary and it should never be public function - it was implemented
      in very dangerous way.
    - removed hb_codeblockDelete() function.
    - removed hb_memvarValueDecGarbageRef()
    + added USHORT usLen parameter to hb_codeblockMacroNew() - when sets
      to non 0 value it informs that PCODE should be copied to dynamically
      allocated buffer.
    * moved all classes/object functions to separate file: hbapicls.h
    + added hb_retptrGC()
    + added internal function hb_memvarGetItem()

  * harbour/include/hbapiitm.h
    - removed hb_itemForwardValue() and added macro which translates
      hb_itemForwardValue() to hb_itemMove()
    + added hb_itemUnShareString() and hb_itemReSizeString() functions
    + added hb_itemSetNil() macro

  * harbour/include/hbdefs.h
    * some cleanups in macro definitions

  * harbour/include/hbexprb.c
    * indenting

  * harbour/include/hbvm.h
  * harbour/include/hbinit.h
    + added hb_vmProcessSymbolsExt(), hb_vmRegisterSymbols(),
      hb_vmFreeSymbols(), hb_vmBeginSymbolGroup(),
      hb_vmInitSymbolGroup(), hb_vmExitSymbolGroup()
    * changed hb_vmProcessSymbols() to return address of register symbol
      table. For normal code it's the same address as given in parameter
      so it does not break backward binary compatibility.
    * changed symbol init macros to work correctly with modified address
      of symbol table

  * harbour/include/hbsetup.h
    * added support for HB_USE_PROFILER macro. Now profiler code is
      is disable in HVM by default
    * commented out HB_ASORT_OPT_ITEMCOPY - it's not longer used - see note.

  * harbour/include/hbstack.h
    * added missing parenthesis in hb_stackItem() macro

  * harbour/include/hbtypes.h
    * updated VM_PROCESS_DLL_SYMBOLS definition
    + added VM_PROCESS_SYMBOLS_EXT
    - removed HB_ARRAYRELEASE

  * harbour/include/hbver.h
    * changed revision number to 2

  * harbour/include/hbvmpub.h
    - remove pFunPtr from HB_DYNS and cover profiler member by
      #ifndef HB_NO_PROFILER
    + added HB_PCODEFUNC structure
    + added HB_FS_PCODEFUNC, HB_FS_DYNCODE and HB_FS_LOCAL - the last one
      is not used yet.

  * harbour/include/hbxvm.h
    * added some multipcode functions for some speed optimization in -gc3
      output

  * harbour/include/hbapicdp.h
  * harbour/source/codepage/cpbg866.c
  * harbour/source/codepage/cpbgiso.c
  * harbour/source/codepage/cpbgwin.c
  * harbour/source/codepage/cpeldos.c
  * harbour/source/codepage/cpelwin.c
  * harbour/source/codepage/cpesdos.c
  * harbour/source/codepage/cpesmwi.c
  * harbour/source/codepage/cpeswin.c
  * harbour/source/codepage/cpgedos.c
  * harbour/source/codepage/cpgewin.c
  * harbour/source/codepage/cphu852.c
  * harbour/source/codepage/cphuiso.c
  * harbour/source/codepage/cphuwin.c
  * harbour/source/codepage/cppl852.c
  * harbour/source/codepage/cppliso.c
  * harbour/source/codepage/cpplmaz.c
  * harbour/source/codepage/cpplwin.c
  * harbour/source/codepage/cppt850.c
  * harbour/source/codepage/cpptiso.c
  * harbour/source/codepage/cpru866.c
  * harbour/source/codepage/cprukoi.c
  * harbour/source/codepage/cpruwin.c
  * harbour/source/codepage/cpsl437.c
  * harbour/source/codepage/cpsl852.c
  * harbour/source/codepage/cpsliso.c
  * harbour/source/codepage/cpslwin.c
  * harbour/source/codepage/cpsrwin.c
  * harbour/source/common/hbfhnd.c
  * harbour/source/common/hbstr.c
  * harbour/source/common/hbver.c
  * harbour/source/compiler/gencli.c
  * harbour/source/rtl/fstemp.c
  * harbour/source/rtl/hbgtcore.c
  * harbour/source/rtl/langapi.c
  * harbour/source/rtl/gtalleg/gtalleg.c
  * harbour/source/rtl/gtalleg/ssf.h
  * harbour/source/rtl/gtcgi/gtcgi.c
  * harbour/source/rtl/gtcrs/gtcrs.c
  * harbour/source/rtl/gtdos/gtdos.c
  * harbour/source/rtl/gtos2/gtos2.c
  * harbour/source/rtl/gtpca/gtpca.c
  * harbour/source/rtl/gtsln/gtsln.c
  * harbour/source/rtl/gtstd/gtstd.c
  * harbour/source/rtl/gtwin/gtwin.c
  * harbour/source/rtl/gtwvt/gtwvt.c
  * harbour/source/rtl/gtxwc/gtxwc.c
    * cleaned the code to avoid warnings for some non ANSI C constructions

  * harbour/source/compiler/cmdcheck.c
    * formatting

  * harbour/source/compiler/gencc.c
    * added some multipcode optimizations

  * harbour/source/compiler/genc.c
    * keep function name set by compiler for static initstatics

  * harbour/source/compiler/harbour.c
    * extend init statics name with the number of used static variables
    * formatting

  * harbour/source/compiler/hbusage.c
    + added my name to developers list - I hope that there is enough
      of my code in Harbour (BTW for quite long time) ;-)

  * harbour/source/rdd/dbcmd.c
    - removed DBF2TEXT() function

  * harbour/source/rdd/dbf1.c
  * harbour/source/rdd/dbffpt/dbffpt1.c
    * generate RT error when someone tries to create DBF with memo fields
      without MEMO RDD linked.

  * harbour/source/rtl/errorapi.c
    * replace all hb_vmDo() with hb_vmSend()

  * harbour/source/rtl/math.c
    * use hb_errPutArgs() to pass parameters to error object

  * harbour/source/rtl/philes.c
  * harbour/source/rtl/space.c
  * harbour/source/rtl/strpeek.c
    * some minor optimizations

  * harbour/source/vm/arrays.c
    - removed hb_arrayRelease() function.
    * changed hb_arrayReleaseGarbage() to be safe for recursive call
    * updated to use GC counters

  * harbour/source/vm/arrayshb.c
    * use stack function/macros instead of direct accessing HB_STACK members

  * harbour/source/vm/asort.c
    * removed unused HB_ASORT_OPT_ITEMCOPY

  * harbour/source/vm/classes.c
    * added class code from HVM
    % added fast overloaded operator detection and execution
    + added hb_objHasOperator(), hb_objOperatorCall()
    + added separated overloading of "=" and "==" operators
    * operate on PHB_SYMB not PHB_FUNC - support for pure PCODE function
      without any machine code
    * use stack function/macros instead of direct accessing HB_STACK members
    * separated profiler code
    * some code cleaning

  * harbour/source/vm/codebloc.c
    + added USHORT usLen parameter to hb_codeblockMacroNew() - when sets
      to non 0 value it informs that PCODE should be copied to dynamically
      allocated buffer.
    * updated to use GC counters
    - removed hb_codeblockDelete() function.
    * changed hb_codeblockDeleteGarbage() to be safe for recursive call
    - removed restoring statics base in hb_codeblockEvaluate()

  * harbour/source/vm/debug.c
    * cleaned and optimized some code

  * harbour/source/vm/dynlibhb.c
    + added support for loading and unloading dynamic libraries with PCODE
    + added support for dynamic libraries in Linux (.so)
    + added HB_LIBERROR() - returns error string with last error in
      HB_LIBLOAD() - now works only in Linux

  * harbour/source/vm/dynsym.c
    * separated profiler code
    + use pDynSym->pSymbol->value.pFunPtr instead of pDynSym->pFunPtr

  * harbour/source/vm/estack.c
    + added #include "hbapicls.h"
    + added hb_stackPushReturn(), hb_stackPopReturn()

  * harbour/source/vm/eval.c
  * harbour/source/vm/extend.c
    * use stack function/macros instead of direct accessing HB_STACK members
    + added hb_retptrGC()

  * harbour/source/vm/fm.c
    + added hb_xRefInc(), hb_xRefDec(), hb_xRefFree(), hb_xRefCount(),
      hb_xRefResize() functions. They are internal Harbour VM functions
      and covered by internal API macro. Should not be used by 3-rd
      party code because we may change them in the future or even remove.

  * harbour/source/vm/garbage.c
    + added hb_gcRefInc(), hb_gcRefDec(), hb_gcRefFree(), hb_gcRefCount()
      functions. These are also internal function which corresponds to the
      above hb_x*() ones.
    * changed Step 3 of GC pass and execution of clean-up function to be
      safe for recursive calls and additional activity.
      Ryszard see my note and s_pDeletedBlock
    + added GC inspected HB_IT_POINTER items.

  * harbour/source/vm/hvm.c
    * separated profiler code
    * separated class code from HVM
    + added support for loading and unloading libraries with PCODE modules
    + added support for pure PCODE functions
    + added support for string item resizing and preallocating string buffer
    + added some new multipcode functions for -gc3 optimization
    + added hb_vmProcessSymbolsExt(), hb_vmRegisterSymbols(),
      hb_vmFreeSymbols(), hb_vmBeginSymbolGroup(),
      hb_vmInitSymbolGroup(), hb_vmExitSymbolGroup()
    * changed hb_vmProcessSymbols() to return address of register symbol
      table. For normal code it's the same address as given in parameter
      so it does not break backward binary compatibility.
    + use new code for operator overloading
    * changed FOR EACH to dynamically check iteration scope in
      hb_vmEnumNext()/hb_vmEnumPrev() and remove max number of iteration
      stored on HVM stack
    * temporary use hb_itemUnRefOnce() instead of hb_itemUnRefRefer() as
      workaround for possible GPF. I'd like Ryszard will chose the final
      version

  * harbour/source/vm/itemapi.c
    + added support for preallocating string buffer size
    + added hb_itemUnShareString() and hb_itemReSizeString()
    * updated string items to use counters allocated with each
      memory block by xh_xgrab()/hb_xalloc()
    * updated codeblock and array items to use GC reference counters
    + added GC inspected HB_IT_POINTER items.
    * generate RT error in hb_itemUnreOnce() for enumerator items
      out of scope
    + added hb_itemPutPtrGC()

  * harbour/source/vm/macro.c
    * use pDynSym->pSymbol->value.pFunPtr instead of pDynSym->pFunPtr

  * harbour/source/vm/maindllp.c
    * updated usage of hb_vmProcessSymbols()
    * added hb_vmProcessSymbolsExt()

  * harbour/source/vm/memvars.c
    + added hb_memvarGetItem()
    - removed hb_memvarValueDecGarbageRef()

  * harbour/source/vm/proc.c
    + added #include "hbapicls.h"

  * harbour/source/vm/pvalue.c
    * do not access stack structure directly but use hb_stack*()
      functions (macros)

  * harbour/source/vm/runner.c
    * synced with xHarbour

  * harbour/utils/hbtest/rt_misc.prg
   * added overloading "=" operator. Now "==" and "=" can be overloaded
     with different methods

   All names I used for new functions/macros can be changed. Please look at
   it and if you will some better propositions then we can use it.
   hb_vmProcessSymbolsExt() is added but not used yet.
This commit is contained in:
Przemyslaw Czerpak
2006-06-14 11:21:26 +00:00
parent 35ca6dae33
commit 917c8057e6
101 changed files with 4920 additions and 3516 deletions
Download Patch File Download Diff File Expand all files Collapse all files

304
harbour/ChangeLog
View File

@@ -8,6 +8,310 @@
2002-12-01 13:30 UTC+0100 Foo Bar <foo.bar@foobar.org>
*/
* generate Clipper compatible error messages for EG_NO[VAR]METHOD
and EG_NOFUNC. Please do not change it. If you want previous Harbour
error messages for EG_NO[VAR]METHOD then please change __msgNoMethod
in classy.c
* harbour/source/vm/arrays.c
* minor modification
2006-06-14 13:30 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/include/hbapiitm.h
+ added missing declaration of hb_itemPutPtrGC()
2006-06-14 13:05 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/config/linux/dir.cf
* harbour/config/linux/gcc.cf
* formatting
* harbour/config/linux/global.cf
* harbour/config/linux/install.cf
* added -ldl to linked library list and RANLIB executing after library
creation
* harbour/contrib/ole/ole2.c
* added #include "hbapicls.h"
+ harbour/include/hbapicls.h
* harbour/include/hbapi.h
+ added HB_IT_ENUM item
+ added collect member to HB_IT_POINTER structure for POINTER items
inspected by GC
* changed the order of HB_CODEBLOCK members to safe few bytes on
alignment
* removed counters from HB_CODEBLOCK and HB_BASEARRAY structure
+ added hb_xRefInc(), hb_xRefDec(), hb_xRefFree(), hb_xRefCount(),
hb_xRefResize() functions. They are internal Harbour VM functions
and covered by internal API macro. Should not be used by 3-rd
party code because we may change them in the future or even remove.
+ added hb_gcRefInc(), hb_gcRefDec(), hb_gcRefFree(), hb_gcRefCount()
functions. These are also internal function which corresponds to the
above hb_x*() ones.
- removed hb_arrayRelease() function. This function is not longer
necessary and it should never be public function - it was implemented
in very dangerous way.
- removed hb_codeblockDelete() function.
- removed hb_memvarValueDecGarbageRef()
+ added USHORT usLen parameter to hb_codeblockMacroNew() - when sets
to non 0 value it informs that PCODE should be copied to dynamically
allocated buffer.
* moved all classes/object functions to separate file: hbapicls.h
+ added hb_retptrGC()
+ added internal function hb_memvarGetItem()
* harbour/include/hbapiitm.h
- removed hb_itemForwardValue() and added macro which translates
hb_itemForwardValue() to hb_itemMove()
+ added hb_itemUnShareString() and hb_itemReSizeString() functions
+ added hb_itemSetNil() macro
* harbour/include/hbdefs.h
* some cleanups in macro definitions
* harbour/include/hbexprb.c
* indenting
* harbour/include/hbvm.h
* harbour/include/hbinit.h
+ added hb_vmProcessSymbolsExt(), hb_vmRegisterSymbols(),
hb_vmFreeSymbols(), hb_vmBeginSymbolGroup(),
hb_vmInitSymbolGroup(), hb_vmExitSymbolGroup()
* changed hb_vmProcessSymbols() to return address of register symbol
table. For normal code it's the same address as given in parameter
so it does not break backward binary compatibility.
* changed symbol init macros to work correctly with modified address
of symbol table
* harbour/include/hbsetup.h
* added support for HB_USE_PROFILER macro. Now profiler code is
is disable in HVM by default
* commented out HB_ASORT_OPT_ITEMCOPY - it's not longer used - see note.
* harbour/include/hbstack.h
* added missing parenthesis in hb_stackItem() macro
* harbour/include/hbtypes.h
* updated VM_PROCESS_DLL_SYMBOLS definition
+ added VM_PROCESS_SYMBOLS_EXT
- removed HB_ARRAYRELEASE
* harbour/include/hbver.h
* changed revision number to 2
* harbour/include/hbvmpub.h
- remove pFunPtr from HB_DYNS and cover profiler member by
#ifndef HB_NO_PROFILER
+ added HB_PCODEFUNC structure
+ added HB_FS_PCODEFUNC, HB_FS_DYNCODE and HB_FS_LOCAL - the last one
is not used yet.
* harbour/include/hbxvm.h
* added some multipcode functions for some speed optimization in -gc3
output
* harbour/include/hbapicdp.h
* harbour/source/codepage/cpbg866.c
* harbour/source/codepage/cpbgiso.c
* harbour/source/codepage/cpbgwin.c
* harbour/source/codepage/cpeldos.c
* harbour/source/codepage/cpelwin.c
* harbour/source/codepage/cpesdos.c
* harbour/source/codepage/cpesmwi.c
* harbour/source/codepage/cpeswin.c
* harbour/source/codepage/cpgedos.c
* harbour/source/codepage/cpgewin.c
* harbour/source/codepage/cphu852.c
* harbour/source/codepage/cphuiso.c
* harbour/source/codepage/cphuwin.c
* harbour/source/codepage/cppl852.c
* harbour/source/codepage/cppliso.c
* harbour/source/codepage/cpplmaz.c
* harbour/source/codepage/cpplwin.c
* harbour/source/codepage/cppt850.c
* harbour/source/codepage/cpptiso.c
* harbour/source/codepage/cpru866.c
* harbour/source/codepage/cprukoi.c
* harbour/source/codepage/cpruwin.c
* harbour/source/codepage/cpsl437.c
* harbour/source/codepage/cpsl852.c
* harbour/source/codepage/cpsliso.c
* harbour/source/codepage/cpslwin.c
* harbour/source/codepage/cpsrwin.c
* harbour/source/common/hbfhnd.c
* harbour/source/common/hbstr.c
* harbour/source/common/hbver.c
* harbour/source/compiler/gencli.c
* harbour/source/rtl/fstemp.c
* harbour/source/rtl/hbgtcore.c
* harbour/source/rtl/langapi.c
* harbour/source/rtl/gtalleg/gtalleg.c
* harbour/source/rtl/gtalleg/ssf.h
* harbour/source/rtl/gtcgi/gtcgi.c
* harbour/source/rtl/gtcrs/gtcrs.c
* harbour/source/rtl/gtdos/gtdos.c
* harbour/source/rtl/gtos2/gtos2.c
* harbour/source/rtl/gtpca/gtpca.c
* harbour/source/rtl/gtsln/gtsln.c
* harbour/source/rtl/gtstd/gtstd.c
* harbour/source/rtl/gtwin/gtwin.c
* harbour/source/rtl/gtwvt/gtwvt.c
* harbour/source/rtl/gtxwc/gtxwc.c
* cleaned the code to avoid warnings for some non ANSI C constructions
* harbour/source/compiler/cmdcheck.c
* formatting
* harbour/source/compiler/gencc.c
* added some multipcode optimizations
* formatting
* keep function name set by compiler for static initstatics
* harbour/source/compiler/harbour.c
* extend init statics name with the number of used static variables
* formatting
* harbour/source/compiler/hbusage.c
+ added my name to developers list - I hope that there is enough
of my code in Harbour (BTW for quite long time) ;-)
* harbour/source/rdd/dbcmd.c
- removed DBF2TEXT() function
* harbour/source/rdd/dbf1.c
* harbour/source/rdd/dbffpt/dbffpt1.c
* generate RT error when someone tries to create DBF with memo fields
without MEMO RDD linked.
* harbour/source/rtl/errorapi.c
* replace all hb_vmDo() with hb_vmSend()
* harbour/source/rtl/math.c
* use hb_errPutArgs() to pass parameters to error object
* harbour/source/rtl/philes.c
* harbour/source/rtl/space.c
* harbour/source/rtl/strpeek.c
* some minor optimizations
* harbour/source/vm/arrays.c
- removed hb_arrayRelease() function.
* changed hb_arrayReleaseGarbage() to be safe for recursive call
* updated to use GC counters
* harbour/source/vm/arrayshb.c
* use stack function/macros instead of direct accessing HB_STACK members
* harbour/source/vm/asort.c
* removed unused HB_ASORT_OPT_ITEMCOPY
* harbour/source/vm/classes.c
* added class code from HVM
% added fast overloaded operator detection and execution
+ added hb_objHasOperator(), hb_objOperatorCall()
+ added separated overloading of "=" and "==" operators
* operate on PHB_SYMB not PHB_FUNC - support for pure PCODE function
without any machine code
* use stack function/macros instead of direct accessing HB_STACK members
* separated profiler code
* some code cleaning
* harbour/source/vm/codebloc.c
+ added USHORT usLen parameter to hb_codeblockMacroNew() - when sets
to non 0 value it informs that PCODE should be copied to dynamically
allocated buffer.
* updated to use GC counters
- removed hb_codeblockDelete() function.
* changed hb_codeblockDeleteGarbage() to be safe for recursive call
- removed restoring statics base in hb_codeblockEvaluate()
* harbour/source/vm/debug.c
* cleaned and optimized some code
* harbour/source/vm/dynlibhb.c
+ added support for loading and unloading dynamic libraries with PCODE
+ added support for dynamic libraries in Linux (.so)
+ added HB_LIBERROR() - returns error string with last error in
HB_LIBLOAD() - now works only in Linux
* harbour/source/vm/dynsym.c
* separated profiler code
+ use pDynSym->pSymbol->value.pFunPtr instead of pDynSym->pFunPtr
* harbour/source/vm/estack.c
+ added #include "hbapicls.h"
+ added hb_stackPushReturn(), hb_stackPopReturn()
* harbour/source/vm/eval.c
* harbour/source/vm/extend.c
* use stack function/macros instead of direct accessing HB_STACK members
+ added hb_retptrGC()
* harbour/source/vm/fm.c
+ added hb_xRefInc(), hb_xRefDec(), hb_xRefFree(), hb_xRefCount(),
hb_xRefResize() functions. They are internal Harbour VM functions
and covered by internal API macro. Should not be used by 3-rd
party code because we may change them in the future or even remove.
* harbour/source/vm/garbage.c
+ added hb_gcRefInc(), hb_gcRefDec(), hb_gcRefFree(), hb_gcRefCount()
functions. These are also internal function which corresponds to the
above hb_x*() ones.
* changed Step 3 of GC pass and execution of clean-up function to be
safe for recursive calls and additional activity.
Ryszard see my note and s_pDeletedBlock
+ added GC inspected HB_IT_POINTER items.
* harbour/source/vm/hvm.c
* separated profiler code
* separated class code from HVM
+ added support for loading and unloading libraries with PCODE modules
+ added support for pure PCODE functions
+ added support for string item resizing and preallocating string buffer
+ added some new multipcode functions for -gc3 optimization
+ added hb_vmProcessSymbolsExt(), hb_vmRegisterSymbols(),
hb_vmFreeSymbols(), hb_vmBeginSymbolGroup(),
hb_vmInitSymbolGroup(), hb_vmExitSymbolGroup()
* changed hb_vmProcessSymbols() to return address of register symbol
table. For normal code it's the same address as given in parameter
so it does not break backward binary compatibility.
+ use new code for operator overloading
* changed FOR EACH to dynamically check iteration scope in
hb_vmEnumNext()/hb_vmEnumPrev() and remove max number of iteration
stored on HVM stack
* temporary use hb_itemUnRefOnce() instead of hb_itemUnRefRefer() as
workaround for possible GPF. I'd like Ryszard will chose the final
version
* harbour/source/vm/itemapi.c
+ added support for preallocating string buffer size
+ added hb_itemUnShareString() and hb_itemReSizeString()
* updated string items to use counters allocated with each
memory block by xh_xgrab()/hb_xalloc()
* updated codeblock and array items to use GC reference counters
+ added GC inspected HB_IT_POINTER items.
* generate RT error in hb_itemUnreOnce() for enumerator items
out of scope
+ added hb_itemPutPtrGC()
* harbour/source/vm/macro.c
* use pDynSym->pSymbol->value.pFunPtr instead of pDynSym->pFunPtr
* harbour/source/vm/maindllp.c
* updated usage of hb_vmProcessSymbols()
* added hb_vmProcessSymbolsExt()
* harbour/source/vm/memvars.c
+ added hb_memvarGetItem()
- removed hb_memvarValueDecGarbageRef()
* harbour/source/vm/proc.c
+ added #include "hbapicls.h"
* harbour/source/vm/pvalue.c
* do not access stack structure directly but use hb_stack*()
functions (macros)
* harbour/source/vm/runner.c
* synced with xHarbour

2
harbour/config/linux/dir.cf
View File

@@ -11,4 +11,4 @@ DIR_RULE =\
fi \
done
endif # ! compiling a specific program module
endif # ! compiling a specific program module

6
harbour/config/linux/gcc.cf
View File

@@ -23,7 +23,7 @@ CPPFLAGS = -I. -I$(HB_INC_COMPILE)
# We are under linux
CFLAGS = -DHB_OS_LINUX -Wall -W -fsigned-char
# uncomment this if you want to farce relocateable code for .so libs
# uncomment this if you want to force relocateable code for .so libs
# it's necessary on some platforms but can reduce performance
#CFLAGS += -fPIC
@@ -106,12 +106,12 @@ endif
endif
LINKLIBS += -lm -Wl,--end-group
LINKLIBS += -lm -ldl -Wl,--end-group
LDFLAGS = $(LINKPATHS)
AR = ar
ARFLAGS = $(A_USR)
AR_RULE = $(AR) $(ARFLAGS) cr $@ $(^F) || $(RM) $@
AR_RULE = $(AR) $(ARFLAGS) cr $@ $(^F) && $(RANLIB) $@ || ( $(RM) $@ && false )
include $(TOP)$(ROOT)config/rules.cf

1
harbour/config/linux/global.cf
View File

@@ -37,6 +37,7 @@ CP = cp -f
MV = mv -f
MD = mkdir
MDP = mkdir -p
RANLIB = ranlib
dirbase::
@[ -d $(ARCH_DIR) ] || $(MDP) $(ARCH_DIR)

1
harbour/config/linux/install.cf
View File

@@ -18,4 +18,3 @@ INSTALL_RULE =\
fi \
done \
fi

1
harbour/contrib/ole/ole2.c
View File

@@ -80,6 +80,7 @@
#include "hbvm.h"
#include "hbapiitm.h"
#include "hbapicls.h"
#include "hbdate.h"
static far VARIANTARG RetVal;

335
harbour/include/hbapi.h
View File

@@ -74,27 +74,28 @@ HB_EXTERN_BEGIN
/* items types and type checking macros */
#define HB_IT_NIL ( ( HB_TYPE ) 0x0000 )
#define HB_IT_POINTER ( ( HB_TYPE ) 0x0001 )
#define HB_IT_INTEGER ( ( HB_TYPE ) 0x0002 )
#define HB_IT_LONG ( ( HB_TYPE ) 0x0008 )
#define HB_IT_DOUBLE ( ( HB_TYPE ) 0x0010 )
#define HB_IT_DATE ( ( HB_TYPE ) 0x0020 )
#define HB_IT_LOGICAL ( ( HB_TYPE ) 0x0080 )
#define HB_IT_SYMBOL ( ( HB_TYPE ) 0x0100 )
#define HB_IT_ALIAS ( ( HB_TYPE ) 0x0200 )
#define HB_IT_STRING ( ( HB_TYPE ) 0x0400 )
#define HB_IT_MEMOFLAG ( ( HB_TYPE ) 0x0800 )
#define HB_IT_NIL ( ( HB_TYPE ) 0x00000 )
#define HB_IT_POINTER ( ( HB_TYPE ) 0x00001 )
#define HB_IT_INTEGER ( ( HB_TYPE ) 0x00002 )
#define HB_IT_LONG ( ( HB_TYPE ) 0x00008 )
#define HB_IT_DOUBLE ( ( HB_TYPE ) 0x00010 )
#define HB_IT_DATE ( ( HB_TYPE ) 0x00020 )
#define HB_IT_LOGICAL ( ( HB_TYPE ) 0x00080 )
#define HB_IT_SYMBOL ( ( HB_TYPE ) 0x00100 )
#define HB_IT_ALIAS ( ( HB_TYPE ) 0x00200 )
#define HB_IT_STRING ( ( HB_TYPE ) 0x00400 )
#define HB_IT_MEMOFLAG ( ( HB_TYPE ) 0x00800 )
#define HB_IT_MEMO ( HB_IT_MEMOFLAG | HB_IT_STRING )
#define HB_IT_BLOCK ( ( HB_TYPE ) 0x1000 )
#define HB_IT_BYREF ( ( HB_TYPE ) 0x2000 )
#define HB_IT_MEMVAR ( ( HB_TYPE ) 0x4000 )
#define HB_IT_ARRAY ( ( HB_TYPE ) 0x8000 )
#define HB_IT_BLOCK ( ( HB_TYPE ) 0x01000 )
#define HB_IT_BYREF ( ( HB_TYPE ) 0x02000 )
#define HB_IT_MEMVAR ( ( HB_TYPE ) 0x04000 )
#define HB_IT_ARRAY ( ( HB_TYPE ) 0x08000 )
#define HB_IT_ENUM ( ( HB_TYPE ) 0x10000 )
#define HB_IT_OBJECT HB_IT_ARRAY
#define HB_IT_NUMERIC ( ( HB_TYPE ) ( HB_IT_INTEGER | HB_IT_LONG | HB_IT_DOUBLE ) )
#define HB_IT_NUMINT ( ( HB_TYPE ) ( HB_IT_INTEGER | HB_IT_LONG ) )
#define HB_IT_ANY ( ( HB_TYPE ) 0xFFFFFFFF )
#define HB_IT_COMPLEX ( ( HB_TYPE ) ( HB_IT_STRING | HB_IT_BLOCK | HB_IT_ARRAY | HB_IT_MEMVAR | HB_IT_BYREF ) )
#define HB_IT_COMPLEX ( ( HB_TYPE ) ( HB_IT_BLOCK | HB_IT_ARRAY | HB_IT_POINTER | HB_IT_MEMVAR | HB_IT_ENUM | HB_IT_STRING ) )
#define HB_IT_GCITEM ( ( HB_TYPE ) ( HB_IT_BLOCK | HB_IT_ARRAY | HB_IT_POINTER | HB_IT_BYREF ) )
#if 0
@@ -119,27 +120,28 @@ HB_EXTERN_BEGIN
* x86 machines they can safe few CPU cycles. [druzus]
*/
#define HB_IS_NIL( p ) HB_IS_OF_TYPE( p, HB_IT_NIL )
#define HB_IS_ARRAY( p ) HB_IS_OF_TYPE( p, HB_IT_ARRAY )
#define HB_IS_BLOCK( p ) HB_IS_OF_TYPE( p, HB_IT_BLOCK )
#define HB_IS_DATE( p ) HB_IS_OF_TYPE( p, HB_IT_DATE )
#define HB_IS_DOUBLE( p ) HB_IS_OF_TYPE( p, HB_IT_DOUBLE )
#define HB_IS_INTEGER( p ) HB_IS_OF_TYPE( p, HB_IT_INTEGER )
#define HB_IS_LOGICAL( p ) HB_IS_OF_TYPE( p, HB_IT_LOGICAL )
#define HB_IS_LONG( p ) HB_IS_OF_TYPE( p, HB_IT_LONG )
#define HB_IS_SYMBOL( p ) HB_IS_OF_TYPE( p, HB_IT_SYMBOL )
#define HB_IS_POINTER( p ) HB_IS_OF_TYPE( p, HB_IT_POINTER )
#define HB_IS_MEMVAR( p ) HB_IS_OF_TYPE( p, HB_IT_MEMVAR )
#define HB_IS_MEMO( p ) HB_IS_OF_TYPE( p, HB_IT_MEMO )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & ~( HB_IT_BYREF | HB_IT_MEMOFLAG ) ) == HB_IT_STRING )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BYREF ) != 0 )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#define HB_IS_NIL( p ) HB_IS_OF_TYPE( p, HB_IT_NIL )
#define HB_IS_ARRAY( p ) HB_IS_OF_TYPE( p, HB_IT_ARRAY )
#define HB_IS_BLOCK( p ) HB_IS_OF_TYPE( p, HB_IT_BLOCK )
#define HB_IS_DATE( p ) HB_IS_OF_TYPE( p, HB_IT_DATE )
#define HB_IS_DOUBLE( p ) HB_IS_OF_TYPE( p, HB_IT_DOUBLE )
#define HB_IS_INTEGER( p ) HB_IS_OF_TYPE( p, HB_IT_INTEGER )
#define HB_IS_LOGICAL( p ) HB_IS_OF_TYPE( p, HB_IT_LOGICAL )
#define HB_IS_LONG( p ) HB_IS_OF_TYPE( p, HB_IT_LONG )
#define HB_IS_SYMBOL( p ) HB_IS_OF_TYPE( p, HB_IT_SYMBOL )
#define HB_IS_POINTER( p ) HB_IS_OF_TYPE( p, HB_IT_POINTER )
#define HB_IS_MEMVAR( p ) HB_IS_OF_TYPE( p, HB_IT_MEMVAR )
#define HB_IS_MEMO( p ) HB_IS_OF_TYPE( p, HB_IT_MEMO )
#define HB_IS_ENUM( p ) HB_IS_OF_TYPE( p, HB_IT_ENUM )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & ~( HB_IT_BYREF | HB_IT_MEMOFLAG ) ) == HB_IT_STRING )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BYREF ) != 0 )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#elif 0
@@ -148,54 +150,56 @@ HB_EXTERN_BEGIN
* they are the safest one in buggy code which may produce wrong item
* signatures but also they can be slower on some machines
*/
#define HB_IS_NIL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_NIL )
#define HB_IS_ARRAY( p ) ( HB_ITEM_TYPE( p ) == HB_IT_ARRAY )
#define HB_IS_BLOCK( p ) ( HB_ITEM_TYPE( p ) == HB_IT_BLOCK )
#define HB_IS_DATE( p ) ( HB_ITEM_TYPE( p ) == HB_IT_DATE )
#define HB_IS_DOUBLE( p ) ( HB_ITEM_TYPE( p ) == HB_IT_DOUBLE )
#define HB_IS_INTEGER( p ) ( HB_ITEM_TYPE( p ) == HB_IT_INTEGER )
#define HB_IS_LOGICAL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_LOGICAL )
#define HB_IS_LONG( p ) ( HB_ITEM_TYPE( p ) == HB_IT_LONG )
#define HB_IS_SYMBOL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_SYMBOL )
#define HB_IS_POINTER( p ) ( HB_ITEM_TYPE( p ) == HB_IT_POINTER )
#define HB_IS_MEMO( p ) ( HB_ITEM_TYPE( p ) == HB_IT_MEMO )
#define HB_IS_MEMVAR( p ) ( HB_ITEM_TYPE( p ) == ( HB_IT_MEMVAR | HB_IT_BYREF ) )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & ~HB_IT_MEMOFLAG ) == HB_IT_STRING )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & ~HB_IT_MEMVAR ) == HB_IT_BYREF )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#define HB_IS_NIL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_NIL )
#define HB_IS_ARRAY( p ) ( HB_ITEM_TYPE( p ) == HB_IT_ARRAY )
#define HB_IS_BLOCK( p ) ( HB_ITEM_TYPE( p ) == HB_IT_BLOCK )
#define HB_IS_DATE( p ) ( HB_ITEM_TYPE( p ) == HB_IT_DATE )
#define HB_IS_DOUBLE( p ) ( HB_ITEM_TYPE( p ) == HB_IT_DOUBLE )
#define HB_IS_INTEGER( p ) ( HB_ITEM_TYPE( p ) == HB_IT_INTEGER )
#define HB_IS_LOGICAL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_LOGICAL )
#define HB_IS_LONG( p ) ( HB_ITEM_TYPE( p ) == HB_IT_LONG )
#define HB_IS_SYMBOL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_SYMBOL )
#define HB_IS_POINTER( p ) ( HB_ITEM_TYPE( p ) == HB_IT_POINTER )
#define HB_IS_MEMO( p ) ( HB_ITEM_TYPE( p ) == HB_IT_MEMO )
#define HB_IS_MEMVAR( p ) ( HB_ITEM_TYPE( p ) == ( HB_IT_MEMVAR | HB_IT_BYREF ) )
#define HB_IS_ENUM( p ) ( HB_ITEM_TYPE( p ) == ( HB_IT_ENUM | HB_IT_BYREF ) )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & ~HB_IT_MEMOFLAG ) == HB_IT_STRING )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & ~HB_IT_MEMVAR ) == HB_IT_BYREF )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#else
/*
* these ones are can be the most efficiently optimized on some CPUs
*/
#define HB_IS_NIL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_NIL )
#define HB_IS_ARRAY( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_ARRAY ) != 0 )
#define HB_IS_BLOCK( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BLOCK ) != 0 )
#define HB_IS_DATE( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_DATE ) != 0 )
#define HB_IS_DOUBLE( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_DOUBLE ) != 0 )
#define HB_IS_INTEGER( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_INTEGER ) != 0 )
#define HB_IS_LOGICAL( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_LOGICAL ) != 0 )
#define HB_IS_LONG( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_LONG ) != 0 )
#define HB_IS_SYMBOL( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_SYMBOL ) != 0 )
#define HB_IS_POINTER( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_POINTER ) != 0 )
#define HB_IS_MEMO( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_MEMOFLAG ) != 0 )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_STRING ) != 0 )
#define HB_IS_MEMVAR( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_MEMVAR ) != 0 )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BYREF ) != 0 )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#define HB_IS_NIL( p ) ( HB_ITEM_TYPE( p ) == HB_IT_NIL )
#define HB_IS_ARRAY( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_ARRAY ) != 0 )
#define HB_IS_BLOCK( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BLOCK ) != 0 )
#define HB_IS_DATE( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_DATE ) != 0 )
#define HB_IS_DOUBLE( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_DOUBLE ) != 0 )
#define HB_IS_INTEGER( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_INTEGER ) != 0 )
#define HB_IS_LOGICAL( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_LOGICAL ) != 0 )
#define HB_IS_LONG( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_LONG ) != 0 )
#define HB_IS_SYMBOL( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_SYMBOL ) != 0 )
#define HB_IS_POINTER( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_POINTER ) != 0 )
#define HB_IS_MEMO( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_MEMOFLAG ) != 0 )
#define HB_IS_STRING( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_STRING ) != 0 )
#define HB_IS_MEMVAR( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_MEMVAR ) != 0 )
#define HB_IS_ENUM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_ENUM ) != 0 )
#define HB_IS_BYREF( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_BYREF ) != 0 )
#define HB_IS_NUMERIC( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMERIC ) != 0 )
#define HB_IS_NUMINT( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_NUMINT ) != 0 )
#define HB_IS_COMPLEX( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 )
#define HB_IS_GCITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_GCITEM ) != 0 )
#define HB_IS_BADITEM( p ) ( ( HB_ITEM_TYPE( p ) & HB_IT_COMPLEX ) != 0 && ( HB_ITEM_TYPE( p ) & ~( HB_IT_COMPLEX | HB_IT_MEMOFLAG ) ) != 0 )
#define HB_IS_OBJECT( p ) ( HB_IS_ARRAY( p ) && HB_OBJ_CLASS( p ) != 0 )
#define HB_IS_NUMBER( p ) HB_IS_NUMERIC( p )
#endif
@@ -265,42 +269,42 @@ struct hb_struLong
HB_LONG value;
};
struct hb_struPointer
{
void * value;
BOOL collect;
};
struct hb_struMemvar
{
struct _HB_VALUE ** itemsbase;
LONG value;
};
struct hb_struPointer
{
void * value;
};
struct hb_struRefer
{
union {
struct _HB_CODEBLOCK * block; /* codeblock */
struct _HB_ITEM * itemPtr; /* item pointer */
struct _HB_ITEM ** itemsbase; /* static variables */
struct _HB_ITEM ** *itemsbasePtr; /* local variables */
struct _HB_CODEBLOCK * block; /* codeblock */
struct _HB_ITEM * itemPtr; /* item pointer */
struct _HB_ITEM ** itemsbase; /* static variables */
struct _HB_ITEM ** *itemsbasePtr; /* local variables */
} BasePtr;
LONG offset; /* 0 for static variables */
LONG offset; /* 0 for static variables */
LONG value;
union {
struct _HB_ITEM * itemPtr; /* item pointer */
} ValuePtr;
};
struct hb_struEnum
{
struct _HB_ITEM * basePtr; /* base item pointer */
struct _HB_ITEM * valuePtr; /* value item pointer */
LONG offset;
};
struct hb_struString
{
ULONG length;
ULONG allocated; /* size of memory block allocated for string value, 0 for static strings */
char * value;
SHORT bStatic; /* it is a static string from pcode or from a C string */
union
{
char value[1];
HB_COUNTER * pulHolders; /* number of holders of this string */
} u;
};
struct hb_struSymbol
@@ -317,18 +321,19 @@ typedef struct _HB_ITEM
HB_TYPE type;
union
{
struct hb_struArray asArray;
struct hb_struBlock asBlock;
struct hb_struDate asDate;
struct hb_struDouble asDouble;
struct hb_struInteger asInteger;
struct hb_struLogical asLogical;
struct hb_struLong asLong;
struct hb_struMemvar asMemvar;
struct hb_struPointer asPointer;
struct hb_struRefer asRefer;
struct hb_struString asString;
struct hb_struSymbol asSymbol;
struct hb_struArray asArray;
struct hb_struBlock asBlock;
struct hb_struDate asDate;
struct hb_struDouble asDouble;
struct hb_struInteger asInteger;
struct hb_struLogical asLogical;
struct hb_struLong asLong;
struct hb_struPointer asPointer;
struct hb_struMemvar asMemvar;
struct hb_struRefer asRefer;
struct hb_struEnum asEnum;
struct hb_struString asString;
struct hb_struSymbol asSymbol;
} item;
} HB_ITEM, * PHB_ITEM, * HB_ITEM_PTR;
@@ -336,7 +341,6 @@ typedef struct _HB_BASEARRAY
{
PHB_ITEM pItems; /* pointer to the array items */
ULONG ulLen; /* number of items in the array */
HB_COUNTER ulHolders; /* number of holders of this array */
USHORT * puiClsTree; /* remember array of super called ID Tree */
USHORT uiClass; /* offset to the classes base if it is an object */
USHORT uiPrevCls; /* for fixing after access super */
@@ -346,12 +350,11 @@ typedef struct _HB_BASEARRAY
typedef struct _HB_CODEBLOCK
{
BYTE * pCode; /* codeblock pcode */
PHB_ITEM pLocals; /* table with referenced local variables */
USHORT uiLocals; /* number of referenced local variables */
PHB_SYMB pSymbols; /* codeblocks symbols */
PHB_SYMB pDefSymb; /* symbol where the codeblock was created */
HB_COUNTER ulCounter; /* numer of references to this codeblock */
BOOL dynBuffer; /* is pcode buffer allocated dynamically */
PHB_ITEM pLocals; /* table with referenced local variables */
USHORT uiLocals; /* number of referenced local variables */
SHORT dynBuffer; /* is pcode buffer allocated dynamically, SHORT used instead of BOOL intentionally to force optimal alignment */
} HB_CODEBLOCK, * PHB_CODEBLOCK, * HB_CODEBLOCK_PTR;
typedef struct _HB_VALUE
@@ -435,6 +438,7 @@ extern HB_EXPORT LONGLONG hb_parnll( int iParam, ... ); /* retrieve a numeric
#define hb_retnint( iNumber ) hb_itemPutNInt( hb_stackReturnItem(), iNumber )
#define hb_retnintlen( lNumber, iWidth ) hb_itemPutNIntLen( hb_stackReturnItem(), lNumber, iWidth )
#define hb_retptr( pointer ) hb_itemPutPtr( hb_stackReturnItem(), pointer )
#define hb_retptrGC( pointer ) hb_itemPutPtrGC( hb_stackReturnItem(), pointer )
#else
@@ -460,6 +464,7 @@ extern HB_EXPORT void hb_retnllen( long lNumber, int iWidth ); /* returns a lo
extern HB_EXPORT void hb_retnintlen( HB_LONG lNumber, int iWidth ); /* returns a long long number, with specific width */
extern HB_EXPORT void hb_reta( ULONG ulLen ); /* returns an array with a specific length */
extern HB_EXPORT void hb_retptr( void * ptr ); /* returns a pointer */
extern HB_EXPORT void hb_retptrGC( void * ptr ); /* returns a pointer to an allocated memory, collected by GC */
#ifndef HB_LONG_LONG_OFF
extern HB_EXPORT void hb_retnll( LONGLONG lNumber );/* returns a long long number */
extern HB_EXPORT void hb_retnlllen( LONGLONG lNumber, int iWidth ); /* returns a long long number, with specific width */
@@ -489,6 +494,32 @@ extern HB_EXPORT void * hb_xrealloc( void * pMem, ULONG ulSize ); /* reallocat
extern HB_EXPORT ULONG hb_xsize( void * pMem ); /* returns the size of an allocated memory block */
extern HB_EXPORT ULONG hb_xquery( USHORT uiMode ); /* Query different types of memory information */
#ifdef _HB_API_INTERNAL_
extern void hb_xRefInc( void * pMem ); /* increment reference counter */
extern BOOL hb_xRefDec( void * pMem ); /* decrement reference counter, return TRUE when 0 reached */
extern void hb_xRefFree( void * pMem ); /* decrement reference counter and free the block when 0 reached */
extern HB_COUNTER hb_xRefCount( void * pMem ); /* return number of references */
extern void * hb_xRefResize( void * pMem, ULONG ulSave, ULONG ulSize ); /* reallocates memory, create copy if reference counter greater then 1 */
#if 0
/*
* I used this macros only to test some speed overhead,
* They may not be supported in the future so please do
* not create any code which needs them. [druzus]
*/
#define hb_xRefInc( p ) (++(*HB_COUNTER_PTR( p )))
#define hb_xRefDec( p ) (--(*HB_COUNTER_PTR( p ))==0)
#define hb_xRefFree( p ) do { \
if( hb_xRefDec( p ) ) \
hb_xfree( (p) ); \
} while( 0 )
#endif
#endif
/* #if UINT_MAX == ULONG_MAX */
/* it fails on 64bit platforms where int has 32 bit and long has 64 bit.
we need these functions only when max(size_t) < max(long)
@@ -505,6 +536,32 @@ extern HB_EXPORT void * hb_xmemcpy( void * pDestArg, void * pSourceArg, ULONG ul
extern HB_EXPORT void * hb_xmemset( void * pDestArg, int iFill, ULONG ulLen ); /* set more than memset() can */
#endif
/* garbage collector */
#define HB_GARBAGE_FUNC( hbfunc ) void hbfunc( void * Cargo ) /* callback function for cleaning garbage memory pointer */
typedef HB_GARBAGE_FUNC( HB_GARBAGE_FUNC_ );
typedef HB_GARBAGE_FUNC_ * HB_GARBAGE_FUNC_PTR;
extern PHB_ITEM hb_gcGripGet( HB_ITEM_PTR pItem );
extern void hb_gcGripDrop( HB_ITEM_PTR pItem );
extern void * hb_gcAlloc( ULONG ulSize, HB_GARBAGE_FUNC_PTR pFunc ); /* allocates a memory controlled by the garbage collector */
extern void hb_gcFree( void *pAlloc ); /* deallocates a memory allocated by the garbage collector */
extern void * hb_gcLock( void *pAlloc ); /* do not release passed memory block */
extern void * hb_gcUnlock( void *pAlloc ); /* passed block is allowed to be released */
#ifdef _HB_API_INTERNAL_
extern void hb_gcRefInc( void * pAlloc ); /* increment reference counter */
extern BOOL hb_gcRefDec( void * pAlloc ); /* decrement reference counter, return TRUE when 0 reached */
extern void hb_gcRefFree( void * pAlloc ); /* decrement reference counter and free the block when 0 reached */
extern HB_COUNTER hb_gcRefCount( void * pAlloc ); /* return number of references */
#endif
extern void hb_gcCollect( void ); /* checks if a single memory block can be released */
extern void hb_gcCollectAll( void ); /* checks if all memory blocks can be released */
extern void hb_gcReleaseAll( void ); /* release all memory blocks unconditionally */
extern void hb_gcItemRef( HB_ITEM_PTR pItem ); /* checks if passed item refers passed memory block pointer */
extern void hb_vmIsLocalRef( void ); /* hvm.c - mark all local variables as used */
extern void hb_vmIsStaticRef( void ); /* hvm.c - mark all static variables as used */
extern void hb_memvarsIsMemvarRef( void ); /* memvars.c - mark all memvar variables as used */
/* array management */
extern HB_EXPORT BOOL hb_arrayNew( PHB_ITEM pItem, ULONG ulLen ); /* creates a new array */
extern HB_EXPORT ULONG hb_arrayLen( PHB_ITEM pArray ); /* retrieves the array len */
@@ -516,7 +573,6 @@ extern HB_EXPORT BOOL hb_arrayIns( PHB_ITEM pArray, ULONG ulIndex ); /* in
extern HB_EXPORT BOOL hb_arrayDel( PHB_ITEM pArray, ULONG ulIndex ); /* delete an array item, without changing length */
extern HB_EXPORT BOOL hb_arraySize( PHB_ITEM pArray, ULONG ulLen ); /* sets the array total length */
extern HB_EXPORT BOOL hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult ); /* retrieve last item in an array */
extern HB_EXPORT BOOL hb_arrayRelease( PHB_ITEM pArray ); /* releases an array - don't call it - use ItemRelease() !!! */
extern HB_EXPORT BOOL hb_arraySet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem ); /* sets an array element */
extern HB_EXPORT BOOL hb_arrayGet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem ); /* retrieves an item */
/* hb_arrayGetItemPtr() is dangerous */
@@ -606,23 +662,6 @@ extern HB_EXPORT double hb_get_le_uint64( BYTE * ptr );
extern HB_EXPORT void hb_put_le_uint64( BYTE * ptr, double d );
#endif
/* class management */
extern void hb_clsReleaseAll( void ); /* releases all defined classes */
extern BOOL hb_clsIsParent( USHORT uiClass, char * szParentName ); /* is a class handle inherited from szParentName Class ? */
/* object management */
extern char * hb_objGetClsName( PHB_ITEM pObject ); /* retrieves an object class name */
extern char * hb_objGetRealClsName( PHB_ITEM pObject, char * szString ); /* retrieves an object class name for a specific message */
extern PHB_FUNC hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pSymMsg ); /* returns the method pointer of a object class */
extern BOOL hb_objHasMsg( PHB_ITEM pObject, char * szString ); /* returns TRUE/FALSE whether szString is an existing message for object */
extern void hb_objSendMsg( PHB_ITEM pObj, char *sMsg, ULONG ulArg, ... );
extern USHORT hb_objGetClass( PHB_ITEM pItem );
/* profiler for object management */
extern void * hb_mthRequested( void ); /* profiler from classes.c */
extern void hb_mthAddTime( void *, ULONG ); /* profiler from classes.c */
/* dynamic symbol table management */
extern HB_EXPORT PHB_DYNS hb_dynsymGet( char * szName ); /* finds and creates a dynamic symbol if not found */
extern HB_EXPORT PHB_DYNS hb_dynsymGetCase( char * szName ); /* finds and creates a dynamic symbol if not found - case sensitive */
@@ -659,9 +698,8 @@ extern HB_EXPORT BOOL hb_winmainArgGet( HANDLE * phInstance, HANDLE * phPrevInst
/* Codeblock management */
extern HB_EXPORT void * hb_codeblockId( PHB_ITEM pItem ); /* retrieves the codeblock unique ID */
extern HB_CODEBLOCK_PTR hb_codeblockNew( const BYTE * pBuffer, USHORT uiLocals, const BYTE * pLocalPosTable, PHB_SYMB pSymbols ); /* create a code-block */
extern HB_CODEBLOCK_PTR hb_codeblockNew( const BYTE * pBuffer, USHORT uiLocals, const BYTE * pLocalPosTable, PHB_SYMB pSymbols, USHORT usLen ); /* create a code-block */
extern HB_CODEBLOCK_PTR hb_codeblockMacroNew( BYTE * pBuffer, USHORT usLen );
extern void hb_codeblockDelete( HB_ITEM_PTR pItem ); /* delete a codeblock */
extern PHB_ITEM hb_codeblockGetVar( PHB_ITEM pItem, LONG iItemPos ); /* get local variable referenced in a codeblock */
extern PHB_ITEM hb_codeblockGetRef( HB_CODEBLOCK_PTR pCBlock, PHB_ITEM pRefer ); /* get local variable passed by reference */
extern void hb_codeblockEvaluate( HB_ITEM_PTR pItem ); /* evaluate a codeblock */
@@ -673,7 +711,6 @@ extern void hb_memvarsRelease( void ); /* clear all PUBLIC and PRIVATE var
extern void hb_memvarsFree( void ); /* release the memvar API system */
extern void hb_memvarValueIncRef( HB_HANDLE hValue ); /* increase the reference count of a global value */
extern void hb_memvarValueDecRef( HB_HANDLE hValue ); /* decrease the reference count of a global value */
extern void hb_memvarValueDecGarbageRef( HB_HANDLE hValue ); /* decrease the reference count of a detached local variable */
extern void hb_memvarSetValue( PHB_SYMB pMemvarSymb, HB_ITEM_PTR pItem ); /* copy an item into a symbol */
extern ERRCODE hb_memvarGet( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ); /* copy an symbol value into an item */
extern void hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb ); /* copy an symbol value into an item, with error trapping */
@@ -685,6 +722,9 @@ extern char * hb_memvarGetStrValuePtr( char * szVarName, ULONG *pulLen );
extern void hb_memvarCreateFromItem( PHB_ITEM pMemvar, BYTE bScope, PHB_ITEM pValue );
extern int hb_memvarScope( char * szVarName, ULONG ulLength ); /* retrieve scope of a dynamic variable symbol */
extern PHB_ITEM hb_memvarDetachLocal( HB_ITEM_PTR pLocal ); /* Detach a local variable from the eval stack */
#ifdef _HB_API_INTERNAL_
extern PHB_ITEM hb_memvarGetItem( PHB_SYMB pMemvarSymb );
#endif
/* console I/O subsystem */
extern void hb_conInit( void ); /* initialize the console API system */
@@ -753,29 +793,6 @@ extern void hb_macroPushAliasedValue( HB_ITEM_PTR pAlias, HB_ITEM_PTR pVar, BY
extern char * hb_macroGetType( HB_ITEM_PTR pItem ); /* determine the type of an expression */
extern char * hb_macroExpandString( char *szString, ULONG ulLength, BOOL *pbNewString ); /* expands valid '&' operator */
/* garbage collector */
#define HB_GARBAGE_FUNC( hbfunc ) void hbfunc( void * Cargo ) /* callback function for cleaning garbage memory pointer */
typedef HB_GARBAGE_FUNC( HB_GARBAGE_FUNC_ );
typedef HB_GARBAGE_FUNC_ * HB_GARBAGE_FUNC_PTR;
extern HB_ITEM_PTR hb_gcGripGet( HB_ITEM_PTR pItem );
extern void hb_gcGripDrop( HB_ITEM_PTR pItem );
extern void * hb_gcAlloc( ULONG ulSize, HB_GARBAGE_FUNC_PTR pFunc ); /* allocates a memory controlled by the garbage collector */
extern void hb_gcFree( void *pAlloc ); /* deallocates a memory allocated by the garbage collector */
extern void * hb_gcLock( void *pAlloc ); /* do not release passed memory block */
extern void * hb_gcUnlock( void *pAlloc ); /* passed block is allowed to be released */
extern void hb_gcCollect( void ); /* checks if a single memory block can be released */
extern void hb_gcCollectAll( void ); /* checks if all memory blocks can be released */
extern void hb_gcReleaseAll( void ); /* release all memory blocks unconditionally */
extern void hb_gcItemRef( HB_ITEM_PTR pItem ); /* checks if passed item refers passed memory block pointer */
extern void hb_vmIsLocalRef( void ); /* hvm.c - mark all local variables as used */
extern void hb_vmIsStaticRef( void ); /* hvm.c - mark all static variables as used */
extern void hb_memvarsIsMemvarRef( void ); /* memvars.c - mark all memvar variables as used */
extern void hb_clsIsClassRef( void ); /* classes.c - mark all class internals as used */
extern HB_GARBAGE_FUNC( hb_codeblockDeleteGarbage ); /* clear a codeblock before releasing by the GC */
extern HB_GARBAGE_FUNC( hb_arrayReleaseGarbage ); /* clear an array before releasing by the GC */
/* idle states */
extern void hb_releaseCPU( void );
extern void hb_idleState( void ); /* services a single idle state */

2
harbour/include/hbapicdp.h
View File

@@ -70,7 +70,7 @@ HB_EXTERN_BEGIN
}
#define HB_CODEPAGE_ANNOUNCE( id ) HB_FUNC( HB_CODEPAGE_##id ) {}
#define HB_CODEPAGE_INIT( id ) HB_CODEPAGE_ANNOUNCE( id ); \
#define HB_CODEPAGE_INIT( id ) HB_CODEPAGE_ANNOUNCE( id ) \
HB_CALL_ON_STARTUP_BEGIN( hb_codepage_Init_##id ) \
hb_cdpRegister( &s_codepage ); \
HB_CALL_ON_STARTUP_END( hb_codepage_Init_##id )

117
harbour/include/hbapicls.h Normal file
View File

@@ -0,0 +1,117 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* Harbour class API
*
* Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
* 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.
*
*/
#ifndef HB_APICLS_H_
#define HB_APICLS_H_
#include "hbapi.h"
HB_EXTERN_BEGIN
#define HB_OO_OP_PLUS 0
#define HB_OO_OP_MINUS 1
#define HB_OO_OP_MULT 2
#define HB_OO_OP_DIVIDE 3
#define HB_OO_OP_MOD 4
#define HB_OO_OP_POWER 5
#define HB_OO_OP_INC 6
#define HB_OO_OP_DEC 7
#define HB_OO_OP_EQUAL 8
#define HB_OO_OP_EXACTEQUAL 9
#define HB_OO_OP_NOTEQUAL 10
#define HB_OO_OP_LESS 11
#define HB_OO_OP_LESSEQUAL 12
#define HB_OO_OP_GREATER 13
#define HB_OO_OP_GREATEREQUAL 14
#define HB_OO_OP_ASSIGN 15
#define HB_OO_OP_INSTRING 16
#define HB_OO_OP_NOT 17
#define HB_OO_OP_AND 18
#define HB_OO_OP_OR 19
#define HB_OO_OP_ARRAYINDEX 20
#define HB_OO_OP_ENUMNEXT 21
#define HB_OO_OP_ENUMPREV 22
#define HB_OO_OP_ENUMINDEX 23
#define HB_OO_OP_ENUMBASE 24
#define HB_OO_OP_ENUMVALUE 25
#define HB_OO_MAX_OPERATOR 25
/* class management */
extern void hb_clsInit( void ); /* initialize Classy/OO system at HVM startup */
extern void hb_clsReleaseAll( void ); /* releases all defined classes */
extern void hb_clsIsClassRef( void ); /* classes.c - mark all class internals as used */
/* has this function to be public? */
extern BOOL hb_clsIsParent( USHORT uiClass, char * szParentName ); /* is a class handle inherited from szParentName Class ? */
/* object management */
extern BOOL hb_objHasOperator( PHB_ITEM pObject, USHORT uiOperator );
extern BOOL hb_objOperatorCall( USHORT uiOperator, HB_ITEM_PTR pResult, PHB_ITEM pObject, PHB_ITEM pMsgArg );
extern USHORT hb_objGetClass( PHB_ITEM pItem ); /* get object class handle */
extern char * hb_objGetClsName( PHB_ITEM pObject ); /* retrieves an object class name */
extern char * hb_objGetRealClsName( PHB_ITEM pObject, char * szString ); /* retrieves an object class name for a specific message */
extern PHB_SYMB hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pSymMsg, BOOL * pfPopSuper ); /* returns the method pointer of an object class */
extern void hb_objPopSuperCast( PHB_ITEM pObject ); /* clean super casting if necessary */
extern BOOL hb_objHasMsg( PHB_ITEM pObject, char * szString ); /* returns TRUE/FALSE whether szString is an existing message for object */
extern void hb_objSendMsg( PHB_ITEM pObj, char *sMsg, ULONG ulArg, ... );
#ifndef HB_NO_PROFILER
/* profiler for object management */
extern BOOL hb_bProfiler; /* profiler activity status */
extern void * hb_mthRequested( void ); /* profiler from classes.c */
extern void hb_mthAddTime( void *, ULONG ); /* profiler from classes.c */
#endif
HB_EXTERN_END
#endif /* HB_APICLS_H_ */

34
harbour/include/hbapiitm.h
View File

@@ -134,13 +134,14 @@ extern HB_EXPORT PHB_ITEM hb_itemPutNLLLen( PHB_ITEM pItem, LONGLONG lNumber,
extern HB_EXPORT PHB_ITEM hb_itemParamPtr ( USHORT uiParam, long lMask );
extern HB_EXPORT int hb_itemStrCmp ( PHB_ITEM pFirst, PHB_ITEM pSecond, BOOL bForceExact ); /* our string compare */
extern HB_EXPORT void hb_itemCopy ( PHB_ITEM pDest, PHB_ITEM pSource ); /* copies an item to one place to another respecting its containts */
extern HB_EXPORT void hb_itemForwardValue( PHB_ITEM pDest, PHB_ITEM pSource ); /* copies the value of an item without incrementing of reference counters */
extern HB_EXPORT void hb_itemMove ( PHB_ITEM pDest, PHB_ITEM pSource );
extern HB_EXPORT void hb_itemMove ( PHB_ITEM pDest, PHB_ITEM pSource ); /* moves the value of an item without incrementing of reference counters, source is cleared */
extern HB_EXPORT void hb_itemClear ( PHB_ITEM pItem );
extern HB_EXPORT PHB_ITEM hb_itemUnRef ( PHB_ITEM pItem ); /* de-references passed variable */
extern HB_EXPORT PHB_ITEM hb_itemUnRefOnce( PHB_ITEM pItem ); /* de-references passed variable, one step*/
extern HB_EXPORT PHB_ITEM hb_itemUnRefRefer( PHB_ITEM pItem ); /* de-references passed variable, leaving the last reference */
extern HB_EXPORT PHB_ITEM hb_itemUnShare ( PHB_ITEM pItem ); /* un-share given string item */
extern HB_EXPORT PHB_ITEM hb_itemUnShareString( PHB_ITEM pItem ); /* un-share given string item - the pItem have to be valid unrefed string item */
extern HB_EXPORT PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, ULONG ulSize ); /* Resize string buffer of given string item - the pItem have to be valid unrefed string item */
extern HB_EXPORT PHB_ITEM hb_itemClone ( PHB_ITEM pItem ); /* clone the given item */
extern HB_EXPORT char * hb_itemStr ( PHB_ITEM pNumber, PHB_ITEM pWidth, PHB_ITEM pDec ); /* convert a number to a string */
extern HB_EXPORT char * hb_itemString ( PHB_ITEM pItem, ULONG * ulLen, BOOL * bFreeReq ); /* Convert any scalar to a string */
@@ -149,6 +150,35 @@ extern HB_EXPORT PHB_ITEM hb_itemValToStr ( PHB_ITEM pItem ); /* Convert any s
extern HB_EXPORT char * hb_itemPadConv ( PHB_ITEM pItem, ULONG * pulSize, BOOL * bFreeReq );
extern HB_EXPORT void hb_itemSwap ( PHB_ITEM pItem1, PHB_ITEM pItem2 );
#if defined( _HB_API_INTERNAL_ )
# define hb_itemSetNil( item ) do { \
if( HB_IS_COMPLEX( item ) ) \
hb_itemClear( item ); \
else \
(item)->type = HB_IT_NIL; \
} while( 0 )
#if 0
# define hb_itemRawMove( dst, src ) do { \
memcpy( (dst), (src), sizeof( HB_ITEM ) ); \
(src)->type = HB_IT_NIL; \
} while( 0 )
#else
# define hb_itemRawMove( dst, src ) hb_itemMove( (dst), (src) )
#endif
#else
# define hb_itemSetNil( item ) hb_itemClear( (item) )
# define hb_itemRawMove( dst, src ) hb_itemMove( (dst), (src) )
#endif
/* xHarbour compatible function */
#define hb_itemForwardValue( dst, src ) hb_itemMove( (dst), (src) )
HB_EXTERN_END
#endif /* HB_APIITM_H_ */

36
harbour/include/hbdefs.h
View File

@@ -404,18 +404,22 @@
# define HB_LL( num ) num##LL
#endif
#if HB_LONG_MAX > HB_LL( 10000000000 )
# define HB_LONG_LENGTH( l ) ( ( (l) <= -1000000000 || (l) >= HB_LL( 10000000000 ) ) ? 20 : 10 )
#else
# define HB_LONG_LENGTH( l ) ( ( (l) <= -1000000000 ) ? 20 : 10 )
#endif
#if HB_INT_MIN <= -1000000000
# define HB_INT_LENGTH( i ) ( ( (i) <= -1000000000 ) ? 20 : 10 )
#else
# define HB_INT_LENGTH( i ) 10
#endif
#if !defined( HB_LONG_LONG_OFF )
# if HB_LONG_MAX > HB_LL( 10000000000 )
# define HB_LONG_LENGTH( l ) ( ( (l) <= -1000000000 || (l) >= HB_LL( 10000000000 ) ) ? 20 : 10 )
# endif
#endif
#if !defined HB_LONG_LENGTH
# define HB_LONG_LENGTH( l ) ( ( (l) <= -1000000000 ) ? 20 : 10 )
#endif
/* NOTE: Yes, -999999999.0 is right instead of -1000000000.0 [vszakats] */
/* This comment is from hb_vmNeg() - if it's true only in this case then
the limit should be changed and this function fixed */
@@ -433,6 +437,11 @@ typedef UINT32 HB_TYPE;
/* type of reference counter */
typedef unsigned long HB_COUNTER;
#if ULONG_MAX <= UINT32_MAX
# define HB_COUNTER_SIZE 4
#else
# define HB_COUNTER_SIZE 8
#endif
/* type for memory pointer diff */
#if defined( _WIN64 )
@@ -584,11 +593,22 @@ typedef unsigned long HB_COUNTER;
# if !defined( HB_STRICT_ALIGNMENT )
# define HB_STRICT_ALIGNMENT
# endif
#endif
#if defined( HB_STRICT_ALIGNMENT )
# if !defined( HB_ALLOC_ALIGNMENT ) || ( HB_ALLOC_ALIGNMENT + 1 == 1 )
# define HB_ALLOC_ALIGNMENT 8
# endif
#endif
#if defined( HB_ALLOC_ALIGNMENT ) && HB_COUNTER_SIZE < HB_ALLOC_ALIGNMENT + 0
# define HB_COUNTER_OFFSET HB_ALLOC_ALIGNMENT
#else
# define HB_COUNTER_OFFSET HB_COUNTER_SIZE
#endif
#define HB_COUNTER_PTR( p ) ((HB_COUNTER*) ((BYTE *) (p)-HB_COUNTER_OFFSET))
/*
* These macros are necessary for architectures which need
* strict alignment for pointers.
@@ -601,6 +621,8 @@ typedef unsigned long HB_COUNTER;
# define HB_PUT_LONG( p, v ) HB_PUT_BE_UINT32( p, ( UINT32 ) ( v ) )
# define HB_GET_LONG( p ) HB_GET_BE_UINT32( p )
# endif
# define HB_PUT_UINT32( p, v ) HB_PUT_BE_UINT32( p, ( UINT32 ) ( v ) )
# define HB_GET_UINT32( p ) HB_GET_BE_UINT32( p )
#else
# if defined( HB_ARCH_64BIT )
# define HB_PUT_LONG( p, v ) HB_PUT_LE_UINT64( p, ( UINT64 ) ( v ) )
@@ -609,6 +631,8 @@ typedef unsigned long HB_COUNTER;
# define HB_PUT_LONG( p, v ) HB_PUT_LE_UINT32( p, ( UINT32 ) ( v ) )
# define HB_GET_LONG( p ) HB_GET_LE_UINT32( p )
# endif
# define HB_PUT_UINT32( p, v ) HB_PUT_LE_UINT32( p, ( UINT32 ) ( v ) )
# define HB_GET_UINT32( p ) HB_GET_LE_UINT32( p )
#endif
#if !defined( HB_STRICT_ALIGNMENT )

27
harbour/include/hbexprb.c
View File

@@ -1285,14 +1285,14 @@ static HB_EXPR_FUNC( hb_compExprUseArrayAt )
{
BOOL bRemoveRef = FALSE;
/* #ifndef HB_C52_STRICT */
if( HB_SUPPORT_ARRSTR )
/* to manage strings as bytes arrays, they must be pushed by reference */
/* arrays also are passed by reference */
if( pSelf->value.asList.pExprList->ExprType == HB_ET_VARIABLE )
{
pSelf->value.asList.pExprList->ExprType = HB_ET_VARREF;
bRemoveRef = TRUE;
}
if( HB_SUPPORT_ARRSTR )
/* to manage strings as bytes arrays, they must be pushed by reference */
/* arrays also are passed by reference */
if( pSelf->value.asList.pExprList->ExprType == HB_ET_VARIABLE )
{
pSelf->value.asList.pExprList->ExprType = HB_ET_VARREF;
bRemoveRef = TRUE;
}
/* #endif */
HB_EXPR_USE( pSelf->value.asList.pExprList, HB_EA_PUSH_PCODE );
@@ -1300,11 +1300,11 @@ static HB_EXPR_FUNC( hb_compExprUseArrayAt )
HB_EXPR_GENPCODE1( hb_compGenPCode1, HB_P_ARRAYPOP );
/* #ifndef HB_C52_STRICT */
if( HB_SUPPORT_ARRSTR )
if( bRemoveRef )
{
pSelf->value.asList.pExprList->ExprType = HB_ET_VARIABLE;
}
if( HB_SUPPORT_ARRSTR )
if( bRemoveRef )
{
pSelf->value.asList.pExprList->ExprType = HB_ET_VARIABLE;
}
/* #endif */
}
@@ -3356,6 +3356,7 @@ static HB_EXPR_FUNC( hb_compExprUsePlus )
case HB_EA_LVALUE:
hb_compErrorLValue( pSelf );
break;
case HB_EA_PUSH_PCODE:
{
HB_EXPR_USE( pSelf->value.asOperator.pLeft, HB_EA_PUSH_PCODE );

37
harbour/include/hbinit.h
View File

@@ -57,7 +57,8 @@
HB_EXTERN_BEGIN
extern HB_EXPORT void hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols ); /* statics symbols initialization */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols ); /* old module symbols initialization */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbolsExt( PHB_SYMB pSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID, USHORT uiPcodeMin, USHORT uiPcodeMax ); /* module symbols initialization with extended information */
#if defined(_MSC_VER) && !defined(_WIN64) && \
!defined(__LCC__) && !defined(__POCC__) && !defined(__XCC__) && \
@@ -87,13 +88,14 @@ extern HB_EXPORT void hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
#if defined(HARBOUR_STRICT_ANSI_C)
#define HB_INIT_SYMBOLS_BEGIN( func ) \
static HB_SYMB symbols[] = {
static HB_SYMB symbols_table[] = {
#define HB_INIT_SYMBOLS_END( func ) \
}; \
static PHB_SYMB symbols = symbols_table; \
void func( void ) \
{ \
hb_vmProcessSymbols( symbols, (USHORT) ( sizeof( symbols ) / sizeof( HB_SYMB ) ) ); \
symbols = hb_vmProcessSymbols( symbols_table, (USHORT) ( sizeof( symbols_table ) / sizeof( HB_SYMB ) ) ); \
}
#define HB_CALL_ON_STARTUP_BEGIN( func ) \
@@ -110,13 +112,14 @@ extern HB_EXPORT void hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
#endif
#define HB_INIT_SYMBOLS_BEGIN( func ) \
static HB_SYMB symbols[] = {
static HB_SYMB symbols_table[] = {
#define HB_INIT_SYMBOLS_END( func ) \
}; \
static PHB_SYMB symbols = symbols_table; \
static void __attribute__ ((constructor)) func( void ) \
{ \
hb_vmProcessSymbols( symbols, (USHORT) ( sizeof( symbols ) / sizeof( HB_SYMB ) ) ); \
symbols = hb_vmProcessSymbols( symbols_table, (USHORT) ( sizeof( symbols_table ) / sizeof( HB_SYMB ) ) ); \
}
#define HB_CALL_ON_STARTUP_BEGIN( func ) \
@@ -131,13 +134,14 @@ extern HB_EXPORT void hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
typedef int (* HB_$INITSYM)( void );
#define HB_INIT_SYMBOLS_BEGIN( func ) \
static HB_SYMB symbols[] = {
static HB_SYMB symbols_table[] = {
#define HB_INIT_SYMBOLS_END( func ) \
}; \
static PHB_SYMB symbols = symbols_table; \
static int func( void ) \
{ \
hb_vmProcessSymbols( symbols, (USHORT) ( sizeof( symbols ) / sizeof( HB_SYMB ) ) ); \
symbols = hb_vmProcessSymbols( symbols_table, (USHORT) ( sizeof( symbols_table ) / sizeof( HB_SYMB ) ) ); \
return 0; \
}
@@ -160,21 +164,11 @@ extern HB_EXPORT void hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
#endif
#define HB_INIT_SYMBOLS_BEGIN( func ) \
static HB_SYMB symbols[] = {
static HB_SYMB symbols_table[] = {
/* this allows any macros to be preprocessed first
so that token pasting is handled correctly */
#define HB_INIT_SYMBOLS_END( func ) \
_HB_INIT_SYMBOLS_END( func )
#define _HB_INIT_SYMBOLS_END( func ) \
}; \
static int func( void ) \
{ \
hb_vmProcessSymbols( symbols, (USHORT) ( sizeof( symbols ) / sizeof( HB_SYMB ) ) ); \
return 0; \
} \
static int hb_vm_auto_##func = func();
static PHB_SYMB symbols = hb_vmProcessSymbols( symbols_table, (USHORT) ( sizeof( symbols_table ) / sizeof( HB_SYMB ) ) ); \
#define HB_CALL_ON_STARTUP_BEGIN( func ) \
static int func( void ) \
@@ -202,13 +196,14 @@ extern HB_EXPORT void hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
#endif
#define HB_INIT_SYMBOLS_BEGIN( func ) \
static HB_SYMB symbols[] = {
static HB_SYMB symbols_table[] = {
#define HB_INIT_SYMBOLS_END( func ) \
}; \
static PHB_SYMB symbols = symbols_table; \
static void func( void ) \
{ \
hb_vmProcessSymbols( symbols, (USHORT) ( sizeof( symbols ) / sizeof( HB_SYMB ) ) ); \
symbols = hb_vmProcessSymbols( symbols_table, (USHORT) ( sizeof( symbols_table ) / sizeof( HB_SYMB ) ) ); \
}
#define HB_CALL_ON_STARTUP_BEGIN( func ) \

21
harbour/include/hbsetup.h
View File

@@ -125,6 +125,16 @@
#define HB_FM_STATISTICS
#endif
/* ***********************************************************************
* Enable profiler support in HVM
* By default this is turned off. Define HB_USE_PROFILER to turn it on.
*/
#ifndef HB_USE_PROFILER
#define HB_NO_PROFILER
#endif
/* ***********************************************************************
* Use native Windows memory allocation functions (HB_OS_WIN_32)
* This option can disabled compiler memory allocation optimization
@@ -207,7 +217,16 @@
* Using this option makes sorting *much* faster, but if you have a
* problem, or the low level stuff changes, turn it off. [vszakats]
*/
#define HB_ASORT_OPT_ITEMCOPY
/*
* It's not longer used - current code which uses hb_itemSwap() should
* give similar performance (probably a little bit worser due to some small
* function call overhead) but it's ready for automatic GC activation and
* I'd like to keep it.
* If the current performance is not enough then I can change sorting
* algorithm used inside ASORT and with cost of some additional memory
* improve the speed but it's not my priority now. [druzus]
*/
/* #define HB_ASORT_OPT_ITEMCOPY */
/* ***********************************************************************
* You can select here faster but less secure behaviour of STOD() function

18
harbour/include/hbstack.h
View File

@@ -97,7 +97,7 @@ typedef struct
#define hb_stackTopItem( ) ( * hb_stack.pPos )
#define hb_stackBaseItem( ) ( * hb_stack.pBase )
#define hb_stackSelfItem( ) ( * ( hb_stack.pBase + 1 ) )
#define hb_stackItem( iItemPos ) ( * ( hb_stack.pItems + iItemPos ) )
#define hb_stackItem( iItemPos ) ( * ( hb_stack.pItems + ( iItemPos ) ) )
#define hb_stackReturnItem( ) ( &hb_stack.Return )
@@ -117,11 +117,27 @@ typedef struct
if( HB_IS_COMPLEX( * hb_stack.pPos ) ) \
hb_itemClear( * hb_stack.pPos ); \
} while ( 0 )
#define hb_stackPush( ) do { \
if( ++hb_stack.pPos == hb_stack.pEnd ) \
hb_stackIncrease(); \
( * hb_stack.pPos )->type = HB_IT_NIL; \
} while ( 0 )
#define hb_stackPopReturn( ) do { \
if( HB_IS_COMPLEX( &hb_stack.Return ) ) \
hb_itemClear( &hb_stack.Return ); \
if( --hb_stack.pPos < hb_stack.pItems ) \
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL ); \
hb_itemRawMove( &hb_stack.Return, * hb_stack.pPos ); \
} while ( 0 )
#define hb_stackPushReturn( ) do { \
hb_itemRawMove( * hb_stack.pPos, &hb_stack.Return ); \
if( ++hb_stack.pPos == hb_stack.pEnd ) \
hb_stackIncrease(); \
( * hb_stack.pPos )->type = HB_IT_NIL; \
} while ( 0 )
#else
extern HB_ITEM_PTR hb_stackItemFromTop( int nFromTop );

9
harbour/include/hbtypes.h
View File

@@ -60,8 +60,12 @@
#include "hbvm.h"
#include "hbapiitm.h"
typedef void ( * VM_PROCESS_DLL_SYMBOLS ) ( PHB_SYMB pModuleSymbols,
USHORT uiModuleSymbols );
typedef PHB_SYMB ( * VM_PROCESS_DLL_SYMBOLS ) ( PHB_SYMB pModuleSymbols,
USHORT uiModuleSymbols );
typedef PHB_SYMB ( * VM_PROCESS_SYMBOLS_EXT )
( PHB_SYMB pModuleSymbols, USHORT uiModuleSymbols,
char * szModuleName, ULONG ulID,
USHORT uiPcodeMin, USHORT uiPcodeMax );
typedef void ( * VM_DLL_EXECUTE ) ( const BYTE * pCode, PHB_SYMB pSymbols );
@@ -126,7 +130,6 @@ typedef BOOL ( * HB_ARRAYINS)( PHB_ITEM pArray, ULONG ulIndex );
typedef BOOL ( * HB_ARRAYDEL)( PHB_ITEM pArray, ULONG ulIndex );
typedef BOOL ( * HB_ARRAYSIZE)( PHB_ITEM pArray, ULONG ulLen );
typedef BOOL ( * HB_ARRAYLAST)( PHB_ITEM pArray, PHB_ITEM pResult );
typedef BOOL ( * HB_ARRAYRELEASE)( PHB_ITEM pArray );
typedef BOOL ( * HB_ARRAYSET)( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem );
typedef BOOL ( * HB_ARRAYGET)( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem );
typedef void ( * HB_XINIT)( void ); /* Initialize fixed memory subsystem */

2
harbour/include/hbver.h
View File

@@ -63,7 +63,7 @@
#define HB_VER_MAJOR 0 /* Major version number */
#define HB_VER_MINOR 46 /* Minor version number */
#define HB_VER_REVISION 1 /* Revision number */
#define HB_VER_REVISION 2 /* Revision number */
/* NOTE: The next two fields are automatically updated by the hbverfix program */

29
harbour/include/hbvm.h
View File

@@ -69,8 +69,31 @@ extern HB_EXPORT void hb_vmAtExit( HB_INIT_FUNC pFunc, void * cargo );
/* Harbour virtual machine functions */
extern HB_EXPORT void hb_vmExecute( const BYTE * pCode, PHB_SYMB pSymbols ); /* invokes the virtual machine */
extern HB_EXPORT void hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols ); /* statics symbols initialization */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols ); /* old module symbols initialization */
extern HB_EXPORT PHB_SYMB hb_vmProcessSymbolsExt( PHB_SYMB pSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID, USHORT uiPcodeMin, USHORT uiPcodeMax ); /* module symbols initialization with extended information */
#ifdef _HB_API_INTERNAL_
typedef struct _HB_SYMBOLS
{
PHB_SYMB pModuleSymbols; /* pointer to module symbol table */
USHORT uiModuleSymbols; /* number of symbols on that table */
struct _HB_SYMBOLS * pNext; /* pointer to the next SYMBOLS structure */
HB_SYMBOLSCOPE hScope; /* scope collected from all symbols in module used to speed initialization code */
void * hDynLib; /* handler to dynamic library */
BOOL fAllocated; /* the symbol table is dynamically allocated and should be freed on HVM exit */
BOOL fActive; /* the symbol table is currently active */
BOOL fInitStatics; /* static initialization should be executed */
char * szModuleName; /* module name */
ULONG ulID; /* module unique identifier */
} HB_SYMBOLS, * PHB_SYMBOLS; /* structure to keep track of all modules symbol tables */
extern PHB_SYMBOLS hb_vmRegisterSymbols( PHB_SYMB pModuleSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID, BOOL fDynLib, BOOL fClone );
extern void hb_vmFreeSymbols( PHB_SYMBOLS pSymbols );
extern void hb_vmBeginSymbolGroup( void * hDynLib, BOOL fClone );
extern void hb_vmInitSymbolGroup( void * hNewDynLib, int argc, char * argv[] );
extern void hb_vmExitSymbolGroup( void * hDynLib );
#endif
extern HB_EXPORT void hb_vmSymbolInit_RT( void ); /* initialization of runtime support symbols */
/* Harbour virtual machine escaping API */
@@ -90,7 +113,7 @@ extern HB_EXPORT void hb_vmRequestQuit( void );
/* Execution */
extern HB_EXPORT void hb_vmDo( USHORT uiParams ); /* invoke the virtual machine */
extern HB_EXPORT void hb_vmFunction( USHORT uiParams ); /* executes a function saving its result */
extern HB_EXPORT void hb_vmFunction( USHORT uiParams ); /* executes a function */
extern HB_EXPORT void hb_vmSend( USHORT uiParams ); /* sends a message to an object */
extern HB_EXPORT PHB_ITEM hb_vmEvalBlock( PHB_ITEM pBlockItem ); /* executes passed codeblock with no arguments */
/* executes passed codeblock with variable number of arguments */

32
harbour/include/hbvmpub.h
View File

@@ -94,14 +94,22 @@ struct _HB_SYMB;
typedef struct _HB_DYNS
{
struct _HB_SYMB * pSymbol; /* pointer to its relative local symbol */
PHB_FUNC pFunPtr; /* Pointer to the function address */
HB_HANDLE hArea; /* Workarea number */
HB_HANDLE hMemvar; /* Index number into memvars ( publics & privates ) array */
#ifndef HB_NO_PROFILER
ULONG ulCalls; /* profiler support */
ULONG ulTime; /* profiler support */
ULONG ulRecurse; /* profiler support */
#endif
} HB_DYNS, * PHB_DYNS, * HB_DYNS_PTR;
/* pCode dynamic function - HRB */
typedef struct _HB_PCODEFUNC
{
BYTE * pCode; /* function body - PCODE */
struct _HB_SYMB * pSymbols;/* module symbol table */
} HB_PCODEFUNC, * PHB_PCODEFUNC;
#else
# undef HB_API_MACROS
@@ -119,6 +127,7 @@ struct _HB_SYMB;
typedef void * PHB_ITEM;
typedef void * HB_ITEM_PTR;
typedef void * HB_CODEBLOCK_PTR;
typedef void * PHB_PCODEFUNC;
typedef void HB_STACK;
@@ -154,7 +163,8 @@ typedef struct _HB_SYMB
} scope;
union
{
PHB_FUNC pFunPtr; /* function address for function symbol table entries */
PHB_FUNC pFunPtr; /* machine code function address for function symbol table entries */
PHB_PCODEFUNC pCodeFunc; /* PCODE function address */
int iStaticsBase; /* base offset to array of statics */
} value;
PHB_DYNS pDynSym; /* pointer to its dynamic symbol if defined */
@@ -173,14 +183,18 @@ typedef struct _HB_FUNC_LIST
} HB_FUNC_LIST, * PHB_FUNC_LIST;
/* Harbour Functions scope ( HB_SYMBOLSCOPE ) */
#define HB_FS_PUBLIC ( ( HB_SYMBOLSCOPE ) 0x01 )
#define HB_FS_STATIC ( ( HB_SYMBOLSCOPE ) 0x02 )
#define HB_FS_FIRST ( ( HB_SYMBOLSCOPE ) 0x04 )
#define HB_FS_INIT ( ( HB_SYMBOLSCOPE ) 0x08 )
#define HB_FS_EXIT ( ( HB_SYMBOLSCOPE ) 0x10 )
#define HB_FS_PUBLIC ( ( HB_SYMBOLSCOPE ) 0x0001 )
#define HB_FS_STATIC ( ( HB_SYMBOLSCOPE ) 0x0002 )
#define HB_FS_FIRST ( ( HB_SYMBOLSCOPE ) 0x0004 )
#define HB_FS_INIT ( ( HB_SYMBOLSCOPE ) 0x0008 )
#define HB_FS_EXIT ( ( HB_SYMBOLSCOPE ) 0x0010 )
#define HB_FS_MESSAGE ( ( HB_SYMBOLSCOPE ) 0x0020 )
#define HB_FS_MEMVAR ( ( HB_SYMBOLSCOPE ) 0x0080 )
#define HB_FS_PCODEFUNC ( ( HB_SYMBOLSCOPE ) 0x0100 )
#define HB_FS_LOCAL ( ( HB_SYMBOLSCOPE ) 0x0200 )
#define HB_FS_DYNCODE ( ( HB_SYMBOLSCOPE ) 0x0400 )
#define HB_FS_INITEXIT ( HB_FS_INIT | HB_FS_EXIT )
#define HB_FS_MESSAGE ( ( HB_SYMBOLSCOPE ) 0x20 )
#define HB_FS_MEMVAR ( ( HB_SYMBOLSCOPE ) 0x80 )
extern HB_EXPORT void hb_vmExecute( const BYTE * pCode, PHB_SYMB pSymbols ); /* invokes the virtual machine */

22
harbour/include/hbxvm.h
View File

@@ -73,7 +73,7 @@ HB_EXTERN_BEGIN
* to check HVM state so they are simply declared as void.
*/
extern HB_EXPORT void hb_xvmExitPorc( ULONG );
extern HB_EXPORT void hb_xvmExitProc( ULONG ulPrivateBase );
extern HB_EXPORT void hb_xvmSeqBegin( void );
extern HB_EXPORT BOOL hb_xvmSeqEnd( LONG * );
extern HB_EXPORT BOOL hb_xvmSeqRecover( LONG * );
@@ -198,6 +198,26 @@ extern HB_EXPORT BOOL hb_xvmArrayItemPop( ULONG ulIndex );
extern HB_EXPORT BOOL hb_xvmMultByInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmDivideByInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmAddInt( LONG lValue );
extern HB_EXPORT void hb_xvmLocalSetInt( int iLocal, LONG lValue );
/*extern HB_EXPORT void hb_xvmLocalSetStr( int iLocal, const char * pValue, ULONG ulLen );*/
extern HB_EXPORT void hb_xvmPushFuncSymbol( PHB_SYMB pSym );
extern HB_EXPORT BOOL hb_xvmLessThenInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmLessThenIntIs( LONG lValue, BOOL *fValue );
extern HB_EXPORT BOOL hb_xvmLessEqualThenInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmLessEqualThenIntIs( LONG lValue, BOOL *fValue );
extern HB_EXPORT BOOL hb_xvmGreaterThenInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmGreaterThenIntIs( LONG lValue, BOOL *fValue );
extern HB_EXPORT BOOL hb_xvmGreaterEqualThenInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmGreaterEqualThenIntIs( LONG lValue, BOOL *fValue );
extern HB_EXPORT BOOL hb_xvmEqualInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmEqualIntIs( LONG lValue, BOOL *fValue );
extern HB_EXPORT BOOL hb_xvmNotEqualInt( LONG lValue );
extern HB_EXPORT BOOL hb_xvmNotEqualIntIs( LONG lValue, BOOL *fValue );
extern HB_EXPORT BOOL hb_xvmLocalAdd( int iLocal );
extern HB_EXPORT BOOL hb_xvmStaticAdd( USHORT uiStatic );
extern HB_EXPORT BOOL hb_xvmMemvarAdd( PHB_SYMB pSymbol );
HB_EXTERN_END

2
harbour/source/codepage/cpbg866.c
View File

@@ -89,7 +89,7 @@ static HB_CODEPAGE s_codepage = { "BG866",
" ¡¢£¤¥¦§¨©ª«¬­®¯àáâãäåæçèéêëìíîï",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( BG866 );
HB_CODEPAGE_INIT( BG866 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_BG866

2
harbour/source/codepage/cpbgiso.c
View File

@@ -89,7 +89,7 @@ static HB_CODEPAGE s_codepage = { "BGISO",
"ÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîï",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( BGISO );
HB_CODEPAGE_INIT( BGISO )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_BGISO

2
harbour/source/codepage/cpbgwin.c
View File

@@ -89,7 +89,7 @@ static HB_CODEPAGE s_codepage = { "BGWIN",
"àáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( BGWIN );
HB_CODEPAGE_INIT( BGWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_BGWIN

2
harbour/source/codepage/cpeldos.c
View File

@@ -89,7 +89,7 @@ static HB_CODEPAGE s_codepage = { "EL",
"˜~ᙚ›œ~â<>ž~㟠~å¡¢£¤¥¦~槨©ª«¬~ç­®¯à~é",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( EL );
HB_CODEPAGE_INIT( EL )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_EL

2
harbour/source/codepage/cpelwin.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "ELWIN",
"á~Üâãäå~Ýæç~Þèé~ßêëìíîï~üðñóòôõ~ýö÷øù~þ",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( ELWIN );
HB_CODEPAGE_INIT( ELWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_ELWIN

3
harbour/source/codepage/cpesdos.c
View File

@@ -90,8 +90,7 @@ static HB_CODEPAGE s_codepage = { "ES",
"a bcde‚fghi¡jklmn¤o¢pqrstu£<EFBFBD>vwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( ES );
HB_CODEPAGE_INIT( ES )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_ES

2
harbour/source/codepage/cpesmwi.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "ESMWIN",
"aáàäbcçdeéèëfghiíìïjklmnñoóòöpqrstuúùüvwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( ESMWIN );
HB_CODEPAGE_INIT( ESMWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_ESMWIN

2
harbour/source/codepage/cpeswin.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "ESWIN",
"aábcdeéfghiíjklmnñoópqrstuúüvwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( ESWIN );
HB_CODEPAGE_INIT( ESWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_ESWIN

2
harbour/source/codepage/cpgedos.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "DE",
"a„bcdefghijklmno”pqrsátu<EFBFBD>vwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( DE );
HB_CODEPAGE_INIT( DE )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_DE

2
harbour/source/codepage/cpgewin.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "DEWIN",
"aäbcdefghijklmnoöpqrsßtuüvwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( DEWIN );
HB_CODEPAGE_INIT( DEWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_DEWIN

2
harbour/source/codepage/cphu852.c
View File

@@ -92,7 +92,7 @@ static HB_CODEPAGE s_codepage = { "HU852",
"a „bcde‚fghi¡jklmno¢”‹pqrstu£<EFBFBD>ûvwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( HU852 );
HB_CODEPAGE_INIT( HU852 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_HU852

2
harbour/source/codepage/cphuiso.c
View File

@@ -89,7 +89,7 @@ static HB_CODEPAGE s_codepage = { "HUISO",
"aábcdeéfghiíjklmnoóöõpqrstuúüûvwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( HUISO );
HB_CODEPAGE_INIT( HUISO )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_HUISO

2
harbour/source/codepage/cphuwin.c
View File

@@ -89,7 +89,7 @@ static HB_CODEPAGE s_codepage = { "HUWIN",
"aábcdeéfghiíjklmnoóöõpqrstuúüûvwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( HUWIN );
HB_CODEPAGE_INIT( HUWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_HUWIN

2
harbour/source/codepage/cppl852.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "PL852",
"a¥bc†de©fghijklˆmnäo¢pqrs˜tuvwxyz«¾",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( PL852 );
HB_CODEPAGE_INIT( PL852 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_PL852

2
harbour/source/codepage/cppliso.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "PLISO",
"a±bcædeêfghijkl³mnñoópqrs¶tuvwxyz¼¿",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( PLISO );
HB_CODEPAGE_INIT( PLISO )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_PLISO

2
harbour/source/codepage/cpplmaz.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "PLMAZ",
"a†bc<EFBFBD>de‘fghijkl’mn¤o¢pqrsžtuvwxyz¦§",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( PLMAZ );
HB_CODEPAGE_INIT( PLMAZ )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_PLMAZ

2
harbour/source/codepage/cpplwin.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "PLWIN",
"a¹bcædeêfghijkl³mnñoópqrsœtuvwxyzŸ¿",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( PLWIN );
HB_CODEPAGE_INIT( PLWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_PLWIN

2
harbour/source/codepage/cppt850.c
View File

@@ -91,7 +91,7 @@ static HB_CODEPAGE s_codepage = { "PT850",
"a …ƒÆ„bc‡de‚Šˆfghi¡<EFBFBD>Œ‹jklmn¤o¢•“ä”pqrstu£—–<EFBFBD>vwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( PT850 );
HB_CODEPAGE_INIT( PT850 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_PT850

2
harbour/source/codepage/cpptiso.c
View File

@@ -91,7 +91,7 @@ static HB_CODEPAGE s_codepage = { "PTISO",
"aáàâãäbcçdeéèêfghiíìîïjklmnñoóòôõöpqrstuúùûüvwxyz",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( PTISO );
HB_CODEPAGE_INIT( PTISO )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_PTISO

2
harbour/source/codepage/cpru866.c
View File

@@ -64,7 +64,7 @@ static HB_CODEPAGE s_codepage = { "RU866",
" ¡¢£¤¥¦§¨©ª«¬­®¯àáâãäåæçèéêëìíîï",
0,0,0,0,0,NULL,NULL,NULL,NULL,0,NULL };
HB_CODEPAGE_INIT( RU866 );
HB_CODEPAGE_INIT( RU866 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_RU866

2
harbour/source/codepage/cprukoi.c
View File

@@ -64,7 +64,7 @@ static HB_CODEPAGE s_codepage = { "RUKOI8",
"ÁÂ×ÇÄÅÖÚÉÊËÌÍÎÏÐÒÓÔÕÆÈÃÞÛÝßÙØÜÀÑ",
0,0,0,0,0,NULL,NULL,NULL,NULL,0,NULL };
HB_CODEPAGE_INIT( RUKOI8 );
HB_CODEPAGE_INIT( RUKOI8 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_RUKOI8

2
harbour/source/codepage/cpruwin.c
View File

@@ -64,7 +64,7 @@ static HB_CODEPAGE s_codepage = { "RU1251",
"àáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ",
0,0,0,0,0,NULL,NULL,NULL,NULL,0,NULL };
HB_CODEPAGE_INIT( RU1251 );
HB_CODEPAGE_INIT( RU1251 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_RU1251

2
harbour/source/codepage/cpsl437.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "SL437",
"abc~}d|efghijklmnopqrs{tuvwz`xy",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( SL437 );
HB_CODEPAGE_INIT( SL437 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_SL437

2
harbour/source/codepage/cpsl852.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "SL852",
"abcŸ†dÐefghijklmnopqrsçtuvwz§xy",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( SL852 );
HB_CODEPAGE_INIT( SL852 )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_SL852

2
harbour/source/codepage/cpsliso.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "SLISO",
"abcèædðefghijklmnopqrs¹tuvwz¾xy",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( SLISO );
HB_CODEPAGE_INIT( SLISO )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_SLISO

2
harbour/source/codepage/cpslwin.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "SLWIN",
"abcèædðefghijklmnopqrsštuvwzžxy",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( SLWIN );
HB_CODEPAGE_INIT( SLWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_SLWIN

2
harbour/source/codepage/cpsrwin.c
View File

@@ -90,7 +90,7 @@ static HB_CODEPAGE s_codepage = { "SRWIN",
"àáâãä<EFBFBD>åæçè¼êëšìíœîïðñòžóôõö÷Ÿø",
IS_LATIN, ACCENTED_EQUAL, ACCENTED_INTERLEAVED, 0, 0, NULL, NULL, NULL, NULL, 0, NULL };
HB_CODEPAGE_INIT( SRWIN );
HB_CODEPAGE_INIT( SRWIN )
#if defined(HB_PRAGMA_STARTUP)
#pragma startup hb_codepage_Init_SRWIN

2
harbour/source/common/hbfhnd.c
View File

@@ -90,7 +90,7 @@
void hb_fhnd_ForceLink( void )
{
/* Intentionally do nothing */
};
}
#if defined(__WIN32__) && defined(__BORLANDC__)

2
harbour/source/common/hbstr.c
View File

@@ -358,7 +358,7 @@ HB_EXPORT double hb_numRound( double dNum, int iDec )
* use the similar hack in ==, >=, <=, <, > operations if it's set.
*/
//#define HB_NUM_PRECISION 16
/* #define HB_NUM_PRECISION 16 */
#ifdef HB_NUM_PRECISION
/*

2
harbour/source/common/hbver.c
View File

@@ -298,7 +298,7 @@ HB_EXPORT BOOL hb_iswinnt(void)
OSVERSIONINFO osvi ;
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx (&osvi);
return(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT); // && osvi.dwMajorVersion >= 4);
return(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT); /* && osvi.dwMajorVersion >= 4); */
#else
return FALSE ;
#endif

795
harbour/source/compiler/cmdcheck.c
View File

File diff suppressed because it is too large Load Diff

2
harbour/source/compiler/genc.c
View File

@@ -177,7 +177,7 @@ void hb_compGenCCode( PHB_FNAME pFileName ) /* generates the C language ou
* we are using these two bits to mark the special function used to
* initialize static variables
*/
fprintf( yyc, "{ \"(_INITSTATICS)\", {HB_FS_INITEXIT}, {hb_INITSTATICS}, NULL }" ); /* NOTE: hb_ intentionally in lower case */
fprintf( yyc, "{ \"%s\", {HB_FS_INITEXIT}, {hb_INITSTATICS}, NULL }", pSym->szName ); /* NOTE: hb_ intentionally in lower case */
}
else
{

122
harbour/source/compiler/gencc.c
View File

@@ -76,12 +76,77 @@ static void hb_gencc_string_put( FILE * yyc, BYTE * pText, USHORT usLen )
fputc( '"', yyc );
}
static int hb_gencc_checkJumpCondAhead( LONG lValue, PFUNCTION pFunc, ULONG lPCodePos, PHB_LABEL_INFO cargo,
char * szFunc )
{
if( HB_GENC_GETLABEL( lPCodePos + 1 ) == 0 )
{
switch( pFunc->pCode[ lPCodePos + 1 ] )
{
case HB_P_JUMPFALSENEAR:
fprintf( cargo->yyc, "\tif( hb_xvm%sIntIs( %ld, &fValue ) ) break;\n",
szFunc, lValue );
fprintf( cargo->yyc, "\tif( !fValue )\n\t\tgoto lab%05ld;\n",
HB_GENC_GETLABEL( lPCodePos + 1 +
( signed char ) ( pFunc->pCode[ lPCodePos + 2 ] ) ) );
return 3;
case HB_P_JUMPFALSE:
fprintf( cargo->yyc, "\tif( hb_xvm%sIntIs( %ld, &fValue ) ) break;\n",
szFunc, lValue );
fprintf( cargo->yyc, "\tif( !fValue )\n\t\tgoto lab%05ld;\n",
HB_GENC_GETLABEL( lPCodePos + 1 +
HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 2 ] ) ) );
return 4;
case HB_P_JUMPFALSEFAR:
fprintf( cargo->yyc, "\tif( hb_xvm%sIntIs( %ld, &fValue ) ) break;\n",
szFunc, lValue );
fprintf( cargo->yyc, "\tif( !fValue )\n\t\tgoto lab%05ld;\n",
HB_GENC_GETLABEL( lPCodePos + 1 +
HB_PCODE_MKINT24( &pFunc->pCode[ lPCodePos + 2 ] ) ) );
return 5;
}
}
fprintf( cargo->yyc, "\tif( hb_xvm%sInt( %ld ) ) break;\n",
szFunc, lValue );
return 1;
}
static int hb_gencc_checkNumAhead( LONG lValue, PFUNCTION pFunc, ULONG lPCodePos, PHB_LABEL_INFO cargo )
{
if( HB_GENC_GETLABEL( lPCodePos ) == 0 )
{
switch( pFunc->pCode[ lPCodePos ] )
{
case HB_P_POPLOCAL:
fprintf( cargo->yyc, "\thb_xvmLocalSetInt( %d, %ld );\n",
HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ),
lValue );
return 3;
case HB_P_POPLOCALNEAR:
fprintf( cargo->yyc, "\thb_xvmLocalSetInt( %d, %ld );\n",
( signed char ) pFunc->pCode[ lPCodePos + 1 ], lValue );
return 2;
case HB_P_EQUAL:
case HB_P_EXACTLYEQUAL:
return hb_gencc_checkJumpCondAhead( lValue, pFunc, lPCodePos, cargo, "Equal" );
case HB_P_NOTEQUAL:
return hb_gencc_checkJumpCondAhead( lValue, pFunc, lPCodePos, cargo, "NotEqual" );
case HB_P_GREATER:
return hb_gencc_checkJumpCondAhead( lValue, pFunc, lPCodePos, cargo, "GreaterThen" );
case HB_P_GREATEREQUAL:
return hb_gencc_checkJumpCondAhead( lValue, pFunc, lPCodePos, cargo, "GreaterEqualThen" );
case HB_P_LESS:
return hb_gencc_checkJumpCondAhead( lValue, pFunc, lPCodePos, cargo, "LessThen" );
case HB_P_LESSEQUAL:
return hb_gencc_checkJumpCondAhead( lValue, pFunc, lPCodePos, cargo, "LessEqualThen" );
case HB_P_ARRAYPUSH:
if( lValue > 0 )
{
@@ -118,6 +183,36 @@ static int hb_gencc_checkNumAhead( LONG lValue, PFUNCTION pFunc, ULONG lPCodePos
return 0;
}
static int hb_gencc_checkPlusAhead( PFUNCTION pFunc, ULONG lPCodePos, PHB_LABEL_INFO cargo )
{
if( HB_GENC_GETLABEL( lPCodePos ) == 0 )
{
switch( pFunc->pCode[ lPCodePos ] )
{
case HB_P_POPLOCALNEAR:
fprintf( cargo->yyc, "\thb_xvmLocalAdd( %d );\n",
( signed char ) pFunc->pCode[ lPCodePos + 1 ] );
return 2;
case HB_P_POPLOCAL:
fprintf( cargo->yyc, "\thb_xvmLocalAdd( %d );\n",
HB_PCODE_MKSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) );
return 3;
case HB_P_POPSTATIC:
fprintf( cargo->yyc, "\thb_xvmStaticAdd( %hu );\n",
HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) );
return 3;
case HB_P_POPMEMVAR:
fprintf( cargo->yyc, "\thb_xvmMemvarAdd( symbols + %hu );\n",
HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) );
return 3;
}
}
return 0;
}
static HB_GENC_FUNC( hb_p_and )
{
HB_GENC_LABEL();
@@ -665,8 +760,15 @@ static HB_GENC_FUNC( hb_p_parameter )
static HB_GENC_FUNC( hb_p_plus )
{
int iSkip;
HB_GENC_LABEL();
iSkip = hb_gencc_checkPlusAhead( pFunc, lPCodePos + 1, cargo );
if( iSkip != 0 )
return 1 + iSkip;
fprintf( cargo->yyc, "\tif( hb_xvmPlus() ) break;\n" );
return 1;
}
@@ -736,7 +838,7 @@ static HB_GENC_FUNC( hb_p_poplocalnear )
{
HB_GENC_LABEL();
fprintf( cargo->yyc, "\thb_xvmPopLocal( %hd );\n",
fprintf( cargo->yyc, "\thb_xvmPopLocal( %d );\n",
( signed char ) pFunc->pCode[ lPCodePos + 1 ] );
return 2;
}
@@ -1070,6 +1172,14 @@ static HB_GENC_FUNC( hb_p_pushsym )
{
HB_GENC_LABEL();
if( HB_GENC_GETLABEL( lPCodePos + 3 ) == 0 &&
pFunc->pCode[ lPCodePos + 3 ] == HB_P_PUSHNIL )
{
fprintf( cargo->yyc, "\thb_xvmPushFuncSymbol( symbols + %hu );\n",
HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) );
return 4;
}
fprintf( cargo->yyc, "\thb_xvmPushSymbol( symbols + %hu );\n",
HB_PCODE_MKUSHORT( &pFunc->pCode[ lPCodePos + 1 ] ) );
return 3;
@@ -1079,6 +1189,14 @@ static HB_GENC_FUNC( hb_p_pushsymnear )
{
HB_GENC_LABEL();
if( HB_GENC_GETLABEL( lPCodePos + 2 ) == 0 &&
pFunc->pCode[ lPCodePos + 2 ] == HB_P_PUSHNIL )
{
fprintf( cargo->yyc, "\thb_xvmPushFuncSymbol( symbols + %hu );\n",
pFunc->pCode[ lPCodePos + 1 ] );
return 3;
}
fprintf( cargo->yyc, "\thb_xvmPushSymbol( symbols + %d );\n",
pFunc->pCode[ lPCodePos + 1 ] );
return 2;
@@ -1621,7 +1739,7 @@ void hb_compGenCRealCode( PFUNCTION pFunc, FILE * yyc )
fprintf( yyc, " } while ( 0 );\n" );
if( label_info.fForEach )
fprintf( yyc, " while( lForEachBase )\n {\n\thb_stackRemove( lForEachBase );\n\thb_xvmEnumEnd( &lForEachBase );\n }\n" );
fprintf( yyc, " hb_xvmExitPorc( ulPrivateBase );\n" );
fprintf( yyc, " hb_xvmExitProc( ulPrivateBase );\n" );
fprintf( yyc, "}\n" );
if( label_info.pulLabels )

355
harbour/source/compiler/gencli.c
View File

@@ -102,140 +102,6 @@ void hb_compGenILCode( PHB_FNAME pFileName ) /* generates the IL output */
fprintf( yyc, ".assembly " );
fprintf( yyc, hb_strupr( pFileName->szName ) );
fprintf( yyc, "_PRG{}\n" );
// if( hb_comp_iGenCOutput != HB_COMPGENC_COMPACT )
// fprintf( yyc, "#include \"hbpcode.h\"\n" );
// fprintf( yyc, "#include \"hbinit.h\"\n\n\n" );
// if( ! hb_comp_bStartProc )
// pFunc = pFunc->pNext; /* No implicit starting procedure */
// /* write functions prototypes for PRG defined functions */
// while( pFunc )
// {
// bIsInitFunction = ( pFunc->cScope & HB_FS_INIT ) ;
// bIsExitFunction = ( pFunc->cScope & HB_FS_EXIT ) ;
// bIsStaticVariable = ( pFunc == hb_comp_pInitFunc ) ;
// bIsPublicFunction = ( pFunc->cScope == HB_FS_PUBLIC ) ;
//
// /* Is it a PUBLIC FUNCTION/PROCEDURE */
// if ( bIsPublicFunction )
// fprintf( yyc, "HB_FUNC( %s );\n", pFunc->szName );
// /* Is it a STATIC$ */
// else if ( bIsStaticVariable )
// fprintf( yyc, "static HARBOUR hb_INITSTATICS( void );\n" ); /* NOTE: hb_ intentionally in lower case */
// /* Is it an INIT FUNCTION/PROCEDURE */
// else if ( bIsInitFunction )
// fprintf( yyc, "HB_FUNC_INIT( %s );\n", pFunc->szName );
// /* Is it an EXIT FUNCTION/PROCEDURE */
// else if ( bIsExitFunction )
// fprintf( yyc, "HB_FUNC_EXIT( %s );\n", pFunc->szName );
// /* Then it must be a STATIC FUNCTION/PROCEDURE */
// else
// fprintf( yyc, "HB_FUNC_STATIC( %s );\n", pFunc->szName );
//
// pFunc = pFunc->pNext;
// }
// /* write functions prototypes for inline blocks */
// while( pInline )
// {
// if( pInline->szName )
// fprintf( yyc, "HB_FUNC_STATIC( %s );\n", pInline->szName );
// pInline = pInline->pNext;
// }
// /* write functions prototypes for called functions outside this PRG */
// pFunc = hb_comp_funcalls.pFirst;
// while( pFunc )
// {
// if( hb_compFunctionFind( pFunc->szName ) == NULL &&
// hb_compInlineFind( pFunc->szName ) == NULL )
// fprintf( yyc, "HB_FUNC_EXTERN( %s );\n", pFunc->szName );
//
// pFunc = pFunc->pNext;
// }
// /* writes the symbol table */
// /* Generate the wrapper that will initialize local symbol table
// */
// hb_strupr( pFileName->szName );
// fprintf( yyc, "\n\nHB_INIT_SYMBOLS_BEGIN( hb_vm_SymbolInit_%s%s )\n", hb_comp_szPrefix, pFileName->szName );
// while( pSym )
// {
// if( pSym->szName[ 0 ] == '(' )
// {
// /* Since the normal function cannot be INIT and EXIT at the same time
// * we are using these two bits to mark the special function used to
// * initialize static variables
// */
// fprintf( yyc, "{ \"(_INITSTATICS)\", HB_FS_INIT | HB_FS_EXIT, {hb_INITSTATICS}, NULL }" ); /* NOTE: hb_ intentionally in lower case */
// }
// else
// {
// fprintf( yyc, "{ \"%s\", ", pSym->szName );
//
// if( pSym->cScope & HB_FS_STATIC )
// {
// fprintf( yyc, "HB_FS_STATIC" );
//
// if( pSym->cScope & HB_FS_PUBLIC )
// fprintf( yyc, " | HB_FS_PUBLIC" );
// }
//
// else if( pSym->cScope & HB_FS_INIT )
// fprintf( yyc, "HB_FS_INIT" );
//
// else if( pSym->cScope & HB_FS_EXIT )
// fprintf( yyc, "HB_FS_EXIT" );
//
// else
// fprintf( yyc, "HB_FS_PUBLIC" );
//
// if( pSym->cScope & VS_MEMVAR )
// fprintf( yyc, " | HB_FS_MEMVAR" );
//
// if( pSym->cScope & HB_FS_MESSAGE )
// fprintf( yyc, " | HB_FS_MESSAGE" );
//
// if ( ( pSym->cScope & HB_FS_FIRST ) && ( ! hb_comp_bNoStartUp ) )
// fprintf( yyc, " | HB_FS_FIRST" );
//
// /* specify the function address if it is a defined function or an
// external called function */
// if( hb_compFunctionFind( pSym->szName ) ) /* is it a function defined in this module */
// fprintf( yyc, ", {HB_FUNCNAME( %s )}, NULL }", pSym->szName );
// else if( hb_compFunCallFind( pSym->szName ) ) /* is it a function called from this module */
// fprintf( yyc, ", {HB_FUNCNAME( %s )}, NULL }", pSym->szName );
// else
// fprintf( yyc, ", {NULL}, NULL }" ); /* memvar */
// }
//
// if( pSym != hb_comp_symbols.pLast )
// fprintf( yyc, ",\n" );
//
// pSym = pSym->pNext;
// }
// fprintf( yyc, "\nHB_INIT_SYMBOLS_END( hb_vm_SymbolInit_%s%s )\n"
// "#if defined(_MSC_VER)\n"
// " #if _MSC_VER >= 1010\n"
// /* [pt] First version of MSC I have that supports this */
// /* is msvc4.1 (which is msc 10.10) */
// " #pragma data_seg( \".CRT$XIY\" )\n"
// " #pragma comment( linker, \"/Merge:.CRT=.data\" )\n"
// " #else\n"
// " #pragma data_seg( \"XIY\" )\n"
// " #endif\n"
// " static HB_$INITSYM hb_vm_auto_SymbolInit_%s%s = hb_vm_SymbolInit_%s%s;\n"
// " #pragma data_seg()\n"
// "#elif ! defined(__GNUC__)\n"
// " #pragma startup hb_vm_SymbolInit_%s%s\n"
// "#endif\n\n",
// hb_comp_szPrefix, pFileName->szName,
// hb_comp_szPrefix, pFileName->szName,
// hb_comp_szPrefix, pFileName->szName,
// hb_comp_szPrefix, pFileName->szName );
/* Generate functions data
*/
@@ -282,7 +148,6 @@ void hb_compGenILCode( PHB_FNAME pFileName ) /* generates the IL output */
fprintf( yyc, " ret\n}\n" );
// fprintf( yyc, " hb_vmExecute( pcode, symbols );\n}\n\n" );
pFunc = pFunc->pNext;
}
@@ -316,7 +181,7 @@ void hb_compGenILCode( PHB_FNAME pFileName ) /* generates the IL output */
fprintf( yyc, "/* Empty source file */\n\n" );
}
// Generate .NET support functions
/* Generate .NET support functions */
hb_genNetFunctions( yyc );
fclose( yyc );
@@ -399,7 +264,7 @@ static HB_GENC_FUNC( hb_p_arraypush )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "call object ObjArrayPush( object, object )\n" );
// fprintf( cargo->yyc, "\tHB_P_ARRAYPUSH,\n" );
/* fprintf( cargo->yyc, "\tHB_P_ARRAYPUSH,\n" ); */
return 1;
}
@@ -475,7 +340,7 @@ static HB_GENC_FUNC( hb_p_doshort )
fprintf( cargo->yyc, "call object %s( object )\n", szFunName );
fprintf( cargo->yyc, " pop\n" );
// fprintf( cargo->yyc, "\tHB_P_DOSHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] );
/* fprintf( cargo->yyc, "\tHB_P_DOSHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); */
return 2;
}
@@ -515,7 +380,7 @@ static HB_GENC_FUNC( hb_p_exactlyequal )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "call bool ObjExactlyEqual( object, object )\n" );
// fprintf( cargo->yyc, "\tHB_P_EXACTLYEQUAL,\n" );
/* fprintf( cargo->yyc, "\tHB_P_EXACTLYEQUAL,\n" ); */
return 1;
}
@@ -535,10 +400,6 @@ static HB_GENC_FUNC( hb_p_endproc )
HB_SYMBOL_UNUSED( cargo );
HB_SYMBOL_UNUSED( lPCodePos );
// if( (lPCodePos+1) == pFunc->lPCodePos )
// fprintf( cargo->yyc, "\tHB_P_ENDPROC\n" );
// else
// fprintf( cargo->yyc, "\tHB_P_ENDPROC,\n" );
return 1;
}
@@ -551,8 +412,6 @@ static HB_GENC_FUNC( hb_p_false )
fprintf( cargo->yyc, "ldc.i4.0\n" );
fprintf( cargo->yyc, " box [mscorlib]System.Boolean\n" );
// fprintf( cargo->yyc, "\tHB_P_FALSE,\n" );
return 1;
}
@@ -564,7 +423,6 @@ static HB_GENC_FUNC( hb_p_fortest )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "call bool ObjForTest( object, object, object )\n" );
// fprintf( cargo->yyc, "\tHB_P_FORTEST,\n" );
return 1;
}
@@ -584,12 +442,6 @@ static HB_GENC_FUNC( hb_p_frame )
fprintf( cargo->yyc, " )\n" );
// fprintf( cargo->yyc, "\tHB_P_FRAME, %i, %i,",
// pFunc->pCode[ lPCodePos + 1 ],
// pFunc->pCode[ lPCodePos + 2 ] );
// if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* locals, params */" );
// fprintf( cargo->yyc, "\n" );
return 3;
}
@@ -635,8 +487,6 @@ static HB_GENC_FUNC( hb_p_functionshort )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "call object %s( object )\n", szFunName );
// fprintf( cargo->yyc, "\tHB_P_FUNCTIONHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] );
return 2;
}
@@ -652,12 +502,6 @@ static HB_GENC_FUNC( hb_p_arraygen )
fprintf( cargo->yyc, ")\n" );
// fprintf( cargo->yyc, "\tHB_P_ARRAYGEN, %i, %i,",
// pFunc->pCode[ lPCodePos + 1 ],
// pFunc->pCode[ lPCodePos + 2 ] );
// if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 );
// fprintf( cargo->yyc, "\n" );
return 3;
}
@@ -708,19 +552,6 @@ static HB_GENC_FUNC( hb_p_jumpnear )
fprintf( cargo->yyc, "br.s" );
fprintf( cargo->yyc, " IL_%04lX\n", ( LONG ) ( lPCodePos + lOffset ) );
// fprintf( cargo->yyc, "\tHB_P_JUMPNEAR, %i,",
// pFunc->pCode[ lPCodePos + 1 ] );
// if( cargo->bVerbose )
// {
// LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] );
//
// if( lOffset > 127 )
// lOffset -= 256;
//
// fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) );
// }
// fprintf( cargo->yyc, "\n" );
return 2;
}
@@ -736,20 +567,6 @@ static HB_GENC_FUNC( hb_p_jump )
fprintf( cargo->yyc, "br.s" );
fprintf( cargo->yyc, " IL_%04lX\n", ( LONG ) ( lPCodePos + lOffset ) );
// fprintf( cargo->yyc, "\tHB_P_JUMP, %i, %i,",
// pFunc->pCode[ lPCodePos + 1 ],
// pFunc->pCode[ lPCodePos + 2 ] );
// if( cargo->bVerbose )
// {
// LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 );
//
// if( lOffset > SHRT_MAX )
// lOffset -= 65536;
//
// fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) );
// }
// fprintf( cargo->yyc, "\n" );
return 3;
}
@@ -782,18 +599,6 @@ static HB_GENC_FUNC( hb_p_jumpfalsenear )
fprintf( cargo->yyc, "brfalse.s" );
fprintf( cargo->yyc, " IL_%04lX\n", ( LONG ) ( lPCodePos + lOffset ) );
// fprintf( cargo->yyc, "\tHB_P_JUMPFALSENEAR, %i,",
// pFunc->pCode[ lPCodePos + 1 ] );
// if( cargo->bVerbose )
// {
// LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] );
//
// if( lOffset > 127 )
// lOffset -= 256;
//
// fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) );
// }
// fprintf( cargo->yyc, "\n" );
return 2;
}
@@ -901,7 +706,6 @@ static HB_GENC_FUNC( hb_p_lessequal )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "call bool ObjLessEqual( object, object )\n" );
// fprintf( cargo->yyc, "\tHB_P_LESSEQUAL,\n" );
return 1;
}
@@ -912,16 +716,6 @@ static HB_GENC_FUNC( hb_p_line )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "nop // HB_P_LINE\n" );
// if( cargo->bVerbose )
// fprintf( cargo->yyc, "/* %05li */ ", lPCodePos );
// else
// fprintf( cargo->yyc, "\t" );
// fprintf( cargo->yyc, "HB_P_LINE, %i, %i,",
// pFunc->pCode[ lPCodePos + 1 ],
// pFunc->pCode[ lPCodePos + 2 ] );
// if( cargo->bVerbose )
// fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 );
// fprintf( cargo->yyc, "\n" );
return 3;
}
@@ -1123,8 +917,6 @@ static HB_GENC_FUNC( hb_p_not )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "call object ObjNot( object )\n" );
// fprintf( cargo->yyc, "\tHB_P_NOT,\n" );
return 1;
}
@@ -1163,7 +955,6 @@ static HB_GENC_FUNC( hb_p_plus )
HB_SYMBOL_UNUSED( lPCodePos );
fprintf( cargo->yyc, " call object ObjAdd( object, object )\n" );
// fprintf( cargo->yyc, "\tHB_P_PLUS,\n" );
return 1;
}
@@ -1255,34 +1046,11 @@ static HB_GENC_FUNC( hb_p_poplocal )
static HB_GENC_FUNC( hb_p_poplocalnear )
{
// important: check the below code for codeblock locals management
/* important: check the below code for codeblock locals management */
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
// warning: IL requires zero based locals index
/* warning: IL requires zero based locals index */
fprintf( cargo->yyc, "stloc.%i\n", pFunc->pCode[ lPCodePos + 1 ] - 1 );
// fprintf( cargo->yyc, "\tHB_P_POPLOCALNEAR, %i,",
// pFunc->pCode[ lPCodePos + 1 ] );
// if( cargo->bVerbose )
// {
// char wVar = ( char ) pFunc->pCode[ lPCodePos + 1 ];
// /* Variable with negative order are local variables
// * referenced in a codeblock -handle it with care
// */
//
// if( cargo->iNestedCodeblock )
// {
// /* we are accesing variables within a codeblock */
// /* the names of codeblock variable are lost */
// if( wVar < 0 )
// fprintf( cargo->yyc, "\t/* localvar%i */", -wVar );
// else
// fprintf( cargo->yyc, "\t/* codeblockvar%i */", wVar );
// }
// else
// fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, wVar )->szName );
// }
// fprintf( cargo->yyc, "\n" );
return 2;
}
@@ -1470,17 +1238,11 @@ static HB_GENC_FUNC( hb_p_pushfield )
static HB_GENC_FUNC( hb_p_pushbyte )
{
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
// load constant numeric onto the stack
/* load constant numeric onto the stack */
fprintf( cargo->yyc, "ldc.i4.s %i\n", pFunc->pCode[ lPCodePos + 1 ] );
// turn the stack value into an object
/* turn the stack value into an object */
fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" );
// fprintf( cargo->yyc, "\tHB_P_PUSHBYTE, %i,",
// pFunc->pCode[ lPCodePos + 1 ] );
// if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */",
// pFunc->pCode[ lPCodePos + 1 ] );
// fprintf( cargo->yyc, "\n" );
return 2;
}
@@ -1526,34 +1288,11 @@ static HB_GENC_FUNC( hb_p_pushlocal )
static HB_GENC_FUNC( hb_p_pushlocalnear )
{
// Important: check the below code for codeblocks locals
/* Important: check the below code for codeblocks locals */
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
// Warning: IL uses zero based locals indexes
/* Warning: IL uses zero based locals indexes */
fprintf( cargo->yyc, "ldloc.%i\n", pFunc->pCode[ lPCodePos + 1 ] - 1 );
// fprintf( cargo->yyc, "\tHB_P_PUSHLOCALNEAR, %i,",
// pFunc->pCode[ lPCodePos + 1 ] );
// if( cargo->bVerbose )
// {
// signed char wVar = ( signed char ) pFunc->pCode[ lPCodePos + 1 ];
// /* Variable with negative order are local variables
// * referenced in a codeblock -handle it with care
// */
//
// if( cargo->iNestedCodeblock )
// {
// /* we are accesing variables within a codeblock */
// /* the names of codeblock variable are lost */
// if( wVar < 0 )
// fprintf( cargo->yyc, "\t/* localvar%i */", -wVar );
// else
// fprintf( cargo->yyc, "\t/* codeblockvar%i */", wVar );
// }
// else
// fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, wVar )->szName );
// }
// fprintf( cargo->yyc, "\n" );
return 2;
}
@@ -1592,14 +1331,6 @@ static HB_GENC_FUNC( hb_p_pushlong )
*( ( long * ) &( pFunc->pCode[ lPCodePos + 1 ] ) ) );
fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" );
// fprintf( cargo->yyc, "\tHB_P_PUSHLONG, %i, %i, %i, %i,",
// pFunc->pCode[ lPCodePos + 1 ],
// pFunc->pCode[ lPCodePos + 2 ],
// pFunc->pCode[ lPCodePos + 3 ],
// pFunc->pCode[ lPCodePos + 4 ] );
// if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %li */", *( ( long * ) &( pFunc->pCode[ lPCodePos + 1 ] ) ) );
// fprintf( cargo->yyc, "\n" );
return 5;
}
@@ -1651,18 +1382,20 @@ static HB_GENC_FUNC( hb_p_pushnil )
pTemp->bFirstParam = FALSE;
else
{
// fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
// fprintf( cargo->yyc, "ldnull\n" );
/*
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "ldnull\n" );
*/
}
}
else
{
// fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
// fprintf( cargo->yyc, "ldnull\n" );
/*
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "ldnull\n" );
*/
}
// fprintf( cargo->yyc, " // HB_P_PUSHNIL,\n" );
return 1;
}
@@ -1759,13 +1492,9 @@ static HB_GENC_FUNC( hb_p_pushstrshort )
ULONG ulStart = lPCodePos;
USHORT wLen = pFunc->pCode[ lPCodePos + 1 ];
// fprintf( cargo->yyc, "\tHB_P_PUSHSTRSHORT, %i,", pFunc->pCode[ lPCodePos + 1 ] );
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "ldstr " );
// if( cargo->bVerbose )
// fprintf( cargo->yyc, "\t/* %i */", wLen );
lPCodePos += 2;
if( wLen > 0 )
{
@@ -1828,17 +1557,9 @@ static HB_GENC_FUNC( hb_p_pushsymnear )
pTemp->bFirstParam = TRUE;
pTemp->pNext = NULL;
// fprintf( cargo->yyc, "\tHB_P_PUSHSYMNEAR, %i,",
// pFunc->pCode[ lPCodePos + 1 ] );
// if( cargo->bVerbose )
// fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] )->szName );
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "nop\n" );
// fprintf( cargo->yyc, " call void %s()\n", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] )->szName );
// fprintf( cargo->yyc, "\n" );
return 2;
}
@@ -1981,8 +1702,6 @@ static HB_GENC_FUNC( hb_p_true )
fprintf( cargo->yyc, "ldc.i4.1\n" );
fprintf( cargo->yyc, " box [mscorlib]System.Boolean\n" );
// fprintf( cargo->yyc, "\tHB_P_TRUE,\n" );
return 1;
}
@@ -1993,11 +1712,9 @@ static HB_GENC_FUNC( hb_p_one )
fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos );
fprintf( cargo->yyc, "ldc.i4.1\n" );
// turn the stack value into an object
/* turn the stack value into an object */
fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" );
// fprintf( cargo->yyc, "\tHB_P_ONE,\n" );
return 1;
}
@@ -2087,18 +1804,6 @@ static HB_GENC_FUNC( hb_p_localnearaddint )
fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" );
fprintf( cargo->yyc, " stloc.%i\n", pFunc->pCode[ lPCodePos + 1 ] - 1 );
// fprintf( cargo->yyc, "\tHB_P_LOCALNEARADDINT, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ],
// pFunc->pCode[ lPCodePos + 2 ],
// pFunc->pCode[ lPCodePos + 3 ] );
//
// if( cargo->bVerbose )
// {
// fprintf( cargo->yyc, "\t/* %s %i*/", hb_compLocalVariableFind( pFunc, ( signed char ) pFunc->pCode[ lPCodePos + 1 ] )->szName,
// HB_PCODE_MKSHORT( &( pFunc->pCode[ lPCodePos + 2 ] ) ) );
// }
//
// fprintf( cargo->yyc, "\n" );
return 4;
}
@@ -2257,9 +1962,6 @@ static void hb_compGenCReadable( PFUNCTION pFunc, FILE * yyc )
genc_info.yyc = yyc;
hb_compPCodeEval( pFunc, ( HB_PCODE_FUNC_PTR * ) s_verbose_table, ( void * ) &genc_info );
// if( genc_info.bVerbose )
// fprintf( yyc, "/* %05li */\n", pFunc->lPCodePos );
}
static void hb_compGenCCompact( PFUNCTION pFunc, FILE * yyc )
@@ -2296,6 +1998,7 @@ static void hb_genNetFunctions( FILE * yyc )
{
int i;
/*
// generated IL code for C# source code:
// public static object ObjAdd( object a, object b )
// {
@@ -2309,6 +2012,7 @@ static void hb_genNetFunctions( FILE * yyc )
// }
// VERY IMPORTANT: As ObjAdd() is a public method, not specific to a Class,
// then arguments have to be decreased, as on a normal method, argument 0 is Self.
*/
char * ObjAdd[] = {
"\n.method public static object ObjAdd(object a, object b)",
@@ -2359,6 +2063,7 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_0078: ret",
"}", 0 };
/*
// public static object ObjArrayGen( __arglist )
// {
// ArrayList a = new ArrayList();
@@ -2369,7 +2074,7 @@ static void hb_genNetFunctions( FILE * yyc )
//
// return a;
// }
*/
char * ObjArrayGen[] = {
"\n.method public static vararg object ObjArrayGen()",
"{",
@@ -2401,10 +2106,12 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_0034: ret",
"}", 0 };
/*
// public static object ObjArrayPush( object array, object index )
// {
// return ( ( ArrayList ) array )[ ( ( int ) index ) - 1 ];
// }
*/
char * ObjArrayPush[] = {
"\n.method public static object ObjArrayPush(object 'array', object index)",
@@ -2425,6 +2132,7 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_0018: ret",
"}", 0 };
/*
// public static bool ObjLessEqual( object a, object b )
// {
// if( a.GetType() == typeof( int ) && b.GetType() == typeof( int ) )
@@ -2432,6 +2140,7 @@ static void hb_genNetFunctions( FILE * yyc )
//
// return false;
// }
*/
char * ObjLessEqual[] = {
"\n.method public static bool ObjLessEqual( object a, object b )",
@@ -2466,6 +2175,7 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_003f: ret",
"}", 0 };
/*
// public static bool ObjForTest( object current, object end, object step )
// {
// if( ( int ) step >= 0 )
@@ -2473,6 +2183,7 @@ static void hb_genNetFunctions( FILE * yyc )
// else
// return ( int ) current >= ( int ) end;
// }
*/
char * ObjForTest[] = {
"\n.method public static bool ObjForTest(object current,object end,object step)",
@@ -2510,6 +2221,7 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_0037: ret",
"}", 0 };
/*
// public static bool ObjExactlyEqual( object a, object b )
// {
// if( a.GetType() == typeof( int ) && b.GetType() == typeof( int ) )
@@ -2520,6 +2232,7 @@ static void hb_genNetFunctions( FILE * yyc )
//
// return false;
// }
*/
char * ObjExactlyEqual[] = {
"\n.method public static bool ObjExactlyEqual(object a, object b)",
@@ -2569,10 +2282,12 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_0074: ret",
"}", 0 };
/*
// public static object ObjNot( object o )
// {
// return ! ( bool ) o;
// }
*/
char * ObjNot[] = {
"\n.method public static object ObjNot(object o)",
@@ -2591,10 +2306,12 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_0013: ret",
"}", 0 };
/*
// public static object LEN( object o )
// {
// return ( ( ArrayList ) o ).Count;
// }
*/
char * LEN[] = {
"\n.method public static object LEN(object o)",
@@ -2611,6 +2328,7 @@ static void hb_genNetFunctions( FILE * yyc )
" IL_0014: ret",
"}", 0 };
/*
// public static object QOUT( object o )
// {
// if( o == null )
@@ -2624,6 +2342,7 @@ static void hb_genNetFunctions( FILE * yyc )
//
// return null;
// }
*/
char * QOUT[] = {
"\n.method public static object QOUT(object o)",

19
harbour/source/compiler/harbour.c
View File

@@ -1944,11 +1944,10 @@ void hb_compFunctionAdd( char * szFunName, HB_SYMBOLSCOPE cScope, int iType )
int iLen;
iLen = strlen(szFunName);
szNewName =(char *)hb_xgrab( iLen+2 );
szNewName[0] = '\0';
szNewName = ( char * ) hb_xgrab( iLen + 2 );
strcpy( szNewName, szFunName );
szNewName[ iLen ] ='$';
szNewName[ iLen+1 ] = '\0';
szNewName[ iLen + 1 ] = '\0';
szFunName = hb_compIdentifierNew( szNewName, TRUE );
hb_xfree( szNewName );
}
@@ -2207,13 +2206,13 @@ void hb_compExternGen( void ) /* generates the symbols for the EXTERN names */
{
if( hb_compSymbolFind( hb_comp_pExterns->szName, NULL, HB_SYM_FUNCNAME ) )
{
if( ! hb_compFunCallFind( hb_comp_pExterns->szName ) )
if( ! hb_compFunCallFind( hb_comp_pExterns->szName ) )
hb_compFunCallAdd( hb_comp_pExterns->szName );
}
else
{
hb_compSymbolAdd( hb_comp_pExterns->szName, NULL, HB_SYM_FUNCNAME );
hb_compFunCallAdd( hb_comp_pExterns->szName );
hb_compSymbolAdd( hb_comp_pExterns->szName, NULL, HB_SYM_FUNCNAME );
hb_compFunCallAdd( hb_comp_pExterns->szName );
}
pDelete = hb_comp_pExterns;
hb_comp_pExterns = hb_comp_pExterns->pNext;
@@ -4404,7 +4403,7 @@ void hb_compStaticDefStart( void )
{
BYTE pBuffer[ 5 ];
hb_comp_pInitFunc = hb_compFunctionNew( hb_compIdentifierNew("(_INITSTATICS)", TRUE), HB_FS_INIT );
hb_comp_pInitFunc = hb_compFunctionNew( hb_compIdentifierNew( "(_INITSTATICS)", TRUE ), HB_FS_INITEXIT );
hb_comp_pInitFunc->pOwner = hb_comp_functions.pLast;
hb_comp_pInitFunc->bFlags = FUN_USES_STATICS | FUN_PROCEDURE;
hb_comp_pInitFunc->cScope = HB_FS_INITEXIT;
@@ -4822,7 +4821,7 @@ int hb_compCompile( char * szPrg, int argc, char * argv[] )
{
hb_comp_pFilePpo = hb_fsFNameSplit( szPrg );
hb_compPpoFile();
//hb_comp_pFileName->szExtension = ".ppo";
/*hb_comp_pFileName->szExtension = ".ppo";*/
hb_fsFNameMerge( szPpoName, hb_comp_pFilePpo );
hb_comp_yyppo = fopen( szPpoName, "w" );
if( ! hb_comp_yyppo )
@@ -4909,11 +4908,15 @@ int hb_compCompile( char * szPrg, int argc, char * argv[] )
if( hb_comp_pInitFunc )
{
PCOMSYMBOL pSym;
char szNewName[ 32 ];
/* Fix the number of static variables */
hb_comp_pInitFunc->pCode[ 3 ] = HB_LOBYTE( hb_comp_iStaticCnt );
hb_comp_pInitFunc->pCode[ 4 ] = HB_HIBYTE( hb_comp_iStaticCnt );
hb_comp_pInitFunc->iStaticsBase = hb_comp_iStaticCnt;
/* Update pseudo function name */
sprintf( szNewName, "(_INITSTATICS%05d)", hb_comp_iStaticCnt );
hb_comp_pInitFunc->szName = hb_compIdentifierNew( szNewName, TRUE );
pSym = hb_compSymbolAdd( hb_comp_pInitFunc->szName, NULL, HB_SYM_FUNCNAME );
pSym->cScope |= hb_comp_pInitFunc->cScope;

1
harbour/source/compiler/hbusage.c
View File

@@ -174,6 +174,7 @@ void hb_compPrintCredits( void )
"Paul Tucker <ptucker@sympatico.ca>\n"
"Peter Townsend <cephas@tpgi.com.au>\n"
"Phil Barnett <philb@iag.net>\n"
"Przemyslaw Czerpak <druzus@priv.onet.pl>\n"
"Ron Pinkas <ron@profit-master.com>\n"
"Ryszard Glab <rglab@imid.med.pl>\n"
"Tim Stone <timstone@mstrlink.com>\n"

261
harbour/source/rdd/dbcmd.c
View File

@@ -1061,7 +1061,7 @@ HB_EXPORT ERRCODE hb_rddSelectWorkAreaAlias( char * szAlias )
}
/*
* Function for getting current workarea pointer
* Function for getting current workarea pointer
*/
HB_EXPORT void * hb_rddGetCurrentWorkAreaPointer( void )
{
@@ -4643,262 +4643,3 @@ HB_FUNC( DBSKIPPER )
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, "DBSKIPPER" );
}
#endif
/* Escaping delimited strings. Need to be cleaned/optimized/improved */
static char *hb_strescape( char *szInput, int lLen, char *cDelim )
{
int lCnt = 0;
char * szChr;
char * szEscape;
char * szReturn;
szReturn = szEscape = ( char * ) hb_xgrab( lLen * 2 + 4 );
while( lLen && HB_ISSPACE( szInput[ lLen - 1 ] ) )
{
lLen--;
}
szChr = szInput;
while ( *szChr && lCnt++ < lLen )
{
if( *szChr == *cDelim )
{
*szEscape++ = '\\';
}
*szEscape++ = *szChr++;
}
*szEscape = '\0';
return szReturn;
}
/* Export field values to text file */
#ifndef HB_CDP_SUPPORT_OFF
static BOOL hb_ExportVar( int handle, PHB_ITEM pValue, char *cDelim, PHB_CODEPAGE cdp )
#else
static BOOL hb_ExportVar( int handle, PHB_ITEM pValue, char *cDelim )
#endif
{
switch( hb_itemType( pValue ) )
{
/* a "C" field */
case HB_IT_STRING:
{
char *szStrEsc;
char *szString;
szStrEsc = hb_strescape( hb_itemGetCPtr( pValue ),
hb_itemGetCLen( pValue ), cDelim );
#ifndef HB_CDP_SUPPORT_OFF
if( cdp )
{
hb_cdpnTranslate( szStrEsc, hb_cdp_page, cdp, hb_itemGetCLen( pValue ) );
}
#endif
szString = hb_xstrcpy( NULL,cDelim,szStrEsc,cDelim,NULL);
/* FWrite( handle, szString ) */
hb_fsWriteLarge( handle, (BYTE*) szString, strlen( szString ) );
/* Orphaned, get rif off it */
hb_xfree( szStrEsc );
hb_xfree( szString );
break;
}
/* a "D" field */
case HB_IT_DATE:
{
char *szDate = (char*) hb_xgrab( 9 );
hb_itemGetDS( pValue, szDate );
hb_fsWriteLarge( handle, (BYTE*) szDate, strlen( szDate ) );
hb_xfree( szDate );
break;
}
/* an "L" field */
case HB_IT_LOGICAL:
{
hb_fsWriteLarge( handle, (BYTE*) ( hb_itemGetL( pValue ) ? "T" : "F" ), 1 );
break;
}
/* an "N" field */
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
{
char *szResult = hb_itemStr( pValue, NULL, NULL );
if ( szResult )
{
ULONG ulLen = strlen( szResult );
char * szTrimmed = hb_strLTrim( szResult, &ulLen );
hb_fsWriteLarge( handle, (BYTE*) szTrimmed, strlen( szTrimmed ) );
hb_xfree( szResult );
}
break;
}
/* an "M" field or the other, might be a "V" in SixDriver */
default:
/* We do not want MEMO contents */
return FALSE;
}
return TRUE;
}
HB_FUNC( DBF2TEXT )
{
HB_THREAD_STUB
PHB_ITEM pWhile = hb_param( 1, HB_IT_BLOCK );
PHB_ITEM pFor = hb_param( 2, HB_IT_BLOCK );
PHB_ITEM pFields = hb_param( 3, HB_IT_ARRAY );
char *cDelim = hb_parc( 4 );
FHANDLE handle = (FHANDLE) hb_parnl(5);
BYTE *cSep = (BYTE *) hb_parc( 6 );
int nCount = (int) hb_parnl( 7 );
#ifndef HB_CDP_SUPPORT_OFF
PHB_CODEPAGE cdp = hb_cdpFind( (char *) hb_parc( 8 ) );
#endif
AREAP pArea = HB_CURRENT_WA;
/* Export DBF content to text file */
int iSepLen;
USHORT uiFields = 0;
USHORT ui;
PHB_ITEM pTmp;
BOOL bWriteSep = FALSE;
BOOL bEof = TRUE;
BOOL bBof = TRUE;
BOOL bNoFieldPassed = ( pFields == NULL || hb_arrayLen( pFields ) == 0 );
if( !pArea )
{
hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, "COPY TO" );
return;
}
if( ! handle )
{
hb_errRT_DBCMD( EG_ARG, EDBCMD_EVAL_BADPARAMETER, NULL, "DBF2TEXT" );
return;
}
if( cdp && cdp == hb_cdp_page )
{
cdp = NULL;
}
pTmp = hb_itemNew( NULL );
if ( !cDelim )
{
cDelim = "\"";
}
if ( cSep )
{
iSepLen = strlen( (char*) cSep );
}
else
{
cSep = (BYTE*) ',';
iSepLen = 1;
}
SELF_FIELDCOUNT( pArea, &uiFields );
while( ( nCount == -1 || nCount > 0 ) &&
( !pWhile || hb_itemGetL( hb_vmEvalBlock( pWhile ) ) ) )
{
/* While !BOF() .AND. !EOF() */
SELF_EOF( pArea, &bEof );
SELF_BOF( pArea, &bBof );
if( bEof || bBof )
{
break;
}
/* For condition is met */
/* if For is NULL, hb__Eval returns TRUE */
if( !pFor || hb_itemGetL( hb_vmEvalBlock( pFor ) ) )
{
/* User does not request fields, copy all fields */
if( bNoFieldPassed )
{
for ( ui = 1; ui <= uiFields; ui ++ )
{
if ( bWriteSep )
{
hb_fsWriteLarge( handle, cSep, iSepLen );
}
SELF_GETVALUE( pArea, ui, pTmp );
#ifndef HB_CDP_SUPPORT_OFF
bWriteSep = hb_ExportVar( handle, pTmp, cDelim, cdp );
#else
bWriteSep = hb_ExportVar( handle, pTmp, cDelim );
#endif
hb_itemClear( pTmp );
}
}
/* Only requested fields are exported here */
else
{
USHORT uiFieldCopy = ( USHORT ) hb_arrayLen( pFields );
USHORT uiItter;
for ( uiItter = 1; uiItter <= uiFieldCopy; uiItter++ )
{
char * szFieldName = hb_arrayGetCPtr( pFields, uiItter );
if( szFieldName )
{
int iPos = hb_rddFieldIndex( pArea, szFieldName );
if( iPos )
{
if ( bWriteSep )
{
hb_fsWriteLarge( handle, cSep, iSepLen );
}
SELF_GETVALUE( pArea, iPos, pTmp );
#ifndef HB_CDP_SUPPORT_OFF
bWriteSep = hb_ExportVar( handle, pTmp, cDelim, cdp );
#else
bWriteSep = hb_ExportVar( handle, pTmp, cDelim );
#endif
hb_itemClear( pTmp );
}
}
}
}
hb_fsWriteLarge( handle, (BYTE*) "\r\n", 2 );
bWriteSep = FALSE;
}
if ( nCount != -1 )
{
nCount-- ;
}
/* DBSKIP() */
SELF_SKIP( pArea, 1 );
}
/* Writing EOF */
hb_fsWriteLarge( handle, (BYTE*) "\x1A", 1 );
hb_itemRelease( pTmp );
}

41
harbour/source/rdd/dbf1.c
View File

@@ -2399,23 +2399,11 @@ static ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
if( pArea->fHasMemo )
{
pFileName = hb_fsFNameSplit( ( char * ) szFileName );
pItem = hb_itemPutC( NULL, "" );
errCode = SELF_INFO( ( AREAP ) pArea, DBI_MEMOEXT, pItem );
if( errCode == SUCCESS )
{
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
pArea->szMemoFileName = hb_strdup( ( char * ) szFileName );
}
hb_itemRelease( pItem );
pFileName->szExtension = NULL;
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_xfree( pFileName );
if( errCode == SUCCESS )
{
BYTE *tmp = pCreateInfo->abName;
pCreateInfo->abName = ( BYTE * ) pArea->szMemoFileName;
errCode = SELF_CREATEMEMFILE( ( AREAP ) pArea, pCreateInfo );
pCreateInfo->abName = tmp;
}
pCreateInfo->abName = szFileName;
errCode = SELF_CREATEMEMFILE( ( AREAP ) pArea, pCreateInfo );
}
/* If successful call SUPER_CREATE to finish system jobs */
if( errCode == SUCCESS )
@@ -3156,24 +3144,11 @@ static ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
if( pArea->fHasMemo )
{
pFileName = hb_fsFNameSplit( ( char * ) szFileName );
pFileExt = hb_itemPutC( NULL, "" );
errCode = SELF_INFO( ( AREAP ) pArea, DBI_MEMOEXT, pFileExt );
if( errCode == SUCCESS )
{
pFileName->szExtension = hb_itemGetCPtr( pFileExt );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
}
hb_itemRelease( pFileExt );
pFileName->szExtension = NULL;
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_xfree( pFileName );
if( errCode == SUCCESS )
{
BYTE * tmp = pOpenInfo->abName;
pArea->szMemoFileName = hb_strdup( ( char * ) szFileName );
pOpenInfo->abName = ( BYTE * ) pArea->szMemoFileName;
/* Open memo file and exit if error */
errCode = SELF_OPENMEMFILE( ( AREAP ) pArea, pOpenInfo );
pOpenInfo->abName = tmp;
}
pOpenInfo->abName = szFileName;
errCode = SELF_OPENMEMFILE( ( AREAP ) pArea, pOpenInfo );
}
if( errCode == SUCCESS )

54
harbour/source/rdd/dbffpt/dbffpt1.c
View File

@@ -3783,6 +3783,8 @@ static ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo )
if( pCreateInfo )
{
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
PHB_FNAME pFileName;
PHB_ITEM pError = NULL, pItem = NULL;
BOOL bRetry;
@@ -3808,6 +3810,7 @@ static ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo )
{
hb_memoErrorRT( pArea, EG_CREATE, EDBF_MEMOTYPE,
( char * ) pCreateInfo->abName, 0, 0 );
hb_itemRelease( pItem );
return FAILURE;
}
}
@@ -3838,6 +3841,23 @@ static ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo )
}
pArea->uiMemoBlockSize = hb_itemGetNI( pItem );
}
/* create file name */
pFileName = hb_fsFNameSplit( ( char * ) pCreateInfo->abName );
if( ! pFileName->szExtension )
{
pItem = hb_itemPutC( pItem, "" );
SELF_INFO( ( AREAP ) pArea, DBI_MEMOEXT, pItem );
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
}
else
{
hb_strncpy( ( char * ) szFileName, ( char * ) pCreateInfo->abName, _POSIX_PATH_MAX );
}
hb_xfree( pFileName );
if( pItem )
{
hb_itemRelease( pItem );
@@ -3846,7 +3866,7 @@ static ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo )
/* Try create */
do
{
pArea->hMemoFile = hb_fsExtOpen( pCreateInfo->abName, NULL,
pArea->hMemoFile = hb_fsExtOpen( szFileName, NULL,
FO_READWRITE | FO_EXCLUSIVE | FXO_TRUNCATE |
FXO_DEFAULTS | FXO_SHARELOCK,
NULL, pError );
@@ -3859,7 +3879,7 @@ static ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo )
hb_errPutSubCode( pError, EDBF_CREATE_MEMO );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_CREATE ) );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, ( char * ) pCreateInfo->abName );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY );
}
bRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
@@ -3872,6 +3892,8 @@ static ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo )
if( pArea->hMemoFile == FS_ERROR )
return FAILURE;
pArea->szMemoFileName = hb_strdup( ( char * ) szFileName );
}
else /* For zap file */
hb_fsSeek( pArea->hMemoFile, 0, FS_SET );
@@ -3984,9 +4006,11 @@ static ERRCODE hb_fptGetValueFile( FPTAREAP pArea, USHORT uiIndex, BYTE * szFile
*/
static ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
{
BYTE szFileName[ _POSIX_PATH_MAX + 1 ];
PHB_FNAME pFileName;
PHB_ITEM pError;
USHORT uiFlags;
BOOL bRetry;
PHB_ITEM pError;
HB_TRACE(HB_TR_DEBUG, ("hb_fptOpenMemFile(%p, %p)", pArea, pOpenInfo));
@@ -4004,6 +4028,22 @@ static ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
return FAILURE;
}
/* create file name */
pFileName = hb_fsFNameSplit( ( char * ) pOpenInfo->abName );
if( ! pFileName->szExtension )
{
PHB_ITEM pItem = hb_itemPutC( NULL, "" );
SELF_INFO( ( AREAP ) pArea, DBI_MEMOEXT, pItem );
pFileName->szExtension = hb_itemGetCPtr( pItem );
hb_fsFNameMerge( ( char * ) szFileName, pFileName );
hb_itemRelease( pItem );
}
else
{
hb_strncpy( ( char * ) szFileName, ( char * ) pOpenInfo->abName, _POSIX_PATH_MAX );
}
hb_xfree( pFileName );
uiFlags = (pOpenInfo->fReadonly ? FO_READ : FO_READWRITE) |
(pOpenInfo->fShared ? FO_DENYNONE : FO_EXCLUSIVE);
pError = NULL;
@@ -4011,7 +4051,7 @@ static ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
/* Try open */
do
{
pArea->hMemoFile = hb_fsExtOpen( pOpenInfo->abName, NULL, uiFlags |
pArea->hMemoFile = hb_fsExtOpen( szFileName, NULL, uiFlags |
FXO_DEFAULTS | FXO_SHARELOCK,
NULL, pError );
if( pArea->hMemoFile == FS_ERROR )
@@ -4023,7 +4063,7 @@ static ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
hb_errPutSubCode( pError, EDBF_OPEN_MEMO );
hb_errPutDescription( pError, hb_langDGetErrorDesc( EG_OPEN ) );
hb_errPutOsCode( pError, hb_fsError() );
hb_errPutFileName( pError, ( char * ) pOpenInfo->abName );
hb_errPutFileName( pError, ( char * ) szFileName );
hb_errPutFlags( pError, EF_CANRETRY | EF_CANDEFAULT );
}
bRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
@@ -4038,6 +4078,8 @@ static ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
if( pArea->hMemoFile == FS_ERROR )
return FAILURE;
pArea->szMemoFileName = hb_strdup( ( char * ) szFileName );
if( pArea->bMemoType == DB_MEMO_DBT )
{
pArea->uiMemoBlockSize = DBT_DEFBLOCKSIZE;
@@ -4086,7 +4128,7 @@ static ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
if( pArea->uiMemoBlockSize == 0 )
{
hb_memoErrorRT( pArea, EG_CORRUPTION, EDBF_CORRUPT,
( char * ) pOpenInfo->abName, 0, 0 );
( char * ) pArea->szMemoFileName, 0, 0 );
return FAILURE;
}

58
harbour/source/rtl/errorapi.c
View File

@@ -375,7 +375,7 @@ char * hb_errGetDescription( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "DESCRIPTION" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetCPtr( hb_stackReturnItem() );
}
@@ -387,7 +387,7 @@ PHB_ITEM hb_errPutDescription( PHB_ITEM pError, const char * szDescription )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_DESCRIPTION" ) );
hb_vmPush( pError );
hb_vmPushString( ( char * ) szDescription, strlen( szDescription ) );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -398,7 +398,7 @@ char * hb_errGetFileName( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "FILENAME" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetCPtr( hb_stackReturnItem() );
}
@@ -410,7 +410,7 @@ PHB_ITEM hb_errPutFileName( PHB_ITEM pError, const char * szFileName )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_FILENAME" ) );
hb_vmPush( pError );
hb_vmPushString( ( char * ) szFileName, strlen( szFileName ) );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -421,7 +421,7 @@ USHORT hb_errGetGenCode( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "GENCODE" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetNI( hb_stackReturnItem() );
}
@@ -433,7 +433,7 @@ PHB_ITEM hb_errPutGenCode( PHB_ITEM pError, USHORT uiGenCode )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_GENCODE" ) );
hb_vmPush( pError );
hb_vmPushInteger( uiGenCode );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -444,7 +444,7 @@ char * hb_errGetOperation( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "OPERATION" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetCPtr( hb_stackReturnItem() );
}
@@ -456,7 +456,7 @@ PHB_ITEM hb_errPutOperation( PHB_ITEM pError, const char * szOperation )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_OPERATION" ) );
hb_vmPush( pError );
hb_vmPushString( ( char * ) szOperation, strlen( szOperation ) );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -467,7 +467,7 @@ USHORT hb_errGetOsCode( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "OSCODE" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetNI( hb_stackReturnItem() );
}
@@ -479,7 +479,7 @@ PHB_ITEM hb_errPutOsCode( PHB_ITEM pError, USHORT uiOsCode )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_OSCODE" ) );
hb_vmPush( pError );
hb_vmPushInteger( uiOsCode );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -490,7 +490,7 @@ USHORT hb_errGetSeverity( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "SEVERITY" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetNI( hb_stackReturnItem() );
}
@@ -502,7 +502,7 @@ PHB_ITEM hb_errPutSeverity( PHB_ITEM pError, USHORT uiSeverity )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_SEVERITY" ) );
hb_vmPush( pError );
hb_vmPushInteger( uiSeverity );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -513,7 +513,7 @@ USHORT hb_errGetSubCode( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "SUBCODE" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetNI( hb_stackReturnItem() );
}
@@ -525,7 +525,7 @@ PHB_ITEM hb_errPutSubCode( PHB_ITEM pError, USHORT uiSubCode )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_SUBCODE" ) );
hb_vmPush( pError );
hb_vmPushInteger( uiSubCode );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -536,7 +536,7 @@ char * hb_errGetSubSystem( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "SUBSYSTEM" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetCPtr( hb_stackReturnItem() );
}
@@ -548,7 +548,7 @@ PHB_ITEM hb_errPutSubSystem( PHB_ITEM pError, const char * szSubSystem )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_SUBSYSTEM" ) );
hb_vmPush( pError );
hb_vmPushString( ( char * ) szSubSystem, strlen( szSubSystem ) );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -559,7 +559,7 @@ USHORT hb_errGetTries( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "TRIES" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
return hb_itemGetNI( hb_stackReturnItem() );
}
@@ -571,7 +571,7 @@ PHB_ITEM hb_errPutTries( PHB_ITEM pError, USHORT uiTries )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_TRIES" ) );
hb_vmPush( pError );
hb_vmPushInteger( uiTries );
hb_vmDo( 1 );
hb_vmSend( 1 );
return pError;
}
@@ -586,7 +586,7 @@ USHORT hb_errGetFlags( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "CANRETRY" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
if( hb_itemGetL( hb_stackReturnItem() ) )
uiFlags |= EF_CANRETRY;
@@ -595,7 +595,7 @@ USHORT hb_errGetFlags( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "CANSUBSTITUTE" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
if( hb_itemGetL( hb_stackReturnItem() ) )
uiFlags |= EF_CANSUBSTITUTE;
@@ -604,7 +604,7 @@ USHORT hb_errGetFlags( PHB_ITEM pError )
hb_vmPushSymbol( hb_dynsymGetSymbol( "CANDEFAULT" ) );
hb_vmPush( pError );
hb_vmDo( 0 );
hb_vmSend( 0 );
if( hb_itemGetL( hb_stackReturnItem() ) )
uiFlags |= EF_CANDEFAULT;
@@ -621,21 +621,21 @@ PHB_ITEM hb_errPutFlags( PHB_ITEM pError, USHORT uiFlags )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_CANRETRY" ) );
hb_vmPush( pError );
hb_vmPushLogical( ( uiFlags & EF_CANRETRY ) ? TRUE : FALSE );
hb_vmDo( 1 );
hb_vmSend( 1 );
/* ; */
hb_vmPushSymbol( hb_dynsymGetSymbol( "_CANSUBSTITUTE" ) );
hb_vmPush( pError );
hb_vmPushLogical( ( uiFlags & EF_CANSUBSTITUTE ) ? TRUE : FALSE );
hb_vmDo( 1 );
hb_vmSend( 1 );
/* ; */
hb_vmPushSymbol( hb_dynsymGetSymbol( "_CANDEFAULT" ) );
hb_vmPush( pError );
hb_vmPushLogical( ( uiFlags & EF_CANDEFAULT ) ? TRUE : FALSE );
hb_vmDo( 1 );
hb_vmSend( 1 );
/* ; */
@@ -664,7 +664,7 @@ PHB_ITEM hb_errPutArgs( PHB_ITEM pError, ULONG ulArgCount, ... )
hb_vmPushSymbol( hb_dynsymGetSymbol( "_ARGS" ) );
hb_vmPush( pError );
hb_vmPush( pArray );
hb_vmDo( 1 );
hb_vmSend( 1 );
hb_itemRelease( pArray );
@@ -824,7 +824,7 @@ USHORT hb_errRT_BASE( ULONG ulGenCode, ULONG ulSubCode, const char * szDescripti
hb_vmPushSymbol( hb_dynsymGetSymbol( "_ARGS" ) );
hb_vmPush( pError );
hb_vmPush( pArray );
hb_vmDo( 1 );
hb_vmSend( 1 );
/* Release the Array. */
if( bRelease )
@@ -867,7 +867,7 @@ USHORT hb_errRT_BASE_Ext1( ULONG ulGenCode, ULONG ulSubCode, const char * szDesc
hb_vmPushSymbol( hb_dynsymGetSymbol( "_ARGS" ) );
hb_vmPush( pError );
hb_vmPush( pArray );
hb_vmDo( 1 );
hb_vmSend( 1 );
/* Release the Array. */
hb_itemRelease( pArray );
@@ -906,7 +906,7 @@ PHB_ITEM hb_errRT_BASE_Subst( ULONG ulGenCode, ULONG ulSubCode, const char * szD
hb_vmPushSymbol( hb_dynsymGetSymbol( "_ARGS" ) );
hb_vmPush( pError );
hb_vmPush( pArray );
hb_vmDo( 1 );
hb_vmSend( 1 );
/* Release the Array. */
hb_itemRelease( pArray );
@@ -969,7 +969,7 @@ void hb_errRT_BASE_SubstR( ULONG ulGenCode, ULONG ulSubCode, const char * szDesc
hb_vmPushSymbol( hb_dynsymGetSymbol( "_ARGS" ) );
hb_vmPush( pError );
hb_vmPush( pArray );
hb_vmDo( 1 );
hb_vmSend( 1 );
/* Release the Array. */
if( bRelease )

2
harbour/source/rtl/fstemp.c
View File

@@ -157,7 +157,7 @@ static BOOL fsGetTempDirByCase( BYTE *pszName, const char *pszTempDir )
strcpy( ( char * ) pszName, ( char * ) pszTempDir );
if ( hb_set.HB_SET_DIRCASE == HB_SET_CASE_LOWER || hb_set.HB_SET_DIRCASE == HB_SET_CASE_UPPER )
{
// check to see if temp directory already upper or lower. If not use current directory ( "." )
/* check to see if temp directory already upper or lower. If not use current directory ( "." ) */
char *psZ = ( char * ) pszName ;
int iChar ;
BOOL bLower = hb_set.HB_SET_DIRCASE == HB_SET_CASE_LOWER ;

2
harbour/source/rtl/gtalleg/gtalleg.c
View File

@@ -1188,7 +1188,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

4
harbour/source/rtl/gtalleg/ssf.h
View File

@@ -64,7 +64,7 @@
#include <allegro.h>
// Hack to use old Allegro branches
/* Hack to use old Allegro branches */
#ifndef AL_GFX_NONE
#define AL_GFX_NONE GFX_NONE
#define AL_GFX_SAFE GFX_SAFE
@@ -239,4 +239,4 @@ extern void ssfSetFontSize(ssfFont *sfont, unsigned short fsize);
extern unsigned short ssfDrawChar(AL_BITMAP *dst, ssfFont *sfont, char c, int x, int y, int color);
extern int ssfDrawText(AL_BITMAP *dst, ssfFont *sfont, char *s, int x, int y, int color);
#endif // _SSF_H_
#endif /* _SSF_H_ */

2
harbour/source/rtl/gtcgi/gtcgi.c
View File

@@ -426,7 +426,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtcrs/gtcrs.c
View File

@@ -2970,7 +2970,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtdos/gtdos.c
View File

@@ -1506,7 +1506,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtos2/gtos2.c
View File

@@ -956,7 +956,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtpca/gtpca.c
View File

@@ -958,7 +958,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtsln/gtsln.c
View File

@@ -1059,7 +1059,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtstd/gtstd.c
View File

@@ -685,7 +685,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtwin/gtwin.c
View File

@@ -1949,7 +1949,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtwvt/gtwvt.c
View File

@@ -2079,7 +2079,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/source/rtl/gtxwc/gtxwc.c
View File

@@ -3951,7 +3951,7 @@ static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

4
harbour/source/rtl/hbgtcore.c
View File

@@ -1955,7 +1955,7 @@ static void hb_gt_def_WhoCares( void * pCargo )
/* ************************************************************************* */
#ifdef __GNUC__
#if defined( __GNUC__ ) && 0
static HB_GT_FUNCS gtCoreFunc =
{
Init : hb_gt_def_Init ,
@@ -2834,4 +2834,4 @@ HB_EXPORT void hb_gtStartupInit( void )
HB_FUNC_EXEC( HB_GTSYS );
}
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )

2
harbour/source/rtl/langapi.c
View File

@@ -199,7 +199,7 @@ static HB_LANG s_lang_en =
}
};
HB_LANG_ANNOUNCE( EN );
HB_LANG_ANNOUNCE( EN )
/* Always link in the default language */
/* HB_LANG_REQUEST( HB_LANG_DEFAULT ); */

34
harbour/source/rtl/math.c
View File

@@ -350,16 +350,8 @@ int hb_matherr (HB_MATH_EXCEPTION * pexc)
PHB_ITEM pMatherrResult;
PHB_ITEM pArg1 = hb_itemPutND(NULL, pexc->arg1);
PHB_ITEM pArg2 = hb_itemPutND(NULL, pexc->arg2);
PHB_ITEM pArray;
PHB_ITEM pError;
/* create an array with the two double arguments */
/* NOTE: Unfortunately, we cannot decide whether one or two parameters have been used when the
math function has been called, so we always take two */
pArray = hb_itemArrayNew(2);
hb_itemArrayPut(pArray, 1, pArg1);
hb_itemArrayPut(pArray, 2, pArg2);
/* create an error object */
/* NOTE: In case of HB_MATH_ERRMODE_USER[C]DEFAULT, I am setting both EF_CANSUBSTITUTE and EF_CANDEFAULT to .T. here.
This is forbidden according to the original Cl*pper docs, but I think this reflects the situation best here:
@@ -370,28 +362,24 @@ int hb_matherr (HB_MATH_EXCEPTION * pexc)
(mode == HB_MATH_ERRMODE_USER ? 0: EF_CANDEFAULT));
/* Assign the new array to the object data item. */
hb_vmPushSymbol (hb_dynsymGetSymbol("_ARGS"));
hb_vmPush (pError);
hb_vmPush (pArray);
hb_vmDo (1);
/* Release the Array. */
hb_itemRelease (pArray);
/* NOTE: Unfortunately, we cannot decide whether one or two parameters have been used when the
math function has been called, so we always take two */
hb_errPutArgs( pError, 2, pArg1, pArg2 );
/* launch error codeblock */
pMatherrResult = hb_errLaunchSubst (pError);
hb_errRelease (pError);
if ((pMatherrResult != NULL) && (HB_IS_NUMERIC (pMatherrResult)))
if (pMatherrResult != NULL)
{
pexc->retval = hb_itemGetND (pMatherrResult);
hb_itemGetNLen (pMatherrResult, &(pexc->retvalwidth), &(pexc->retvaldec));
pexc->handled = 1;
if (HB_IS_NUMERIC (pMatherrResult))
{
pexc->retval = hb_itemGetND (pMatherrResult);
hb_itemGetNLen (pMatherrResult, &(pexc->retvalwidth), &(pexc->retvaldec));
pexc->handled = 1;
}
hb_itemRelease (pMatherrResult);
}
hb_itemRelease (pMatherrResult);
hb_itemRelease (pArg1);
hb_itemRelease (pArg2);
}
/* math exception not handled by Harbour error routine above ? */

2
harbour/source/rtl/philes.c
View File

@@ -109,7 +109,7 @@ HB_FUNC( FREAD )
/* Unshare the item to avoid GPF on static buffers and changing
other items which shares this buffer. [druzus] */
pBuffer = hb_itemUnShare( pBuffer );
pBuffer = hb_itemUnShareString( pBuffer );
ulRead = hb_fsReadLarge( hb_parni( 1 ),
( BYTE * ) hb_itemGetCPtr( pBuffer ),

6
harbour/source/rtl/space.c
View File

@@ -58,9 +58,11 @@
HB_FUNC( SPACE )
{
if( ISNUM( 1 ) )
PHB_ITEM pItem = hb_param( 1, HB_IT_NUMERIC );
if( pItem )
{
long lLen = hb_parnl( 1 );
long lLen = hb_itemGetNL( pItem );
if( lLen > 0 )
{

2
harbour/source/rtl/strpeek.c
View File

@@ -84,7 +84,7 @@ HB_FUNC( STRPOKE )
if( ulPos > 0 && ulPos <= hb_itemGetCLen( pText ) )
{
pText = hb_itemUnShare( pText );
pText = hb_itemUnShareString( pText );
hb_itemGetCPtr( pText )[ ulPos - 1 ] = (char) ( hb_parni( 3 ) & 0xff );
}
hb_itemReturn( pText );

97
harbour/source/vm/arrays.c
View File

@@ -76,6 +76,38 @@
#include "hbvm.h"
#include "hbstack.h"
/* This releases array when called from the garbage collector */
static HB_GARBAGE_FUNC( hb_arrayReleaseGarbage )
{
PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) Cargo;
/* clear object tree as needed */
if( pBaseArray->uiClass && pBaseArray->puiClsTree )
{
hb_xfree( pBaseArray->puiClsTree );
pBaseArray->puiClsTree = NULL;
}
if( pBaseArray->pItems )
{
HB_ITEM_PTR pItems = pBaseArray->pItems;
ULONG ulLen = pBaseArray->ulLen;
/* clear the pBaseArray->pItems to avoid infinit loop in cross
* referenced items
*/
pBaseArray->pItems = NULL;
pBaseArray->ulLen = 0;
while( ulLen-- )
{
if( HB_IS_COMPLEX( pItems + ulLen ) )
hb_itemClear( pItems + ulLen );
}
hb_xfree( pItems );
}
}
HB_EXPORT BOOL hb_arrayNew( PHB_ITEM pItem, ULONG ulLen ) /* creates a new array */
{
PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) hb_gcAlloc( sizeof( HB_BASEARRAY ), hb_arrayReleaseGarbage );
@@ -93,7 +125,6 @@ HB_EXPORT BOOL hb_arrayNew( PHB_ITEM pItem, ULONG ulLen ) /* creates a new array
pBaseArray->pItems = NULL;
pBaseArray->ulLen = ulLen;
pBaseArray->ulHolders = 1;
pBaseArray->uiClass = 0;
pBaseArray->uiPrevCls = 0;
pBaseArray->puiClsTree = NULL;
@@ -576,7 +607,7 @@ ULONG hb_arrayScan( PHB_ITEM pArray, PHB_ITEM pValue, ULONG * pulStart, ULONG *
hb_vmPushLong( ulStart + 1 );
hb_vmDo( 2 );
if( HB_IS_LOGICAL( &hb_stack.Return ) && hb_stack.Return.item.asLogical.value )
if( HB_IS_LOGICAL( hb_stackReturnItem() ) && hb_stackReturnItem()->item.asLogical.value )
return ulStart + 1; /* arrays start from 1 */
}
}
@@ -686,41 +717,6 @@ BOOL hb_arrayEval( PHB_ITEM pArray, PHB_ITEM bBlock, ULONG * pulStart, ULONG * p
return FALSE;
}
BOOL hb_arrayRelease( PHB_ITEM pArray )
{
HB_TRACE(HB_TR_DEBUG, ("hb_arrayRelease(%p)", pArray));
if( HB_IS_ARRAY( pArray ) )
{
PHB_BASEARRAY pBaseArray = pArray->item.asArray.value;
ULONG ulLen = pBaseArray->ulLen;
ULONG ulPos;
/* clear object tree as needed */
if( pBaseArray->uiClass && pBaseArray->puiClsTree )
{
hb_xfree(pBaseArray->puiClsTree);
pBaseArray->puiClsTree = NULL;
}
if( pBaseArray->pItems )
{
for( ulPos = 0; ulPos < ulLen; ulPos++ )
hb_itemClear( pBaseArray->pItems + ulPos );
hb_xfree( pBaseArray->pItems );
}
hb_gcFree( ( void * ) pBaseArray );
pArray->type = HB_IT_NIL;
pArray->item.asArray.value = NULL;
return TRUE;
}
else
return FALSE;
}
/* NOTE: CA-Cl*pper 5.3a has a fix for the case when the starting position
is greater than the length of the array. [vszakats] */
@@ -945,30 +941,3 @@ HB_EXPORT PHB_ITEM hb_arrayBaseParams( void )
return pArray;
}
/* This releases array when called from the garbage collector */
HB_GARBAGE_FUNC( hb_arrayReleaseGarbage )
{
PHB_BASEARRAY pBaseArray = ( PHB_BASEARRAY ) Cargo;
if( pBaseArray->pItems )
{
HB_ITEM_PTR pItem = pBaseArray->pItems;
ULONG ulLen = pBaseArray->ulLen;
while( ulLen-- )
{
/* Only strings should be deallocated.
* Arrays, objects and codeblock should be released directly by
* the garbage collector
*/
if( HB_IS_STRING( pItem ) )
hb_itemClear( pItem );
++pItem;
}
hb_xfree( pBaseArray->pItems );
pBaseArray->pItems = NULL;
pBaseArray->ulLen = 0;
}
}

6
harbour/source/vm/arrayshb.c
View File

@@ -108,7 +108,7 @@ HB_FUNC( ARRAY )
}
if( ! bError )
hb_arrayNewRagged( &hb_stack.Return, 1 );
hb_arrayNewRagged( hb_stackReturnItem(), 1 );
}
}
@@ -166,7 +166,7 @@ HB_FUNC( ATAIL )
PHB_ITEM pArray = hb_param( 1, HB_IT_ARRAY );
if( pArray )
hb_arrayLast( pArray, &hb_stack.Return );
hb_arrayLast( pArray, hb_stackReturnItem() );
}
HB_FUNC( AINS )
@@ -335,7 +335,7 @@ HB_FUNC( HB_APARAMS )
HB_FUNC( HB_AEXPRESSIONS )
{
PHB_ITEM pArray = &hb_stack.Return;
PHB_ITEM pArray = hb_stackReturnItem();
PHB_ITEM pLine = hb_param( 1, HB_IT_STRING );
size_t i, iOffset = 0;
int iParans = 0, iArrays = 0, iIndexs = 0;

2
harbour/source/vm/asort.c
View File

@@ -63,8 +63,6 @@
#include "hbvm.h"
#include "hbstack.h"
/* #define HB_ASORT_OPT_ITEMCOPY - use hbsetup.h to enable/disable it*/
static BOOL hb_itemIsLess( PHB_ITEM pItem1, PHB_ITEM pItem2, PHB_ITEM pBlock )
{
if( pBlock )

726
harbour/source/vm/classes.c
View File

File diff suppressed because it is too large Load Diff

168
harbour/source/vm/codebloc.c
View File

@@ -58,6 +58,44 @@
#include "hbvm.h"
#include "hbstack.h"
/* Release all allocated memory when called from the garbage collector
*/
static HB_GARBAGE_FUNC( hb_codeblockDeleteGarbage )
{
HB_CODEBLOCK_PTR pCBlock = ( HB_CODEBLOCK_PTR ) Cargo;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockDeleteGarbage(%p)", Cargo));
/* free space allocated for pcodes - if it was a macro-compiled codeblock
*/
if( pCBlock->pCode && pCBlock->dynBuffer )
{
hb_xfree( pCBlock->pCode );
pCBlock->pCode = NULL;
}
/* free space allocated for local variables
*/
if( pCBlock->pLocals )
{
PHB_ITEM pLocals = pCBlock->pLocals;
USHORT uiLocals = pCBlock->uiLocals;
/* clear pCBlock->pLocals to avoid infinit loop in cross
* referenced items
*/
pCBlock->pLocals = NULL;
pCBlock->uiLocals = 0;
if( hb_xRefDec( pLocals ) )
{
while( uiLocals )
hb_memvarValueDecRef( pLocals[ uiLocals-- ].item.asMemvar.value );
hb_xfree( pLocals );
}
}
}
/* Creates the codeblock structure
*
* pBuffer -> the buffer with pcodes (without HB_P_PUSHBLOCK)
@@ -71,11 +109,12 @@
HB_CODEBLOCK_PTR hb_codeblockNew( const BYTE * pBuffer,
USHORT uiLocals,
const BYTE * pLocalPosTable,
PHB_SYMB pSymbols )
PHB_SYMB pSymbols,
USHORT usLen )
{
HB_CODEBLOCK_PTR pCBlock;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockNew(%p, %hu, %p, %p)", pBuffer, uiLocals, pLocalPosTable, pSymbols));
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockNew(%p, %hu, %p, %p, %hu)", pBuffer, uiLocals, pLocalPosTable, pSymbols, usLen));
pCBlock = ( HB_CODEBLOCK_PTR ) hb_gcAlloc( sizeof( HB_CODEBLOCK ), hb_codeblockDeleteGarbage );
@@ -133,37 +172,41 @@ HB_CODEBLOCK_PTR hb_codeblockNew( const BYTE * pBuffer,
{
HB_CODEBLOCK_PTR pOwner = pLocal->item.asBlock.value;
pCBlock->pLocals = pOwner->pLocals;
pCBlock->uiLocals = uiLocals = pOwner->uiLocals;
pCBlock->uiLocals = pOwner->uiLocals;
pCBlock->pLocals = pOwner->pLocals;
if( pOwner->pLocals )
{ /* the outer codeblock have the table with local references - reuse it */
while( uiLocals )
{
hb_memvarValueIncRef( pCBlock->pLocals[ uiLocals ].item.asMemvar.value );
--uiLocals;
}
/* increment a reference counter for the table of local references
*/
pCBlock->pLocals[ 0 ].item.asLong.value++;
}
hb_xRefInc( pOwner->pLocals );
}
else
pCBlock->pLocals = NULL;
}
/*
* The codeblock pcode is stored in static segment.
* The only allowed operation on a codeblock is evaluating it then
* there is no need to duplicate its pcode - just store the pointer to it
*/
pCBlock->pCode = ( BYTE * ) pBuffer;
pCBlock->dynBuffer = FALSE;
if( usLen )
{
/*
* The codeblock pcode is stored in dynamically allocated memory that
* can be deallocated after creation of a codeblock. We have to duplicate
* the passed buffer
*/
pCBlock->pCode = ( BYTE * ) hb_xgrab( usLen );
memcpy( pCBlock->pCode, pBuffer, usLen );
pCBlock->dynBuffer = TRUE;
}
else
{
/*
* The codeblock pcode is stored in static segment.
* The only allowed operation on a codeblock is evaluating it then
* there is no need to duplicate its pcode - just store the pointer to it
*/
pCBlock->pCode = ( BYTE * ) pBuffer;
pCBlock->dynBuffer = FALSE;
}
pCBlock->pDefSymb = hb_stackBaseItem()->item.asSymbol.value;
pCBlock->pSymbols = pSymbols;
pCBlock->ulCounter = 1;
HB_TRACE(HB_TR_INFO, ("codeblock created (%li) %lx", pCBlock->ulCounter, pCBlock));
HB_TRACE(HB_TR_INFO, ("codeblock created %p", pCBlock));
return pCBlock;
}
@@ -191,86 +234,12 @@ HB_CODEBLOCK_PTR hb_codeblockMacroNew( BYTE * pBuffer, USHORT usLen )
pCBlock->pDefSymb = hb_stackBaseItem()->item.asSymbol.value;
pCBlock->pSymbols = NULL; /* macro-compiled codeblock cannot acces a local symbol table */
pCBlock->ulCounter = 1;
HB_TRACE(HB_TR_INFO, ("codeblock created (%li) %lx", pCBlock->ulCounter, pCBlock));
HB_TRACE(HB_TR_INFO, ("codeblock created %p", pCBlock));
return pCBlock;
}
/* Delete a codeblock
*/
void hb_codeblockDelete( HB_ITEM_PTR pItem )
{
HB_CODEBLOCK_PTR pCBlock = pItem->item.asBlock.value;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockDelete(%p)", pItem));
if( pCBlock && (--pCBlock->ulCounter == 0) )
{
if( pCBlock->pLocals )
{
USHORT ui = pCBlock->uiLocals;
while( ui )
hb_memvarValueDecRef( pCBlock->pLocals[ ui-- ].item.asMemvar.value );
/* decrement the table reference counter and release memory if
* it was the last reference
*/
if( --pCBlock->pLocals[ 0 ].item.asLong.value == 0 )
hb_xfree( pCBlock->pLocals );
}
/* free space allocated for pcodes - if it was a macro-compiled codeblock
*/
if( pCBlock->pCode && pCBlock->dynBuffer )
{
hb_xfree( pCBlock->pCode );
pCBlock->pCode = NULL;
}
/* free space allocated for a CODEBLOCK structure
*/
hb_gcFree( pCBlock );
}
}
/* Release all allocated memory when called from the garbage collector
*/
HB_GARBAGE_FUNC( hb_codeblockDeleteGarbage )
{
HB_CODEBLOCK_PTR pCBlock = ( HB_CODEBLOCK_PTR ) Cargo;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockDeleteGarbage(%p)", Cargo));
/* free space allocated for local variables
*/
if( pCBlock->pLocals )
{
USHORT ui = 1;
while( ui <= pCBlock->uiLocals )
{
hb_memvarValueDecGarbageRef( pCBlock->pLocals[ ui ].item.asMemvar.value );
++ui;
}
/* decrement the table reference counter and release memory if
* it was the last reference
*/
if( --pCBlock->pLocals[ 0 ].item.asLong.value == 0 )
{
hb_xfree( pCBlock->pLocals );
pCBlock->pLocals = NULL;
}
}
/* free space allocated for pcodes - if it was a macro-compiled codeblock
*/
if( pCBlock->pCode && pCBlock->dynBuffer )
{
hb_xfree( pCBlock->pCode );
pCBlock->pCode = NULL;
}
}
/* Evaluate passed codeblock
* Before evaluation we have to switch to a static variable base that
* was defined when the codeblock was created.
@@ -279,13 +248,10 @@ HB_GARBAGE_FUNC( hb_codeblockDeleteGarbage )
*/
void hb_codeblockEvaluate( HB_ITEM_PTR pItem )
{
int iStatics = hb_stack.iStatics;
HB_TRACE(HB_TR_DEBUG, ("hb_codeblockEvaluate(%p)", pItem));
hb_stack.iStatics = pItem->item.asBlock.statics;
hb_vmExecute( pItem->item.asBlock.value->pCode, pItem->item.asBlock.value->pSymbols );
hb_stack.iStatics = iStatics;
}
/* Get local variable referenced in a codeblock

18
harbour/source/vm/debug.c
View File

@@ -61,22 +61,20 @@
* $End$ */
static void AddToArray( PHB_ITEM pItem, PHB_ITEM pReturn, ULONG ulPos )
{
PHB_ITEM pTemp;
HB_TRACE(HB_TR_DEBUG, ("AddToArray(%p, %p, %lu)", pItem, pReturn, ulPos));
if( pItem->type == HB_IT_SYMBOL )
{ /* Symbol is pushed as text */
pTemp = hb_itemNew( NULL ); /* Create temporary string */
pTemp->type = HB_IT_STRING;
pTemp->item.asString.length = strlen( pItem->item.asSymbol.value->szName ) + 2;
pTemp->item.asString.value = ( char * ) hb_xgrab( pTemp->item.asString.length + 1 );
pTemp->item.asString.bStatic = FALSE;
PHB_ITEM pArrayItem = hb_arrayGetItemPtr( pReturn, ulPos );
sprintf( pTemp->item.asString.value, "[%s]", pItem->item.asSymbol.value->szName );
if( pArrayItem )
{
ULONG ulLen = strlen( pItem->item.asSymbol.value->szName ) + 2;
char * szBuff = ( char * ) hb_xgrab( ulLen );
hb_itemArrayPut( pReturn, ulPos, pTemp );
hb_itemRelease( pTemp ); /* Get rid of temporary str.*/
sprintf( szBuff, "[%s]", pItem->item.asSymbol.value->szName );
hb_itemPutCPtr( pArrayItem, szBuff, ulLen );
}
}
else /* Normal types */
hb_itemArrayPut( pReturn, ulPos, pItem );

82
harbour/source/vm/dynlibhb.c
View File

@@ -63,29 +63,101 @@
#include "hbstack.h"
#include "hbvm.h"
#if defined(HB_OS_LINUX) && !defined(__WATCOMC__)
# include <dlfcn.h>
#endif
HB_FUNC( HB_LIBLOAD )
{
void * hDynLib = NULL;
#if defined(HB_OS_WIN_32)
if( hb_parclen( 1 ) > 0 )
{
hb_retnl( ( long ) LoadLibrary( hb_parc( 1 ) ) );
int argc = hb_pcount() - 1, i;
char **argv = NULL;
if( argc > 0 )
{
argv = ( char** ) hb_xgrab( sizeof( char* ) * argc );
for( i = 0; i < argc; ++i )
{
argv[i] = hb_parcx( i + 2 );
}
}
/* use stack address as first level marker */
hb_vmBeginSymbolGroup( ( void * ) &hb_stack, TRUE );
hDynLib = ( void * ) LoadLibrary( hb_parc( 1 ) );
/* set real marker */
hb_vmInitSymbolGroup( hDynLib, argc, argv );
if( argv )
{
hb_xfree( argv );
}
}
#else
#elif defined(HB_OS_LINUX) && !defined(__WATCOMC__)
if( hb_parclen( 1 ) > 0 )
{
hb_retnl( 0 );
int argc = hb_pcount() - 1, i;
char **argv = NULL;
if( argc > 0 )
{
argv = ( char** ) hb_xgrab( sizeof( char* ) * argc );
for( i = 0; i < argc; ++i )
{
argv[i] = hb_parcx( i + 2 );
}
}
/* use stack address as first level marker */
hb_vmBeginSymbolGroup( ( void * ) &hb_stack, TRUE );
hDynLib = ( void * ) dlopen( hb_parc( 1 ), RTLD_LAZY | RTLD_GLOBAL );
/* set real marker */
hb_vmInitSymbolGroup( hDynLib, argc, argv );
if( argv )
{
hb_xfree( argv );
}
}
#endif
hb_retptr( hDynLib );
}
HB_FUNC( HB_LIBFREE )
{
#if defined(HB_OS_WIN_32)
void * hDynLib = hb_parptr( 1 );
if( hDynLib )
{
hb_retl( FreeLibrary( ( HMODULE ) hb_parnl( 1 ) ) );
hb_vmExitSymbolGroup( hDynLib );
hb_retl( FreeLibrary( ( HMODULE ) hDynLib ) );
}
#else
else
#elif defined(HB_OS_LINUX) && !defined(__WATCOMC__)
void * hDynLib = hb_parptr( 1 );
if( hDynLib )
{
hb_vmExitSymbolGroup( hDynLib );
hb_retl( dlclose( hDynLib ) == 0 );
}
else
#endif
{
hb_retl( FALSE );
}
}
HB_FUNC( HB_LIBERROR )
{
#if defined(HB_OS_LINUX) && !defined(__WATCOMC__)
hb_retc( dlerror() );
#else
hb_retc( NULL );
#endif
}

43
harbour/source/vm/dynsym.c
View File

@@ -120,16 +120,14 @@ HB_EXPORT PHB_DYNS hb_dynsymNew( PHB_SYMB pSymbol ) /* creates a new dynamic
if( pDynSym ) /* If name exists */
{
if( pSymbol->scope.value & HB_FS_PUBLIC ) /* only for HB_FS_PUBLIC */
if( !pDynSym->pSymbol->value.pFunPtr && pSymbol->value.pFunPtr ) /* The DynSym existed */
{
if( ( ! pDynSym->pFunPtr ) && pSymbol->value.pFunPtr ) /* The DynSym existed */
{
pDynSym->pFunPtr = pSymbol->value.pFunPtr; /* but had no function ptr assigned */
pDynSym->pSymbol = pSymbol;
pDynSym->ulCalls = 0; /* profiler support */
pDynSym->ulTime = 0; /* profiler support */
pDynSym->ulRecurse = 0;
}
pDynSym->pSymbol = pSymbol;
#ifndef HB_NO_PROFILER
pDynSym->ulCalls = 0; /* profiler support */
pDynSym->ulTime = 0; /* profiler support */
pDynSym->ulRecurse = 0; /* profiler support */
#endif
}
pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */
return pDynSym; /* Return pointer to DynSym */
@@ -158,19 +156,12 @@ HB_EXPORT PHB_DYNS hb_dynsymNew( PHB_SYMB pSymbol ) /* creates a new dynamic
pDynSym->pSymbol = pSymbol;
pDynSym->hMemvar = 0;
pDynSym->hArea = 0;
pDynSym->ulCalls = 0; /* profiler support */
pDynSym->ulTime = 0; /* profiler support */
pDynSym->ulRecurse = 0;
if( pSymbol->scope.value & HB_FS_PUBLIC ) /* only for HB_FS_PUBLIC */
{
pDynSym->pFunPtr = pSymbol->value.pFunPtr; /* place the pointer function at DynSym */
}
else
{
pDynSym->pFunPtr = NULL;
}
pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */
#ifndef HB_NO_PROFILER
pDynSym->ulCalls = 0; /* profiler support */
pDynSym->ulTime = 0; /* profiler support */
pDynSym->ulRecurse = 0; /* profiler support */
#endif
pSymbol->pDynSym = pDynSym; /* place a pointer to DynSym */
return pDynSym;
}
@@ -464,7 +455,7 @@ HB_FUNC( __DYNSISFUN ) /* returns .t. if a symbol has a function/procedure point
long lIndex = hb_parnl( 1 ); /* NOTE: This will return zero if the parameter is not numeric */
if( lIndex >= 1 && lIndex <= s_uiDynSymbols )
hb_retl( s_pDynItems[ lIndex - 1 ].pDynSym->pFunPtr != NULL );
hb_retl( s_pDynItems[ lIndex - 1 ].pDynSym->pSymbol->value.pFunPtr != NULL );
else
hb_retl( FALSE );
}
@@ -473,20 +464,24 @@ HB_FUNC( __DYNSGETPRF ) /* profiler: It returns an array with a function or proc
called and consumed times { nTimes, nTime }
, given the dynamic symbol index */
{
#ifndef HB_NO_PROFILER
long lIndex = hb_parnl( 1 ); /* NOTE: This will return zero if the parameter is not numeric */
#endif
hb_reta( 2 );
hb_stornl( 0, -1, 1 );
hb_stornl( 0, -1, 2 );
#ifndef HB_NO_PROFILER
if( lIndex >= 1 && lIndex <= s_uiDynSymbols )
{
if( s_pDynItems[ lIndex - 1 ].pDynSym->pFunPtr ) /* it is a function or procedure */
if( s_pDynItems[ lIndex - 1 ].pDynSym->pSymbol->value.pFunPtr ) /* it is a function or procedure */
{
hb_stornl( s_pDynItems[ lIndex - 1 ].pDynSym->ulCalls, -1, 1 );
hb_stornl( s_pDynItems[ lIndex - 1 ].pDynSym->ulTime, -1, 2 );
}
}
#endif
}
#endif

30
harbour/source/vm/estack.c
View File

@@ -56,6 +56,7 @@
#include "hbvmopt.h"
#include "hbapi.h"
#include "hbapicls.h"
#include "hbdefs.h"
#include "hbstack.h"
#include "hbapiitm.h"
@@ -88,6 +89,20 @@ void hb_stackPop( void )
hb_itemClear( * hb_stack.pPos );
}
#undef hb_stackPopReturn
void hb_stackPopReturn( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackPopReturn()"));
if( HB_IS_COMPLEX( &hb_stack.Return ) )
hb_itemClear( &hb_stack.Return );
if( --hb_stack.pPos < hb_stack.pItems )
hb_errInternal( HB_EI_STACKUFLOW, NULL, NULL, NULL );
hb_itemRawMove( &hb_stack.Return, * hb_stack.pPos );
}
#undef hb_stackDec
void hb_stackDec( void )
{
@@ -131,6 +146,21 @@ void hb_stackPush( void )
( * hb_stack.pPos )->type = HB_IT_NIL;
}
#undef hb_stackPushReturn
void hb_stackPushReturn( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_stackPushReturn()"));
hb_itemRawMove( * hb_stack.pPos, &hb_stack.Return );
/* enough room for another item ? */
if( ++hb_stack.pPos == hb_stack.pEnd )
hb_stackIncrease();
/* now, push it: */
( * hb_stack.pPos )->type = HB_IT_NIL;
}
void hb_stackIncrease( void )
{
LONG BaseIndex; /* index of stack base */

6
harbour/source/vm/eval.c
View File

@@ -130,7 +130,7 @@ PHB_ITEM hb_evalLaunch( PEVALINFO pEvalInfo )
hb_vmDo( pEvalInfo->paramCount );
pResult = hb_itemNew( NULL );
hb_itemCopy( pResult, &hb_stack.Return );
hb_itemCopy( pResult, hb_stackReturnItem() );
}
else if( HB_IS_BLOCK( pEvalInfo->pItems[ 0 ] ) )
{
@@ -141,7 +141,7 @@ PHB_ITEM hb_evalLaunch( PEVALINFO pEvalInfo )
hb_vmDo( pEvalInfo->paramCount );
pResult = hb_itemNew( NULL );
hb_itemCopy( pResult, &hb_stack.Return );
hb_itemCopy( pResult, hb_stackReturnItem() );
}
else
pResult = NULL;
@@ -297,7 +297,7 @@ PHB_ITEM hb_itemDoC( char * szFunc, ULONG ulPCount, ... )
}
/*
* Notice that these two functions place the result at hb_stack.Return,
* Notice that these two functions place the result at hb_stackReturnItem(),
* that you may access its value using a _par...( -1 ).
*/

114
harbour/source/vm/extend.c
View File

@@ -86,7 +86,7 @@ HB_EXPORT PHB_ITEM hb_param( int iParam, long lMask )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( pItem->type & HB_IT_BYREF )
{
@@ -123,7 +123,7 @@ HB_EXPORT PHB_ITEM hb_paramError( int iParam )
HB_EXPORT BOOL hb_extIsArray( int iParam )
{
if( iParam == -1 )
return HB_IS_ARRAY( &hb_stack.Return );
return HB_IS_ARRAY( hb_stackReturnItem() );
else if( iParam >= 0 && iParam <= hb_pcount() )
return HB_IS_ARRAY( hb_stackItemFromBase( iParam ) );
@@ -138,7 +138,7 @@ HB_EXPORT BOOL hb_extIsArray( int iParam )
HB_EXPORT BOOL hb_extIsObject( int iParam )
{
if( iParam == -1 )
return HB_IS_OBJECT( &hb_stack.Return );
return HB_IS_OBJECT( hb_stackReturnItem() );
else if( iParam >= 0 && iParam <= hb_pcount() )
return HB_IS_OBJECT( hb_stackItemFromBase( iParam ) );
@@ -156,7 +156,7 @@ HB_EXPORT char * hb_parc( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -185,7 +185,7 @@ HB_EXPORT char * hb_parcx( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -214,7 +214,7 @@ HB_EXPORT ULONG hb_parclen( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -247,7 +247,7 @@ HB_EXPORT ULONG hb_parcsiz( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
/* NOTE: hb_parcsiz() will only work for strings passed by reference.
CA-Cl*pper works like this. [vszakats] */
@@ -284,7 +284,7 @@ HB_EXPORT char * hb_pards( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -315,7 +315,7 @@ HB_EXPORT char * hb_pardsbuff( char * szDate, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -346,7 +346,7 @@ HB_EXPORT LONG hb_pardl( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
{
@@ -380,7 +380,7 @@ HB_EXPORT int hb_parl( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -415,7 +415,7 @@ HB_EXPORT double hb_parnd( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -448,7 +448,7 @@ HB_EXPORT int hb_parni( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -481,7 +481,7 @@ HB_EXPORT long hb_parnl( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -521,7 +521,7 @@ HB_EXPORT LONGLONG hb_parnll( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -561,7 +561,7 @@ HB_EXPORT HB_LONG hb_parnint( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -600,7 +600,7 @@ HB_EXPORT void * hb_parptr( int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
if( HB_IS_BYREF( pItem ) )
pItem = hb_itemUnRef( pItem );
@@ -652,11 +652,11 @@ HB_EXPORT ULONG hb_parinfo( int iParam )
{
if( ( iParam > 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
HB_TYPE uiType = ( iParam == -1 ) ? hb_stack.Return.type : ( hb_stackItemFromBase( iParam ) )->type;
HB_TYPE uiType = ( iParam == -1 ) ? hb_stackReturnItem()->type : ( hb_stackItemFromBase( iParam ) )->type;
if( uiType & HB_IT_BYREF )
{
PHB_ITEM pItem = hb_itemUnRef( ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam ) );
PHB_ITEM pItem = hb_itemUnRef( ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam ) );
if( pItem )
uiType |= pItem->type;
@@ -674,7 +674,7 @@ HB_EXPORT void hb_ret( void )
{
HB_TRACE(HB_TR_DEBUG, ("hb_ret()"));
hb_itemClear( &hb_stack.Return );
hb_itemClear( hb_stackReturnItem() );
}
#undef hb_reta
@@ -682,7 +682,7 @@ HB_EXPORT void hb_reta( ULONG ulLen ) /* undocumented hb_reta() */
{
HB_TRACE(HB_TR_DEBUG, ("hb_reta(%lu)", ulLen));
hb_arrayNew( &hb_stack.Return, ulLen );
hb_arrayNew( hb_stackReturnItem(), ulLen );
}
#undef hb_retc
@@ -690,7 +690,7 @@ HB_EXPORT void hb_retc( const char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retc(%s)", szText));
hb_itemPutC( &hb_stack.Return, szText );
hb_itemPutC( hb_stackReturnItem(), szText );
}
#undef hb_retc_buffer
@@ -698,7 +698,7 @@ HB_EXPORT void hb_retc_buffer( char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retc_buffer(%s)", szText));
hb_itemPutCPtr( &hb_stack.Return, szText, strlen( szText ) );
hb_itemPutCPtr( hb_stackReturnItem(), szText, strlen( szText ) );
}
#undef hb_retc_const
@@ -706,7 +706,7 @@ HB_EXPORT void hb_retc_const( const char * szText )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retc_const(%s)", szText));
hb_itemPutCConst( &hb_stack.Return, szText );
hb_itemPutCConst( hb_stackReturnItem(), szText );
}
#undef hb_retclen
@@ -714,7 +714,7 @@ HB_EXPORT void hb_retclen( const char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retclen(%s, %lu)", szText, ulLen));
hb_itemPutCL( &hb_stack.Return, szText, ulLen );
hb_itemPutCL( hb_stackReturnItem(), szText, ulLen );
}
#undef hb_retclen_buffer
@@ -722,7 +722,7 @@ HB_EXPORT void hb_retclen_buffer( char * szText, ULONG ulLen )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retclen_buffer(%s, %lu)", szText, ulLen));
hb_itemPutCPtr( &hb_stack.Return, szText, ulLen );
hb_itemPutCPtr( hb_stackReturnItem(), szText, ulLen );
}
#undef hb_retcAdopt
@@ -736,7 +736,7 @@ HB_EXPORT void hb_retcAdopt( char * szText )
*/
HB_TRACE_STEALTH( HB_TR_INFO, ("hb_retcAdopt(%s)", szText ) );
hb_itemPutCPtr( &hb_stack.Return, szText, strlen( szText ) );
hb_itemPutCPtr( hb_stackReturnItem(), szText, strlen( szText ) );
}
/* szDate must have YYYYMMDD format */
@@ -746,7 +746,7 @@ HB_EXPORT void hb_retds( const char * szDate )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retds(%s)", szDate));
hb_itemPutDS( &hb_stack.Return, szDate );
hb_itemPutDS( hb_stackReturnItem(), szDate );
}
#undef hb_retd
@@ -754,7 +754,7 @@ HB_EXPORT void hb_retd( int iYear, int iMonth, int iDay )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retd(%04i, %02i, %02i)", iYear, iMonth, iDay));
hb_itemPutD( &hb_stack.Return, iYear, iMonth, iDay );
hb_itemPutD( hb_stackReturnItem(), iYear, iMonth, iDay );
}
#undef hb_retdl
@@ -762,7 +762,7 @@ HB_EXPORT void hb_retdl( long lJulian )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retdl(%ld)", lJulian));
hb_itemPutDL( &hb_stack.Return, lJulian );
hb_itemPutDL( hb_stackReturnItem(), lJulian );
}
#undef hb_retl
@@ -770,7 +770,7 @@ HB_EXPORT void hb_retl( int iLogical )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retl(%d)", iLogical));
hb_itemPutL( &hb_stack.Return, iLogical ? TRUE : FALSE );
hb_itemPutL( hb_stackReturnItem(), iLogical ? TRUE : FALSE );
}
#undef hb_retnd
@@ -778,7 +778,7 @@ HB_EXPORT void hb_retnd( double dNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnd(%lf)", dNumber));
hb_itemPutND( &hb_stack.Return, dNumber );
hb_itemPutND( hb_stackReturnItem(), dNumber );
}
#undef hb_retni
@@ -786,7 +786,7 @@ HB_EXPORT void hb_retni( int iNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retni(%d)", iNumber));
hb_itemPutNI( &hb_stack.Return, iNumber );
hb_itemPutNI( hb_stackReturnItem(), iNumber );
}
#undef hb_retnl
@@ -794,7 +794,7 @@ HB_EXPORT void hb_retnl( long lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnl(%ld)", lNumber));
hb_itemPutNL( &hb_stack.Return, lNumber );
hb_itemPutNL( hb_stackReturnItem(), lNumber );
}
#ifndef HB_LONG_LONG_OFF
@@ -803,7 +803,7 @@ HB_EXPORT void hb_retnll( LONGLONG llNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnll(%" PFLL "d)", llNumber));
hb_itemPutNLL( &hb_stack.Return, llNumber );
hb_itemPutNLL( hb_stackReturnItem(), llNumber );
}
#endif
@@ -812,7 +812,7 @@ HB_EXPORT void hb_retnint( HB_LONG lNumber )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnl(%ld)", lNumber));
hb_itemPutNInt( &hb_stack.Return, lNumber );
hb_itemPutNInt( hb_stackReturnItem(), lNumber );
}
#undef hb_retnlen
@@ -820,7 +820,7 @@ HB_EXPORT void hb_retnlen( double dNumber, int iWidth, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnlen(%lf, %d, %d)", dNumber, iWidth, iDec));
hb_itemPutNLen( &hb_stack.Return, dNumber, iWidth, iDec );
hb_itemPutNLen( hb_stackReturnItem(), dNumber, iWidth, iDec );
}
#undef hb_retndlen
@@ -828,7 +828,7 @@ HB_EXPORT void hb_retndlen( double dNumber, int iWidth, int iDec )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retndlen(%lf, %d, %d)", dNumber, iWidth, iDec));
hb_itemPutNDLen( &hb_stack.Return, dNumber, iWidth, iDec );
hb_itemPutNDLen( hb_stackReturnItem(), dNumber, iWidth, iDec );
}
#undef hb_retnilen
@@ -836,7 +836,7 @@ HB_EXPORT void hb_retnilen( int iNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnilen(%d, %d)", iNumber, iWidth));
hb_itemPutNILen( &hb_stack.Return, iNumber, iWidth );
hb_itemPutNILen( hb_stackReturnItem(), iNumber, iWidth );
}
#undef hb_retnllen
@@ -844,7 +844,7 @@ HB_EXPORT void hb_retnllen( long lNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnllen(%ld, %d)", lNumber, iWidth));
hb_itemPutNLLen( &hb_stack.Return, lNumber, iWidth );
hb_itemPutNLLen( hb_stackReturnItem(), lNumber, iWidth );
}
#ifndef HB_LONG_LONG_OFF
@@ -853,7 +853,7 @@ HB_EXPORT void hb_retnlllen( LONGLONG llNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnlllen(%" PFLL "d, %d)", llNumber, iWidth));
hb_itemPutNLLLen( &hb_stack.Return, llNumber, iWidth );
hb_itemPutNLLLen( hb_stackReturnItem(), llNumber, iWidth );
}
#endif
@@ -862,7 +862,7 @@ HB_EXPORT void hb_retnintlen( HB_LONG lNumber, int iWidth )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retnintlen(%" PFHL "d, %d)", lNumber, iWidth));
hb_itemPutNIntLen( &hb_stack.Return, lNumber, iWidth );
hb_itemPutNIntLen( hb_stackReturnItem(), lNumber, iWidth );
}
#undef hb_retptr
@@ -870,7 +870,15 @@ HB_EXPORT void hb_retptr( void * pointer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retptr(%p)", pointer));
hb_itemPutPtr( &hb_stack.Return, pointer );
hb_itemPutPtr( hb_stackReturnItem(), pointer );
}
#undef hb_retptrGC
void HB_EXPORT hb_retptrGC( void * pointer )
{
HB_TRACE(HB_TR_DEBUG, ("hb_retptrGC(%p)", pointer));
hb_itemPutPtrGC( hb_stackReturnItem(), pointer );
}
@@ -880,7 +888,7 @@ HB_EXPORT int hb_storc( char * szText, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -914,7 +922,7 @@ HB_EXPORT int hb_storclen( char * szText, ULONG ulLen, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -950,7 +958,7 @@ HB_EXPORT int hb_stords( char * szDate, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -984,7 +992,7 @@ HB_EXPORT int hb_storl( int iLogical, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -1018,7 +1026,7 @@ HB_EXPORT int hb_storni( int iValue, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -1052,7 +1060,7 @@ HB_EXPORT int hb_stornl( long lValue, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -1087,7 +1095,7 @@ HB_EXPORT int hb_stornll( LONGLONG llValue, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -1122,7 +1130,7 @@ HB_EXPORT int hb_stornint( HB_LONG lValue, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -1156,7 +1164,7 @@ HB_EXPORT int hb_stornd( double dNumber, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )
@@ -1190,7 +1198,7 @@ HB_EXPORT int hb_storptr( void * pointer, int iParam, ... )
if( ( iParam >= 0 && iParam <= hb_pcount() ) || ( iParam == -1 ) )
{
PHB_ITEM pItem = ( iParam == -1 ) ? &hb_stack.Return : hb_stackItemFromBase( iParam );
PHB_ITEM pItem = ( iParam == -1 ) ? hb_stackReturnItem() : hb_stackItemFromBase( iParam );
BOOL bByRef = HB_IS_BYREF( pItem );
if( bByRef )

392
harbour/source/vm/fm.c
View File

@@ -88,6 +88,7 @@
/* #define HB_PARANOID_MEM_CHECK */
/*#undef HB_FM_STATISTICS*/
#ifndef HB_FM_STATISTICS
# undef HB_PARANOID_MEM_CHECK
#endif
@@ -96,6 +97,7 @@
#define HB_TR_LEVEL HB_TR_ERROR
#endif
#ifdef HB_FM_STATISTICS
#ifndef HB_MEMFILER
@@ -105,21 +107,34 @@
typedef struct _HB_MEMINFO
{
ULONG ulSignature;
ULONG ulSize;
USHORT uiProcLine;
char szProcName[ HB_SYMBOL_NAME_LEN + 1 ];
UINT32 u32Signature;
ULONG ulSize;
USHORT uiProcLine;
char szProcName[ HB_SYMBOL_NAME_LEN + 1 ];
struct _HB_MEMINFO * pPrevBlock;
struct _HB_MEMINFO * pNextBlock;
} HB_MEMINFO, * PHB_MEMINFO;
#ifdef HB_ALLOC_ALIGNMENT
# define HB_MEMINFO_SIZE ( ( sizeof( HB_MEMINFO ) + HB_ALLOC_ALIGNMENT - 1 ) - \
( sizeof( HB_MEMINFO ) + HB_ALLOC_ALIGNMENT - 1 ) % HB_ALLOC_ALIGNMENT )
# define HB_MEMINFO_SIZE ( ( ( sizeof( HB_MEMINFO ) + HB_ALLOC_ALIGNMENT - 1 ) - \
( sizeof( HB_MEMINFO ) + HB_ALLOC_ALIGNMENT - 1 ) % HB_ALLOC_ALIGNMENT ) + \
HB_COUNTER_OFFSET )
#else
# define HB_MEMINFO_SIZE sizeof( HB_MEMINFO )
# define HB_MEMINFO_SIZE ( sizeof( HB_MEMINFO ) + HB_COUNTER_OFFSET )
#endif
#define HB_ALLOC_SIZE( n ) ( ( n ) + HB_MEMINFO_SIZE + sizeof( UINT32 ) )
#define HB_FM_PTR( p ) ( ( PHB_MEMINFO ) ( ( BYTE * ) ( p ) - HB_MEMINFO_SIZE ) )
#define HB_FM_GETSIG( p, n ) HB_GET_UINT32( ( BYTE * )( p ) + ( n ) )
#define HB_FM_SETSIG( p, n ) HB_PUT_UINT32( ( BYTE * )( p ) + ( n ), HB_MEMINFO_SIGNATURE )
#define HB_FM_CLRSIG( p, n ) HB_PUT_UINT32( ( BYTE * )( p ) + ( n ), 0 )
/* NOTE: we cannot use here HB_TRACE because it will overwrite the
* function name/line number of code which called hb_xalloc/hb_xgrab
*/
#define HB_TRACE_FM HB_TRACE_STEALTH
static LONG s_lMemoryBlocks = 0; /* memory blocks used */
static LONG s_lMemoryMaxBlocks = 0; /* maximum number of used memory blocks */
static LONG s_lMemoryMaxConsumed = 0; /* memory size consumed */
@@ -128,44 +143,50 @@ static LONG s_lMemoryConsumed = 0; /* memory max size consumed */
static PHB_MEMINFO s_pFirstBlock = NULL;
static PHB_MEMINFO s_pLastBlock = NULL;
#endif
#else /* ! HB_FM_STATISTICS */
typedef void * PHB_MEMINFO;
#define HB_MEMINFO_SIZE HB_COUNTER_OFFSET
#define HB_ALLOC_SIZE( n ) ( ( n ) + HB_MEMINFO_SIZE )
#define HB_FM_PTR( p ) HB_COUNTER_PTR( p )
#define HB_TRACE_FM HB_TRACE
#endif /* HB_FM_STATISTICS */
#define HB_MEM_PTR( p ) ( ( void * ) ( ( BYTE * ) ( p ) + HB_MEMINFO_SIZE ) )
HB_EXPORT void * hb_xalloc( ULONG ulSize ) /* allocates fixed memory, returns NULL on failure */
{
PHB_MEMINFO pMem;
#ifdef HB_FM_STATISTICS
void * pMem;
/* NOTE: we cannot use here HB_TRACE because it will overwrite the
* function name/line number of code which called hb_xalloc/hb_xgrab
*/
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_xalloc(%lu)", ulSize));
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xalloc(%lu)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XALLOCNULLSIZE, NULL, NULL, NULL );
pMem = malloc( ulSize + HB_MEMINFO_SIZE + sizeof( ULONG ) );
pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) );
if( ! pMem )
return pMem;
#ifdef HB_FM_STATISTICS
if( ! s_pFirstBlock )
{
( ( PHB_MEMINFO ) pMem )->pPrevBlock = NULL;
s_pFirstBlock = ( PHB_MEMINFO ) pMem;
pMem->pPrevBlock = NULL;
s_pFirstBlock = pMem;
}
else
{
( ( PHB_MEMINFO ) pMem )->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = ( PHB_MEMINFO ) pMem;
pMem->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = pMem;
}
s_pLastBlock = ( PHB_MEMINFO ) pMem;
s_pLastBlock = pMem;
( ( PHB_MEMINFO ) pMem )->pNextBlock = NULL;
( ( PHB_MEMINFO ) pMem )->ulSignature = HB_MEMINFO_SIGNATURE;
HB_PUT_LONG( ( ( BYTE * ) pMem ) + ulSize + HB_MEMINFO_SIZE, HB_MEMINFO_SIGNATURE );
( ( PHB_MEMINFO ) pMem )->ulSize = ulSize; /* size of the memory block */
pMem->pNextBlock = NULL;
pMem->u32Signature = HB_MEMINFO_SIGNATURE;
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
pMem->ulSize = ulSize; /* size of the memory block */
if( hb_tr_level() >= HB_TR_DEBUG )
{
@@ -174,25 +195,25 @@ HB_EXPORT void * hb_xalloc( ULONG ulSize ) /* allocates fixed memory, re
* function/line info - this is a location of code that called
* hb_xalloc/hb_xgrab
*/
( ( PHB_MEMINFO ) pMem )->uiProcLine = hb_tr_line_; /* C line number */
strcpy( ( ( PHB_MEMINFO ) pMem )->szProcName, hb_tr_file_ );
pMem->uiProcLine = hb_tr_line_; /* C line number */
strcpy( pMem->szProcName, hb_tr_file_ );
}
else
{
if( hb_stack.pItems && ( hb_stack.pBase != hb_stack.pItems ) )
{
( ( PHB_MEMINFO ) pMem )->uiProcLine = ( hb_stackBaseItem() )->item.asSymbol.lineno; /* PRG line number */
strcpy( ( ( PHB_MEMINFO ) pMem )->szProcName,
pMem->uiProcLine = ( hb_stackBaseItem() )->item.asSymbol.lineno; /* PRG line number */
strcpy( pMem->szProcName,
( hb_stackBaseItem() )->item.asSymbol.value->szName ); /* PRG ProcName */
}
else
{
( ( PHB_MEMINFO ) pMem )->uiProcLine = 0; /* PRG line number */
( ( PHB_MEMINFO ) pMem )->szProcName[ 0 ] = '\0'; /* PRG ProcName */
pMem->uiProcLine = 0; /* PRG line number */
pMem->szProcName[ 0 ] = '\0'; /* PRG ProcName */
}
}
s_lMemoryConsumed += ulSize;
s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
s_lMemoryBlocks++;
@@ -200,57 +221,47 @@ HB_EXPORT void * hb_xalloc( ULONG ulSize ) /* allocates fixed memory, re
s_lMemoryMaxBlocks = s_lMemoryBlocks;
#ifdef HB_PARANOID_MEM_CHECK
memset( ( char * ) pMem + HB_MEMINFO_SIZE, HB_MEMFILER, ulSize );
memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize );
#endif
return ( void * ) ( ( BYTE * ) pMem + HB_MEMINFO_SIZE );
#else
HB_TRACE(HB_TR_DEBUG, ("hb_xalloc(%lu)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XALLOCNULLSIZE, NULL, NULL, NULL );
return malloc( ulSize );
#endif
* HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ) = 1;
return HB_MEM_PTR( pMem );
}
HB_EXPORT void * hb_xgrab( ULONG ulSize ) /* allocates fixed memory, exits on failure */
{
void * pMem;
PHB_MEMINFO pMem;
/* NOTE: we cannot use here HB_TRACE because it will overwrite the
* function name/line number of code which called hb_xalloc/hb_xgrab
*/
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_xgrab(%lu)", ulSize));
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xgrab(%lu)", ulSize));
if( ulSize == 0 )
hb_errInternal( HB_EI_XGRABNULLSIZE, NULL, NULL, NULL );
#ifdef HB_FM_STATISTICS
pMem = malloc( ulSize + HB_MEMINFO_SIZE + sizeof( ULONG ) );
pMem = ( PHB_MEMINFO ) malloc( HB_ALLOC_SIZE( ulSize ) );
if( ! pMem )
hb_errInternal( HB_EI_XGRABALLOC, NULL, NULL, NULL );
#ifdef HB_FM_STATISTICS
if( ! s_pFirstBlock )
{
( ( PHB_MEMINFO ) pMem )->pPrevBlock = NULL;
s_pFirstBlock = ( PHB_MEMINFO ) pMem;
pMem->pPrevBlock = NULL;
s_pFirstBlock = pMem;
}
else
{
( ( PHB_MEMINFO ) pMem )->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = ( PHB_MEMINFO ) pMem;
pMem->pPrevBlock = s_pLastBlock;
s_pLastBlock->pNextBlock = pMem;
}
s_pLastBlock = ( PHB_MEMINFO ) pMem;
s_pLastBlock = pMem;
( ( PHB_MEMINFO ) pMem )->pNextBlock = NULL;
( ( PHB_MEMINFO ) pMem )->ulSignature = HB_MEMINFO_SIGNATURE;
HB_PUT_LONG( ( ( BYTE * ) pMem ) + ulSize + HB_MEMINFO_SIZE, HB_MEMINFO_SIGNATURE );
( ( PHB_MEMINFO ) pMem )->ulSize = ulSize; /* size of the memory block */
pMem->pNextBlock = NULL;
pMem->u32Signature = HB_MEMINFO_SIGNATURE;
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
pMem->ulSize = ulSize; /* size of the memory block */
if( hb_tr_level() >= HB_TR_DEBUG )
{
@@ -259,25 +270,25 @@ HB_EXPORT void * hb_xgrab( ULONG ulSize ) /* allocates fixed memory, exi
* function/line info - this is a location of code that called
* hb_xalloc/hb_xgrab
*/
( ( PHB_MEMINFO ) pMem )->uiProcLine = hb_tr_line_; /* C line number */
strcpy( ( ( PHB_MEMINFO ) pMem )->szProcName, hb_tr_file_ );
pMem->uiProcLine = hb_tr_line_; /* C line number */
strcpy( pMem->szProcName, hb_tr_file_ );
}
else
{
if( hb_stack.pItems && ( hb_stack.pBase != hb_stack.pItems ) )
{
( ( PHB_MEMINFO ) pMem )->uiProcLine = ( hb_stackBaseItem() )->item.asSymbol.lineno; /* PRG line number */
strcpy( ( ( PHB_MEMINFO ) pMem )->szProcName,
pMem->uiProcLine = ( hb_stackBaseItem() )->item.asSymbol.lineno; /* PRG line number */
strcpy( pMem->szProcName,
( hb_stackBaseItem() )->item.asSymbol.value->szName ); /* PRG ProcName */
}
else
{
( ( PHB_MEMINFO ) pMem )->uiProcLine = 0; /* PRG line number */
( ( PHB_MEMINFO ) pMem )->szProcName[ 0 ] = '\0'; /* PRG ProcName */
pMem->uiProcLine = 0; /* PRG line number */
pMem->szProcName[ 0 ] = '\0'; /* PRG ProcName */
}
}
s_lMemoryConsumed += ulSize;
s_lMemoryConsumed += ulSize + sizeof( HB_COUNTER );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
s_lMemoryBlocks++;
@@ -285,30 +296,19 @@ HB_EXPORT void * hb_xgrab( ULONG ulSize ) /* allocates fixed memory, exi
s_lMemoryMaxBlocks = s_lMemoryBlocks;
#ifdef HB_PARANOID_MEM_CHECK
memset( ( char * ) pMem + HB_MEMINFO_SIZE, HB_MEMFILER, ulSize );
memset( HB_MEM_PTR( pMem ), HB_MEMFILER, ulSize );
#endif
return ( void * ) ( ( BYTE * ) pMem + HB_MEMINFO_SIZE );
#else
pMem = malloc( ulSize );
if( ! pMem )
hb_errInternal( HB_EI_XGRABALLOC, NULL, NULL, NULL );
return pMem;
#endif
* HB_COUNTER_PTR( HB_MEM_PTR( pMem ) ) = 1;
return HB_MEM_PTR( pMem );
}
HB_EXPORT void * hb_xrealloc( void * pMem, ULONG ulSize ) /* reallocates memory */
{
#ifdef HB_FM_STATISTICS
PHB_MEMINFO pMemBlock;
ULONG ulMemSize;
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_xrealloc(%p, %lu)", pMem, ulSize));
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xrealloc(%p, %lu)", pMem, ulSize));
if( ! pMem )
hb_errInternal( HB_EI_XREALLOCNULL, NULL, NULL, NULL );
@@ -316,94 +316,88 @@ HB_EXPORT void * hb_xrealloc( void * pMem, ULONG ulSize ) /* reallocates m
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
pMemBlock = ( PHB_MEMINFO ) ( ( BYTE * ) pMem - HB_MEMINFO_SIZE );
#ifdef HB_FM_STATISTICS
{
PHB_MEMINFO pMemBlock;
ULONG ulMemSize;
if( pMemBlock->ulSignature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XREALLOCINV, NULL, NULL, NULL );
pMemBlock = HB_FM_PTR( pMem );
ulMemSize = pMemBlock->ulSize;
if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XREALLOCINV, NULL, NULL, NULL );
if ( HB_GET_LONG( ( ( BYTE * ) pMem ) + ulMemSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL );
ulMemSize = pMemBlock->ulSize;
HB_PUT_LONG( ( ( BYTE * ) pMem ) + ulMemSize, 0 );
if( HB_FM_GETSIG( pMem, ulMemSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL );
HB_FM_CLRSIG( pMem, ulMemSize );
#ifdef HB_PARANOID_MEM_CHECK
pMem = malloc( ulSize + HB_MEMINFO_SIZE + sizeof( ULONG ) );
if ( pMem )
{
if ( ulSize > ulMemSize )
pMem = malloc( HB_ALLOC_SIZE( ulSize ) );
if( pMem )
{
memcpy( pMem, pMemBlock, ulMemSize + HB_MEMINFO_SIZE );
memset( ( char * ) pMem + HB_MEMINFO_SIZE + ulMemSize, HB_MEMFILER, ulSize - ulMemSize );
if( ulSize > ulMemSize )
{
memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulMemSize ) );
memset( ( BYTE * ) pMem + HB_ALLOC_SIZE( ulMemSize ), ulSize - ulMemSize );
}
else
memcpy( pMem, pMemBlock, HB_ALLOC_SIZE( ulSize ) );
}
else
memcpy( pMem, pMemBlock, ulSize + HB_MEMINFO_SIZE );
memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( ulMemSize ) );
free( pMemBlock );
#else
pMem = realloc( pMemBlock, HB_ALLOC_SIZE( ulSize ) );
#endif
s_lMemoryConsumed += ( ulSize - ulMemSize );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
if( ! pMem )
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
( ( PHB_MEMINFO ) pMem )->ulSize = ulSize; /* size of the memory block */
HB_FM_SETSIG( HB_MEM_PTR( pMem ), ulSize );
if( ( ( PHB_MEMINFO ) pMem )->pPrevBlock )
( ( PHB_MEMINFO ) pMem )->pPrevBlock->pNextBlock = ( PHB_MEMINFO ) pMem;
if( ( ( PHB_MEMINFO ) pMem )->pNextBlock )
( ( PHB_MEMINFO ) pMem )->pNextBlock->pPrevBlock = ( PHB_MEMINFO ) pMem;
if( s_pFirstBlock == pMemBlock )
s_pFirstBlock = ( PHB_MEMINFO ) pMem;
if( s_pLastBlock == pMemBlock )
s_pLastBlock = ( PHB_MEMINFO ) pMem;
}
memset( pMemBlock, HB_MEMFILER, ulMemSize + HB_MEMINFO_SIZE + sizeof( ULONG ) );
free( pMemBlock );
#else
pMem = realloc( pMemBlock, ulSize + HB_MEMINFO_SIZE + sizeof( ULONG ) );
#endif
s_lMemoryConsumed += ( ulSize - ulMemSize );
if( s_lMemoryMaxConsumed < s_lMemoryConsumed )
s_lMemoryMaxConsumed = s_lMemoryConsumed;
if( ! pMem )
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
( ( PHB_MEMINFO ) pMem )->ulSize = ulSize; /* size of the memory block */
HB_PUT_LONG( ( ( BYTE * ) pMem ) + ulSize + HB_MEMINFO_SIZE, HB_MEMINFO_SIGNATURE );
if( ( ( PHB_MEMINFO ) pMem )->pPrevBlock )
( ( PHB_MEMINFO ) pMem )->pPrevBlock->pNextBlock = ( PHB_MEMINFO ) pMem;
if( ( ( PHB_MEMINFO ) pMem )->pNextBlock )
( ( PHB_MEMINFO ) pMem )->pNextBlock->pPrevBlock = ( PHB_MEMINFO ) pMem;
if( s_pFirstBlock == pMemBlock )
s_pFirstBlock = ( PHB_MEMINFO ) pMem;
if( s_pLastBlock == pMemBlock )
s_pLastBlock = ( PHB_MEMINFO ) pMem;
return ( void * ) ( ( BYTE * ) pMem + HB_MEMINFO_SIZE );
#else
HB_TRACE(HB_TR_DEBUG, ("hb_xrealloc(%p, %lu)", pMem, ulSize));
if( ! pMem )
hb_errInternal( HB_EI_XREALLOCNULL, NULL, NULL, NULL );
if( ulSize == 0 )
hb_errInternal( HB_EI_XREALLOCNULLSIZE, NULL, NULL, NULL );
pMem = realloc( pMem, ulSize );
if( ! pMem )
pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE( ulSize ) );
if( !pMem )
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
return pMem;
#endif
return HB_MEM_PTR( pMem );
}
HB_EXPORT void hb_xfree( void * pMem ) /* frees fixed memory */
{
#ifdef HB_FM_STATISTICS
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_xfree(%p)", pMem));
HB_TRACE_FM(HB_TR_DEBUG, ("hb_xfree(%p)", pMem));
if( pMem )
{
PHB_MEMINFO pMemBlock = ( PHB_MEMINFO ) ( ( BYTE * ) pMem - HB_MEMINFO_SIZE );
#ifdef HB_FM_STATISTICS
if( pMemBlock->ulSignature != HB_MEMINFO_SIGNATURE )
PHB_MEMINFO pMemBlock = HB_FM_PTR( pMem );
if( pMemBlock->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, NULL, NULL, NULL );
if ( HB_GET_LONG( ( ( BYTE * ) pMem ) + pMemBlock->ulSize ) != HB_MEMINFO_SIGNATURE )
if( HB_FM_GETSIG( pMem, pMemBlock->ulSize ) != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XMEMOVERFLOW, NULL, NULL, NULL );
s_lMemoryConsumed -= pMemBlock->ulSize;
s_lMemoryConsumed -= pMemBlock->ulSize + sizeof( HB_COUNTER );
s_lMemoryBlocks--;
if( pMemBlock->pPrevBlock )
@@ -416,26 +410,106 @@ HB_EXPORT void hb_xfree( void * pMem ) /* frees fixed memory */
else
s_pLastBlock = pMemBlock->pPrevBlock;
pMemBlock->ulSignature = 0;
HB_PUT_LONG( ( ( BYTE * ) pMem ) + pMemBlock->ulSize, 0 );
pMemBlock->u32Signature = 0;
HB_FM_CLRSIG( pMem, pMemBlock->ulSize );
#ifdef HB_PARANOID_MEM_CHECK
memset( pMemBlock, HB_MEMFILER, pMemBlock->ulSize + HB_MEMINFO_SIZE + sizeof( ULONG ) );
memset( pMemBlock, HB_MEMFILER, HB_ALLOC_SIZE( pMemBlock->ulSize ) );
#endif
free( ( void * ) pMemBlock );
}
else
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
#else
HB_TRACE(HB_TR_DEBUG, ("hb_xfree(%p)", pMem));
free( HB_FM_PTR( pMem ) );
if( pMem )
free( pMem );
#endif
}
else
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
}
/* increment reference counter */
#undef hb_xRefInc
void hb_xRefInc( void * pMem )
{
++( * HB_COUNTER_PTR( pMem ) );
}
/* decrement reference counter, return TRUE when 0 reached */
#undef hb_xRefDec
BOOL hb_xRefDec( void * pMem )
{
return --( * HB_COUNTER_PTR( pMem ) ) == 0;
}
/* decrement reference counter and free the block when 0 reached */
#undef hb_xRefFree
void hb_xRefFree( void * pMem )
{
#ifdef HB_FM_STATISTICS
if( HB_FM_PTR( pMem )->u32Signature != HB_MEMINFO_SIGNATURE )
hb_errInternal( HB_EI_XFREEINV, NULL, NULL, NULL );
if( --( * HB_COUNTER_PTR( pMem ) ) == 0 )
hb_xfree( pMem );
#else
if( --( * HB_COUNTER_PTR( pMem ) ) == 0 )
free( HB_FM_PTR( pMem ) );
#endif
}
/* return number of references */
#undef hb_xRefCount
HB_COUNTER hb_xRefCount( void * pMem )
{
return * HB_COUNTER_PTR( pMem );
}
/* reallocates memory, create copy if reference counter greater then 1 */
#undef hb_xRefResize
void * hb_xRefResize( void * pMem, ULONG ulSave, ULONG ulSize )
{
#ifdef HB_FM_STATISTICS
if( * HB_COUNTER_PTR( pMem ) > 1 )
{
void * pMemNew = hb_xgrab( ulSize );
--( * HB_COUNTER_PTR( pMem ) );
memcpy( pMemNew, pMem, HB_MIN( ulSave, ulSize ) );
return pMemNew;
}
return hb_xrealloc( pMem, ulSize );
#else
if( * HB_COUNTER_PTR( pMem ) > 1 )
{
void * pMemNew = malloc( HB_ALLOC_SIZE( ulSize ) );
if( pMemNew )
{
--( * HB_COUNTER_PTR( pMem ) );
* HB_COUNTER_PTR( HB_MEM_PTR( pMemNew ) ) = 1;
memcpy( HB_MEM_PTR( pMemNew ), pMem, HB_MIN( ulSave, ulSize ) );
return HB_MEM_PTR( pMemNew );
}
}
else
{
pMem = realloc( HB_FM_PTR( pMem ), HB_ALLOC_SIZE ( ulSize ) );
if( pMem )
return HB_MEM_PTR( pMem );
}
hb_errInternal( HB_EI_XREALLOC, NULL, NULL, NULL );
return NULL;
#endif
}
@@ -447,7 +521,7 @@ HB_EXPORT ULONG hb_xsize( void * pMem ) /* returns the size of an allocated mem
HB_TRACE(HB_TR_DEBUG, ("hb_xsize(%p)", pMem));
#ifdef HB_FM_STATISTICS
return ( ( PHB_MEMINFO ) ( ( BYTE * ) pMem - HB_MEMINFO_SIZE ) )->ulSize;
return HB_FM_PTR( pMem )->ulSize;
#else
HB_SYMBOL_UNUSED( pMem );
@@ -779,7 +853,7 @@ HB_FUNC( MEMORY )
}
#ifdef HB_FM_STATISTICS
HB_FUNC( HB_FM_STAT ) {};
HB_FUNC( HB_FM_STAT ) {}
#else
HB_FUNC( HB_FM_NOSTAT ) {};
HB_FUNC( HB_FM_NOSTAT ) {}
#endif

198
harbour/source/vm/garbage.c
View File

@@ -53,6 +53,7 @@
#include "hbvmopt.h"
#include "hbapi.h"
#include "hbstack.h"
#include "hbapicls.h"
#include "hbapiitm.h"
#include "hbapierr.h"
#include "hbvm.h"
@@ -78,6 +79,13 @@ typedef struct HB_GARBAGE_
# define HB_GARBAGE_SIZE sizeof( HB_GARBAGE )
#endif
#define HB_GC_PTR( p ) ( ( HB_GARBAGE_PTR ) ( ( BYTE * ) ( p ) - HB_GARBAGE_SIZE ) )
#define HB_MEM_PTR( p ) ( ( void * ) ( ( BYTE * ) ( p ) + HB_GARBAGE_SIZE ) )
/* we may use a cache later */
#define HB_GARBAGE_NEW( ulSize ) ( ( HB_GARBAGE_PTR ) hb_xgrab( HB_GARBAGE_SIZE + ( ulSize ) ) )
#define HB_GARBAGE_FREE( pAlloc ) hb_xfree( ( void * ) ( pAlloc ) )
/* status of memory block */
#define HB_GC_UNLOCKED 0
#define HB_GC_LOCKED 1 /* do not collect a memory block */
@@ -91,6 +99,9 @@ static HB_GARBAGE_PTR s_pCurrBlock = NULL;
/* pointer to locked memory blocks */
static HB_GARBAGE_PTR s_pLockedBlock = NULL;
/* pointer to memory blocks that will be deleted */
static HB_GARBAGE_PTR s_pDeletedBlock = NULL;
/* marks if block releasing is requested during garbage collecting */
static BOOL s_bCollecting = FALSE;
@@ -99,10 +110,6 @@ static BOOL s_bCollecting = FALSE;
*/
static USHORT s_uUsedFlag = HB_GC_USED_FLAG;
/* we may use a cache later */
#define HB_GARBAGE_NEW( ulSize ) ( ( HB_GARBAGE_PTR ) hb_xgrab( ulSize ) )
#define HB_GARBAGE_FREE( pAlloc ) hb_xfree( ( void * ) ( pAlloc ) )
static void hb_gcLink( HB_GARBAGE_PTR *pList, HB_GARBAGE_PTR pAlloc )
{
if( *pList )
@@ -134,14 +141,14 @@ void * hb_gcAlloc( ULONG ulSize, HB_GARBAGE_FUNC_PTR pCleanupFunc )
{
HB_GARBAGE_PTR pAlloc;
pAlloc = HB_GARBAGE_NEW( HB_GARBAGE_SIZE + ulSize );
pAlloc = HB_GARBAGE_NEW( ulSize );
if( pAlloc )
{
hb_gcLink( &s_pCurrBlock, pAlloc );
pAlloc->pFunc = pCleanupFunc;
pAlloc->locked = 0;
pAlloc->used = s_uUsedFlag;
return ( void * ) ( ( BYTE * ) pAlloc + HB_GARBAGE_SIZE ); /* hide the internal data */
return HB_MEM_PTR( pAlloc ); /* hide the internal data */
}
else
return NULL;
@@ -152,7 +159,7 @@ void hb_gcFree( void *pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) ( ( BYTE * ) pBlock - HB_GARBAGE_SIZE );
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( !( pAlloc->used & HB_GC_DELETE ) )
{
@@ -170,6 +177,69 @@ void hb_gcFree( void *pBlock )
}
}
/* increment reference counter */
void hb_gcRefInc( void * pBlock )
{
hb_xRefInc( HB_GC_PTR( pBlock ) );
}
/* decrement reference counter, return TRUE when 0 reached */
BOOL hb_gcRefDec( void * pBlock )
{
return hb_xRefDec( HB_GC_PTR( pBlock ) );
}
/* decrement reference counter and free the block when 0 reached */
void hb_gcRefFree( void * pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( hb_xRefDec( pAlloc ) )
{
/* Don't release the block that will be deleted during finalization */
if( !( pAlloc->used & HB_GC_DELETE ) )
{
/* unlink the block first to avoid possible problems
* if cleanup function activate GC
*/
if( pAlloc->locked )
hb_gcUnlink( &s_pLockedBlock, pAlloc );
else
hb_gcUnlink( &s_pCurrBlock, pAlloc );
/* execute clean-up function */
if( pAlloc->pFunc )
{
/*
* we do not have to set HB_GC_DELETE flag here. If upper level
* code is not broken then the reference counter to this block
* now reach 0 so is nowhere accessible. I set this flag only
* as workaround for some wrong code which may want to execute
* hb_gcFree() for this block from clean-up function. [druzus]
*/
pAlloc->used |= HB_GC_DELETE;
( pAlloc->pFunc )( pBlock );
}
HB_GARBAGE_FREE( pAlloc );
}
}
}
else
{
hb_errInternal( HB_EI_XFREENULL, NULL, NULL, NULL );
}
}
/* return number of references */
HB_COUNTER hb_gcRefCount( void * pBlock )
{
return hb_xRefCount( HB_GC_PTR( pBlock ) );
}
static HB_GARBAGE_FUNC( hb_gcGripRelease )
{
/* Item was already released in hb_gcGripDrop() - then we have nothing
@@ -182,10 +252,10 @@ HB_ITEM_PTR hb_gcGripGet( HB_ITEM_PTR pOrigin )
{
HB_GARBAGE_PTR pAlloc;
pAlloc = HB_GARBAGE_NEW( HB_GARBAGE_SIZE + sizeof( HB_ITEM ) );
pAlloc = HB_GARBAGE_NEW( sizeof( HB_ITEM ) );
if( pAlloc )
{
HB_ITEM_PTR pItem = ( HB_ITEM_PTR ) ( ( BYTE * ) pAlloc + HB_GARBAGE_SIZE );
HB_ITEM_PTR pItem = ( HB_ITEM_PTR ) HB_MEM_PTR( pAlloc );
hb_gcLink( &s_pLockedBlock, pAlloc );
pAlloc->pFunc = hb_gcGripRelease;
@@ -206,7 +276,7 @@ void hb_gcGripDrop( HB_ITEM_PTR pItem )
{
if( pItem )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) ( ( BYTE * ) pItem - HB_GARBAGE_SIZE );
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem );
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem ); /* clear value stored in this item */
@@ -223,7 +293,7 @@ void * hb_gcLock( void * pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) ( ( BYTE * ) pBlock - HB_GARBAGE_SIZE );
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( ! pAlloc->locked )
{
@@ -239,11 +309,11 @@ void * hb_gcLock( void * pBlock )
/* Unlock a memory pointer so it can be released if there is no
references inside of harbour variables
*/
void *hb_gcUnlock( void *pBlock )
void *hb_gcUnlock( void * pBlock )
{
if( pBlock )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) ( ( BYTE * ) pBlock - HB_GARBAGE_SIZE );
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pBlock );
if( pAlloc->locked )
{
@@ -267,7 +337,7 @@ void hb_gcItemRef( HB_ITEM_PTR pItem )
if( HB_IS_ARRAY( pItem ) )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) ( ( BYTE * ) pItem->item.asArray.value - HB_GARBAGE_SIZE );
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asArray.value );
/* Check this array only if it was not checked yet */
if( pAlloc->used == s_uUsedFlag )
@@ -289,7 +359,7 @@ void hb_gcItemRef( HB_ITEM_PTR pItem )
}
else if( HB_IS_BLOCK( pItem ) )
{
HB_GARBAGE_PTR pAlloc = ( HB_GARBAGE_PTR ) ( ( BYTE * ) pItem->item.asBlock.value - HB_GARBAGE_SIZE );
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asBlock.value );
if( pAlloc->used == s_uUsedFlag )
{
@@ -305,6 +375,16 @@ void hb_gcItemRef( HB_ITEM_PTR pItem )
}
}
}
else if( HB_IS_POINTER( pItem ) )
{
if( pItem->item.asPointer.collect )
{
HB_GARBAGE_PTR pAlloc = HB_GC_PTR( pItem->item.asPointer.value );
if( pAlloc->used == s_uUsedFlag )
pAlloc->used ^= HB_GC_USED_FLAG; /* mark this codeblock as used */
}
}
/* all other data types don't need the GC */
}
@@ -335,7 +415,7 @@ void hb_gcCollectAll( void )
hb_vmIsLocalRef();
hb_vmIsStaticRef();
hb_memvarsIsMemvarRef();
hb_gcItemRef( &hb_stack.Return );
hb_gcItemRef( hb_stackReturnItem() );
hb_clsIsClassRef();
/* check list of locked block for blocks referenced from
@@ -348,25 +428,85 @@ void hb_gcCollectAll( void )
{ /* it is not very elegant method but it works well */
if( pAlloc->pFunc == hb_gcGripRelease )
{
hb_gcItemRef( ( HB_ITEM_PTR ) ( ( BYTE * ) pAlloc + HB_GARBAGE_SIZE ) );
hb_gcItemRef( ( HB_ITEM_PTR ) HB_MEM_PTR( pAlloc ) );
}
pAlloc = pAlloc->pNext;
} while ( s_pLockedBlock != pAlloc );
} while( s_pLockedBlock != pAlloc );
}
/* Step 3 - finalize */
/* Release all blocks that are still marked as unused */
/*
* infinite loop can appear when we are executing clean-up functions
* scanning s_pCurrBlock. It's possible that one of them will free
* the GC block which we are using as stop condition. Only blocks
* for which we set HB_GC_DELETE flag are guarded against releasing.
* To avoid such situation first we are moving blocks which will be
* deleted to separate list. It's additional operation but it can
* even increase the speed when we are deleting only few percent
* of all allocated blocks because in next passes we will scan only
* deleted block list. [druzus]
*/
pAlloc = NULL; /* for stop condition */
do
{
if( s_pCurrBlock->used == s_uUsedFlag )
{
pDelete = s_pCurrBlock;
s_pCurrBlock->used |= HB_GC_DELETE;
hb_gcUnlink( &s_pCurrBlock, s_pCurrBlock );
hb_gcLink( &s_pDeletedBlock, pDelete );
}
else
{
/* at least one block will not be deleted, set new stop condition */
if( ! pAlloc )
pAlloc = s_pCurrBlock;
s_pCurrBlock = s_pCurrBlock->pNext;
}
} while( pAlloc != s_pCurrBlock );
/* do we have any deleted blocks? */
if( s_pDeletedBlock )
{
/* call a cleanup function */
pAlloc = s_pDeletedBlock;
do
{
if( s_pDeletedBlock->pFunc )
( s_pDeletedBlock->pFunc )( HB_MEM_PTR( s_pDeletedBlock ) );
s_pDeletedBlock = s_pDeletedBlock->pNext;
} while( pAlloc != s_pDeletedBlock );
/* release all deleted blocks */
do
{
pDelete = s_pDeletedBlock;
hb_gcUnlink( &s_pDeletedBlock, s_pDeletedBlock );
HB_GARBAGE_FREE( pDelete );
} while( s_pDeletedBlock );
}
#if 0
pAlloc = s_pCurrBlock;
do
{
if( s_pCurrBlock->used == s_uUsedFlag )
{
/* call a cleanup function */
s_pCurrBlock->used |= HB_GC_DELETE;
if( s_pCurrBlock->pFunc )
{
( s_pCurrBlock->pFunc )( ( void *) ( ( BYTE * ) s_pCurrBlock + HB_GARBAGE_SIZE ) );
}
/* call a cleanup function */
s_pCurrBlock->used |= HB_GC_DELETE;
if( s_pCurrBlock->pFunc )
{
( s_pCurrBlock->pFunc )( HB_MEM_PTR( s_pCurrBlock ) );
}
}
s_pCurrBlock = s_pCurrBlock->pNext;
@@ -408,18 +548,18 @@ void hb_gcCollectAll( void )
{
s_pCurrBlock = s_pCurrBlock->pNext;
}
} while ( s_pCurrBlock && ( pAlloc != s_pCurrBlock ) );
s_bCollecting = FALSE;
s_pCurrBlock = pAlloc;
#endif
/* Step 4 - flip flag */
/* Reverse used/unused flag so we don't have to mark all blocks
* during next collecting
*/
s_uUsedFlag ^= HB_GC_USED_FLAG;
s_bCollecting = FALSE;
}
}
@@ -438,7 +578,9 @@ void hb_gcReleaseAll( void )
if( s_pCurrBlock->pFunc )
{
HB_TRACE( HB_TR_INFO, ( "Cleanup, %p", s_pCurrBlock ) );
( s_pCurrBlock->pFunc )( ( void *) ( ( BYTE * ) s_pCurrBlock + HB_GARBAGE_SIZE ) );
s_pCurrBlock->used |= HB_GC_DELETE;
( s_pCurrBlock->pFunc )( HB_MEM_PTR( s_pCurrBlock ) );
}
s_pCurrBlock = s_pCurrBlock->pNext;

2322
harbour/source/vm/hvm.c
View File

File diff suppressed because it is too large Load Diff

365
harbour/source/vm/itemapi.c
View File

@@ -97,6 +97,7 @@
#include "hbapi.h"
#include "hbstack.h"
#include "hbapiitm.h"
#include "hbapilng.h"
#include "hbapierr.h"
#include "hbdate.h"
#include "hbset.h"
@@ -214,25 +215,23 @@ HB_EXPORT PHB_ITEM hb_itemPutC( PHB_ITEM pItem, const char * szText )
if( ulLen == 0 )
{
pItem->item.asString.length = 0;
pItem->item.asString.value = hb_vm_sNull;
pItem->item.asString.bStatic = TRUE;
pItem->item.asString.length = 0;
pItem->item.asString.allocated = 0;
pItem->item.asString.value = hb_vm_sNull;
}
else if( ulLen == 1 )
{
pItem->item.asString.length = 1;
pItem->item.asString.value = hb_vm_acAscii[ (unsigned char) ( szText[0] ) ];
pItem->item.asString.bStatic = TRUE;
pItem->item.asString.length = 1;
pItem->item.asString.allocated = 0;
pItem->item.asString.value = hb_vm_acAscii[ (unsigned char) ( szText[0] ) ];
}
else
{
pItem->item.asString.length = ulLen;
pItem->item.asString.value = ( char * ) hb_xgrab( ulLen + 1 );
pItem->item.asString.bStatic = 0;
pItem->item.asString.u.pulHolders = ( HB_COUNTER * ) hb_xgrab( sizeof( HB_COUNTER ) );
* ( pItem->item.asString.u.pulHolders ) = 1;
hb_xmemcpy( pItem->item.asString.value, szText, ulLen );
pItem->item.asString.value[ ulLen ] = '\0';
pItem->item.asString.length = ulLen;
pItem->item.asString.allocated = ulLen + 1;
pItem->item.asString.value = ( char * ) hb_xgrab( ulLen + 1 );
/* we used strlen() above so we no it's 0-ended string */
hb_xmemcpy( pItem->item.asString.value, szText, ulLen + 1 );
}
return pItem;
@@ -251,7 +250,7 @@ HB_EXPORT PHB_ITEM hb_itemPutCConst( PHB_ITEM pItem, const char * szText )
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_STRING;
pItem->item.asString.bStatic = 1;
pItem->item.asString.allocated = 0;
if( szText == NULL )
{
@@ -287,23 +286,21 @@ HB_EXPORT PHB_ITEM hb_itemPutCL( PHB_ITEM pItem, const char * szText, ULONG ulLe
if( szText == NULL || ulLen == 0 )
{
pItem->item.asString.length = 0;
pItem->item.asString.value = hb_vm_sNull;
pItem->item.asString.bStatic = TRUE;
pItem->item.asString.length = 0;
pItem->item.asString.allocated = 0;
pItem->item.asString.value = hb_vm_sNull;
}
else if( ulLen == 1 )
{
pItem->item.asString.length = 1;
pItem->item.asString.value = hb_vm_acAscii[ (unsigned char) ( szText[0] ) ];
pItem->item.asString.bStatic = TRUE;
pItem->item.asString.length = 1;
pItem->item.asString.allocated = 0;
pItem->item.asString.value = hb_vm_acAscii[ (unsigned char) ( szText[0] ) ];
}
else
{
pItem->item.asString.length = ulLen;
pItem->item.asString.value = ( char * ) hb_xgrab( ulLen + 1 );
pItem->item.asString.bStatic = 0;
pItem->item.asString.u.pulHolders = ( HB_COUNTER * ) hb_xgrab( sizeof( HB_COUNTER ) );
* ( pItem->item.asString.u.pulHolders ) = 1;
pItem->item.asString.length = ulLen;
pItem->item.asString.allocated = ulLen + 1;
pItem->item.asString.value = ( char * ) hb_xgrab( ulLen + 1 );
hb_xmemcpy( pItem->item.asString.value, szText, ulLen );
pItem->item.asString.value[ ulLen ] = '\0';
}
@@ -327,23 +324,21 @@ HB_EXPORT PHB_ITEM hb_itemPutCPtr( PHB_ITEM pItem, char * szText, ULONG ulLen )
pItem->item.asString.length = ulLen;
if( ulLen == 0 )
{
pItem->item.asString.value = hb_vm_sNull;
pItem->item.asString.bStatic = TRUE;
pItem->item.asString.allocated = 0;
pItem->item.asString.value = hb_vm_sNull;
hb_xfree( szText );
}
else if( ulLen == 1 )
{
pItem->item.asString.value = hb_vm_acAscii[ (unsigned char) ( szText[0] ) ];
pItem->item.asString.bStatic = TRUE;
pItem->item.asString.allocated = 0;
pItem->item.asString.value = hb_vm_acAscii[ (unsigned char) ( szText[0] ) ];
hb_xfree( szText );
}
else
{
pItem->item.asString.value = szText;
pItem->item.asString.value[ ulLen ] = '\0';
pItem->item.asString.bStatic = FALSE;
pItem->item.asString.u.pulHolders = ( HB_COUNTER * ) hb_xgrab( sizeof( HB_COUNTER ) );
* ( pItem->item.asString.u.pulHolders ) = 1;
szText[ ulLen ] = '\0';
pItem->item.asString.allocated = ulLen + 1;
pItem->item.asString.value = szText;
}
return pItem;
@@ -634,7 +629,7 @@ HB_EXPORT PHB_ITEM hb_itemReturn( PHB_ITEM pItem )
HB_TRACE(HB_TR_DEBUG, ("hb_itemReturn(%p)", pItem));
if( pItem )
hb_itemCopy( &hb_stack.Return, pItem );
hb_itemCopy( hb_stackReturnItem(), pItem );
return pItem;
}
@@ -644,9 +639,7 @@ HB_EXPORT PHB_ITEM hb_itemReturnForward( PHB_ITEM pItem )
HB_TRACE_STEALTH( HB_TR_DEBUG, ("hb_itemReturnForward(%p)", pItem ) );
if( pItem )
{
hb_itemForwardValue( &hb_stack.Return, pItem );
}
hb_itemMove( hb_stackReturnItem(), pItem );
return pItem;
}
@@ -918,14 +911,10 @@ HB_EXPORT PHB_ITEM hb_itemPutNDDec( PHB_ITEM pItem, double dNumber, int iDec )
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
{
hb_itemClear( pItem );
}
}
else
{
pItem = hb_itemNew( NULL );
}
pItem->type = HB_IT_DOUBLE;
pItem->item.asDouble.length = HB_DBL_LENGTH( dNumber );
@@ -1107,6 +1096,26 @@ HB_EXPORT PHB_ITEM hb_itemPutPtr( PHB_ITEM pItem, void * pValue )
pItem->type = HB_IT_POINTER;
pItem->item.asPointer.value = pValue;
pItem->item.asPointer.collect = FALSE;
return pItem;
}
HB_EXPORT PHB_ITEM hb_itemPutPtrGC( PHB_ITEM pItem, void * pValue )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemPutPtrGC(%p, %p)", pItem, pValue));
if( pItem )
{
if( HB_IS_COMPLEX( pItem ) )
hb_itemClear( pItem );
}
else
pItem = hb_itemNew( NULL );
pItem->type = HB_IT_POINTER;
pItem->item.asPointer.value = pValue;
pItem->item.asPointer.collect = TRUE;
return pItem;
}
@@ -1225,41 +1234,30 @@ HB_EXPORT void hb_itemClear( PHB_ITEM pItem )
if( HB_IS_STRING( pItem ) )
{
if( !pItem->item.asString.bStatic )
{
if( --*( pItem->item.asString.u.pulHolders ) == 0 )
{
hb_xfree( pItem->item.asString.value );
pItem->item.asString.value = NULL;
hb_xfree( pItem->item.asString.u.pulHolders );
}
}
if( pItem->item.asString.allocated )
hb_xRefFree( pItem->item.asString.value );
}
else if( HB_IS_ARRAY( pItem ) )
{
if( pItem->item.asArray.value )
{
if( --( pItem->item.asArray.value )->ulHolders == 0 )
hb_arrayRelease( pItem );
}
}
hb_gcRefFree( pItem->item.asArray.value );
else if( HB_IS_BLOCK( pItem ) )
hb_codeblockDelete( pItem );
hb_gcRefFree( pItem->item.asBlock.value );
else if( HB_IS_MEMVAR( pItem ) )
hb_memvarValueDecRef( pItem->item.asMemvar.value );
else if( HB_IS_BYREF( pItem ) )
else if( HB_IS_POINTER( pItem ) )
{
if( pItem->item.asRefer.offset < 0 && pItem->item.asRefer.value >= 0 )
{
/* FOR EACH control variable */
hb_itemRelease( pItem->item.asRefer.BasePtr.itemPtr );
if( pItem->item.asRefer.ValuePtr.itemPtr )
hb_itemRelease( pItem->item.asRefer.ValuePtr.itemPtr );
}
if( pItem->item.asPointer.collect )
hb_gcRefFree( pItem->item.asPointer.value );
}
else if( HB_IS_ENUM( pItem ) ) /* FOR EACH control variable */
{
hb_itemRelease( pItem->item.asEnum.basePtr );
if( pItem->item.asEnum.valuePtr )
hb_itemRelease( pItem->item.asEnum.valuePtr );
}
#if defined( HB_FM_STATISTICS ) && defined( HB_PARANOID_MEM_CHECK )
else if( HB_IS_BADITEM( pItem ) )
hb_errInternal( HB_EI_VMPOPINVITEM, NULL, "hb_itemClear()", NULL );
@@ -1286,47 +1284,30 @@ HB_EXPORT void hb_itemCopy( PHB_ITEM pDest, PHB_ITEM pSource )
{
if( HB_IS_STRING( pSource ) )
{
if( !pSource->item.asString.bStatic )
++*( pSource->item.asString.u.pulHolders );
if( pSource->item.asString.allocated )
hb_xRefInc( pSource->item.asString.value );
}
else if( HB_IS_ARRAY( pSource ) )
{
( pSource->item.asArray.value )->ulHolders++;
}
hb_gcRefInc( pSource->item.asArray.value );
else if( HB_IS_BLOCK( pSource ) )
{
( pSource->item.asBlock.value )->ulCounter++;
}
hb_gcRefInc( pSource->item.asBlock.value );
else if( HB_IS_MEMVAR( pSource ) )
hb_memvarValueIncRef( pSource->item.asMemvar.value );
else if( HB_IS_POINTER( pSource ) )
{
if( pSource->item.asPointer.collect )
hb_gcRefInc( pSource->item.asPointer.value );
}
}
}
/* copy (transfer) the value of item without increasing
* a reference counters (the pSource item cannot be cleared)
*/
HB_EXPORT void hb_itemForwardValue( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE_STEALTH( HB_TR_DEBUG, ("hb_itemForwardValue(%p, %p) %i", pDest, pSource, pDest->type ) );
if( pDest == pSource )
{
hb_errInternal( HB_EI_ITEMBADCOPY, NULL, "hb_itemForwardValue()", NULL );
}
if( HB_IS_COMPLEX( pDest ) )
{
hb_itemClear( pDest );
}
/* Forward. */
memcpy( pDest, pSource, sizeof( HB_ITEM ) );
/* Now fake clear the transferer. */
//pSource->item.asString.bStatic = FALSE;
pSource->type = HB_IT_NIL;
}
/*
* copy (transfer) the value of item without increasing
* a reference counters, the pSource item is cleared
*/
HB_EXPORT void hb_itemMove( PHB_ITEM pDest, PHB_ITEM pSource )
{
HB_TRACE(HB_TR_DEBUG, ("hb_itemCopy(%p, %p)", pDest, pSource));
@@ -1339,7 +1320,6 @@ HB_EXPORT void hb_itemMove( PHB_ITEM pDest, PHB_ITEM pSource )
memcpy( pDest, pSource, sizeof( HB_ITEM ) );
pSource->type = HB_IT_NIL;
}
HB_EXPORT void hb_itemSwap( PHB_ITEM pItem1, PHB_ITEM pItem2 )
@@ -1377,7 +1357,7 @@ PHB_ITEM hb_itemUnRef( PHB_ITEM pItem )
/* Unreference passed variable
* Do not unreference the last reference stored
*/
*/
PHB_ITEM hb_itemUnRefRefer( PHB_ITEM pItem )
{
PHB_ITEM pRef = pItem;
@@ -1412,6 +1392,34 @@ PHB_ITEM hb_itemUnRefOnce( PHB_ITEM pItem )
pItem->item.asMemvar.value;
pItem = pValue->pVarItem;
}
else if( HB_IS_ENUM( pItem ) ) /* FOR EACH control variable */
{
/* enumerator variable */
if( HB_IS_ARRAY( pItem->item.asEnum.basePtr ) )
{
PHB_ITEM pResult = hb_arrayGetItemPtr( pItem->item.asEnum.basePtr,
pItem->item.asEnum.offset );
if( pResult )
return pResult;
}
else if( pItem->item.asEnum.valuePtr )
return pItem->item.asEnum.valuePtr;
/* to avoid recursive RT error generation */
if( pItem->item.asEnum.offset >= 0 )
{
hb_stackPush();
hb_itemPutNInt( hb_stackItemFromTop( -1 ), pItem->item.asEnum.offset );
pItem->item.asEnum.offset = -1;
if( !pItem->item.asEnum.valuePtr )
pItem->item.asEnum.valuePtr = hb_itemNew( NULL );
hb_errRT_BASE( EG_BOUND, 1132, NULL, hb_langDGetErrorDesc( EG_ARRACCESS ),
2, pItem->item.asEnum.basePtr, hb_stackItemFromTop( -1 ) );
/* break() was executed by error block */
}
return pItem->item.asEnum.valuePtr;
}
else
{
if( pItem->item.asRefer.value >= 0 )
@@ -1422,30 +1430,19 @@ PHB_ITEM hb_itemUnRefOnce( PHB_ITEM pItem )
pItem = *( pItem->item.asRefer.BasePtr.itemsbase ) +
pItem->item.asRefer.value;
}
else if( pItem->item.asRefer.offset < 0 )
{
/* enumerator variable */
if( HB_IS_ARRAY( pItem->item.asRefer.BasePtr.itemPtr ) )
{
pItem = hb_arrayGetItemPtr( pItem->item.asRefer.BasePtr.itemPtr, pItem->item.asRefer.value );
}
else if( pItem->item.asRefer.ValuePtr.itemPtr )
{
pItem = pItem->item.asRefer.ValuePtr.itemPtr;
}
}
else
{
/* a reference to a local variable */
HB_ITEM_PTR *pLocal;
pLocal = *( pItem->item.asRefer.BasePtr.itemsbasePtr ) + pItem->item.asRefer.offset + pItem->item.asRefer.value;
pLocal = *( pItem->item.asRefer.BasePtr.itemsbasePtr ) +
pItem->item.asRefer.offset + pItem->item.asRefer.value;
pItem = *pLocal;
}
}
else
{
/* local variable referenced in a codeblock
*/
/* local variable referenced in a codeblock */
pItem = hb_codeblockGetRef( pItem->item.asRefer.BasePtr.block, pItem );
}
}
@@ -1455,36 +1452,79 @@ PHB_ITEM hb_itemUnRefOnce( PHB_ITEM pItem )
}
/* Internal API, not standard Clipper */
/* UnShare string buffer of given item */
/* Resize string buffer of given string item */
PHB_ITEM hb_itemReSizeString( PHB_ITEM pItem, ULONG ulSize )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemReSizeString(%p,%lu)", pItem, ulSize));
if( pItem->item.asString.allocated == 0 )
{
char *szText = ( char* ) hb_xgrab( ulSize + 1 );
hb_xmemcpy( szText, pItem->item.asString.value,
pItem->item.asString.length );
szText[ ulSize ] = '\0';
pItem->item.asString.value = szText;
pItem->item.asString.length = ulSize;
pItem->item.asString.allocated = ulSize + 1;
}
#if 0
else if( pItem->item.asString.allocated > ulSize )
{
pItem->item.asString.length = ulSize;
pItem->item.asString.value[ ulSize ] = '\0';
}
#endif
else
{
ULONG ulAlloc = ulSize + 1 +
( pItem->item.asString.allocated < ulSize ? ulSize : 0 );
pItem->item.asString.value = ( char* )
hb_xRefResize( pItem->item.asString.value,
pItem->item.asString.length,
ulAlloc );
pItem->item.asString.length = ulSize;
pItem->item.asString.allocated = ulAlloc;
pItem->item.asString.value[ ulSize ] = '\0';
}
return pItem;
}
/* Internal API, not standard Clipper */
/* UnShare string buffer of given string item */
PHB_ITEM hb_itemUnShareString( PHB_ITEM pItem )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemUnShareString(%p)", pItem));
if( pItem->item.asString.allocated == 0 ||
hb_xRefCount( pItem->item.asString.value ) > 1 )
{
ULONG ulLen = pItem->item.asString.length + 1;
char *szText = ( char* ) hb_xgrab( ulLen );
hb_xmemcpy( szText, pItem->item.asString.value, ulLen );
pItem->item.asString.value = szText;
if( ! pItem->item.asString.allocated )
hb_xRefDec( pItem->item.asString.value );
pItem->item.asString.allocated = ulLen;
}
return pItem;
}
PHB_ITEM hb_itemUnShare( PHB_ITEM pItem )
{
HB_TRACE_STEALTH(HB_TR_DEBUG, ("hb_itemUnShare(%p)", pItem));
if( HB_IS_BYREF( pItem ) )
{
pItem = hb_itemUnRef( pItem );
}
if( HB_IS_STRING( pItem ) )
{
if( pItem->item.asString.bStatic || *( pItem->item.asString.u.pulHolders ) > 1 )
{
ULONG ulLen = pItem->item.asString.length;
char *szText = ( char* ) hb_xgrab( ulLen + 1 );
hb_xmemcpy( szText, pItem->item.asString.value, ulLen + 1 );
pItem->item.asString.value = szText;
if( ! pItem->item.asString.bStatic )
{
--*( pItem->item.asString.u.pulHolders );
}
pItem->item.asString.u.pulHolders = ( HB_COUNTER * ) hb_xgrab( sizeof( HB_COUNTER ) );
*( pItem->item.asString.u.pulHolders ) = 1;
}
}
return pItem;
return hb_itemUnShareString( pItem );
else
return pItem;
}
/* Internal API, not standard Clipper */
@@ -1645,7 +1685,7 @@ HB_EXPORT BOOL hb_itemStrBuf( char *szResult, PHB_ITEM pNumber, int iSize, int i
double dInt, dFract, dDig, doBase = 10.0;
int iPrec, iFirst = -1;
//dNumber = hb_numRound( dNumber, iDec );
/* dNumber = hb_numRound( dNumber, iDec ); */
#ifdef HB_NUM_PRECISION
iPrec = HB_NUM_PRECISION;
@@ -1979,34 +2019,33 @@ HB_EXPORT char * hb_itemString( PHB_ITEM pItem, ULONG * ulLen, BOOL * bFreeReq )
break;
case HB_IT_POINTER:
{
int size = ( sizeof( void * ) << 1 ) + 3; /* n bytes for address + 0x + \0 */
int n;
BOOL bFail = TRUE;
buffer = ( char * ) hb_xgrab( size );
do
{
int size = ( sizeof( void * ) << 1 ) + 3; /* n bytes for address + 0x + \0 */
int n;
BOOL bFail = TRUE;
buffer = ( char * ) hb_xgrab( size );
do
n = snprintf( buffer, size, "%p", hb_itemGetPtr( pItem ) );
if( (n > -1) && (n < size) )
{
n = snprintf( buffer, size, "%p", hb_itemGetPtr( pItem ) );
if( (n > -1) && (n < size) )
{
bFail = FALSE;
}
else
{
if( n > -1 )
size = n + 1;
else
size *= 2;
buffer = ( char * ) hb_xrealloc( buffer, size );
}
bFail = FALSE;
}
else
{
if( n > -1 )
size = n + 1;
else
size *= 2;
buffer = ( char * ) hb_xrealloc( buffer, size );
}
while( bFail );
* ulLen = strlen( buffer );
* bFreeReq = TRUE;
}
while( bFail );
* ulLen = strlen( buffer );
* bFreeReq = TRUE;
break;
}
default:
buffer = "";
* ulLen = 0;

2
harbour/source/vm/macro.c
View File

@@ -1228,7 +1228,7 @@ void hb_compGenPushSymbol( char * szSymbolName, BOOL bFunction, BOOL bAlias, HB_
}
else if( bFunction )
{
if( pSym->pFunPtr==NULL )
if( pSym->pSymbol->value.pFunPtr == NULL )
{
/* static functions are not allowed in macro */
HB_MACRO_DATA->status |= HB_MACRO_UNKN_SYM;

32
harbour/source/vm/maindllp.c
View File

@@ -85,7 +85,7 @@ HB_EXPORT BOOL WINAPI DllEntryPoint( HINSTANCE hInstance, DWORD fdwReason, PVOID
}
/* module symbols initialization */
void hb_vmProcessSymbols( PHB_SYMB pModuleSymbols, USHORT uiModuleSymbols )
PHB_SYMB hb_vmProcessSymbols( PHB_SYMB pSymbols, USHORT uiSymbols )
{
/* notice hb_vmProcessDllSymbols() must be used, and not
* hb_vmProcessSymbols(), as some special symbols pointers
@@ -94,10 +94,27 @@ void hb_vmProcessSymbols( PHB_SYMB pModuleSymbols, USHORT uiModuleSymbols )
FARPROC pProcessSymbols = GetProcAddress( GetModuleHandle( NULL ),
"_hb_vmProcessDllSymbols" );
if( pProcessSymbols )
( ( VM_PROCESS_DLL_SYMBOLS ) pProcessSymbols ) ( pModuleSymbols,
uiModuleSymbols );
return ( ( VM_PROCESS_DLL_SYMBOLS ) pProcessSymbols ) ( pSymbols,
uiSymbols );
/* else
* may we issue an error ? */
return pSymbols;
}
/* module symbols initialization */
PHB_SYMB hb_vmProcessSymbolsExt( PHB_SYMB pSymbols, USHORT uiSymbols, char * szModuleName, ULONG ulID, USHORT uiPcodeMin, USHORT uiPcodeMax ) /* module symbols initialization with extended information */
{
FARPROC pProcessSymbols = GetProcAddress( GetModuleHandle( NULL ),
"_hb_vmProcessSymbolsExt" );
if( pProcessSymbols )
return ( ( VM_PROCESS_SYMBOLS_EXT ) pProcessSymbols )
( pSymbols, uiSymbols, szModuleName,
ulID, uiPcodeMin, uiPcodeMax );
/* else
* may we issue an error ? */
return pSymbols;
}
void hb_vmExecute( const BYTE * pCode, PHB_SYMB pSymbols )
@@ -768,15 +785,6 @@ BOOL hb_arrayLast( PHB_ITEM pArray, PHB_ITEM pResult ) /* retrieve last ite
return FALSE;
}
BOOL hb_arrayRelease( PHB_ITEM pArray ) /* releases an array - don't call it - use ItemRelease() !!! */
{
HB_ARRAYRELEASE pArrayRelease = (HB_ARRAYRELEASE)GetProcAddress( GetModuleHandle( NULL ), "_hb_arrayRelease" );
if (pArrayRelease)
return pArrayRelease( pArray );
else
return FALSE;
}
BOOL hb_arraySet( PHB_ITEM pArray, ULONG ulIndex, PHB_ITEM pItem ) /* sets an array element */
{
HB_ARRAYSET pArraySet = (HB_ARRAYSET)GetProcAddress( GetModuleHandle( NULL ), "_hb_arraySet" );

49
harbour/source/vm/memvars.c
View File

@@ -205,7 +205,7 @@ HB_HANDLE hb_memvarValueNew( HB_ITEM_PTR pSource, BOOL bTrueMemvar )
s_globalTable = ( HB_VALUE_PTR ) hb_xrealloc( s_globalTable, sizeof( HB_VALUE ) * s_globalTableSize );
}
}
pValue = s_globalTable + hValue;
pValue->pVarItem = ( HB_ITEM_PTR ) hb_xgrab( sizeof( HB_ITEM ) );
pValue->counter = 1;
@@ -219,9 +219,9 @@ HB_HANDLE hb_memvarValueNew( HB_ITEM_PTR pSource, BOOL bTrueMemvar )
}
if( bTrueMemvar )
pValue->hPrevMemvar = 0;
pValue->hPrevMemvar = 0;
else
pValue->hPrevMemvar = ( HB_HANDLE )-1; /* detached variable */
pValue->hPrevMemvar = ( HB_HANDLE ) -1; /* detached variable */
HB_TRACE(HB_TR_INFO, ("hb_memvarValueNew: memvar item created with handle %i", hValue));
@@ -233,7 +233,7 @@ HB_HANDLE hb_memvarValueNew( HB_ITEM_PTR pSource, BOOL bTrueMemvar )
HB_ITEM_PTR hb_memvarDetachLocal( HB_ITEM_PTR pLocal )
{
HB_TRACE(HB_TR_DEBUG, ("hb_memvarDetachLocal(%p, %d)", pLocal, pLocal->type ));
if( HB_IS_BYREF( pLocal ) && ! HB_IS_MEMVAR( pLocal ) )
{
HB_ITEM_PTR pItem = pLocal;
@@ -311,8 +311,7 @@ void hb_memvarSetPrivatesBase( ULONG ulBase )
while( s_privateStackCnt > s_privateStackBase )
{
--s_privateStackCnt;
hVar = s_privateStack[ s_privateStackCnt ]->hMemvar;
hVar = s_privateStack[ --s_privateStackCnt ]->hMemvar;
if( hVar )
{
hOldValue = s_globalTable[ hVar ].hPrevMemvar;
@@ -373,7 +372,7 @@ void hb_memvarValueDecRef( HB_HANDLE hValue )
if( pValue->counter > 0 )
{
/* Notice that Counter can be equal to 0.
/* Notice that Counter can be equal to 0.
* This can happen if for example PUBLIC variable holds a codeblock
* with detached variable. When hb_memvarsRelease() is called then
* detached variable can be released before the codeblock. So if
@@ -382,7 +381,8 @@ void hb_memvarValueDecRef( HB_HANDLE hValue )
*/
if( --pValue->counter == 0 )
{
hb_itemClear( pValue->pVarItem );
if( HB_IS_COMPLEX( pValue->pVarItem ) )
hb_itemClear( pValue->pVarItem );
hb_xfree( pValue->pVarItem );
hb_memvarRecycle( hValue );
@@ -391,6 +391,7 @@ void hb_memvarValueDecRef( HB_HANDLE hValue )
}
}
#if 0
/* This function is called from releasing of detached local variables
* referenced in a codeblock that is wiped out by the Garbage Collector.
* Decrement the reference counter and clear a value stored in the memvar.
@@ -409,7 +410,7 @@ void hb_memvarValueDecGarbageRef( HB_HANDLE hValue )
if( pValue->counter > 0 )
{
/* Notice that Counter can be equal to 0.
/* Notice that Counter can be equal to 0.
* This can happen if for example PUBLIC variable holds a codeblock
* with detached variable. When hb_memvarsRelease() is called then
* detached variable can be released before the codeblock. So if
@@ -427,6 +428,7 @@ void hb_memvarValueDecGarbageRef( HB_HANDLE hValue )
}
}
}
#endif
/*
* This functions copies passed item value into the memvar pointed
@@ -513,7 +515,7 @@ void hb_memvarGetValue( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
while( uiAction == E_RETRY )
{
@@ -556,7 +558,7 @@ void hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
HB_ITEM_PTR pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
while( uiAction == E_RETRY )
{
@@ -581,6 +583,24 @@ void hb_memvarGetRefer( HB_ITEM_PTR pItem, PHB_SYMB pMemvarSymb )
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
}
PHB_ITEM hb_memvarGetItem( PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetItem(%p)", pMemvarSymb));
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn && pDyn->hMemvar )
{
HB_ITEM_PTR pItem = s_globalTable[ pDyn->hMemvar ].pVarItem;
if( HB_IS_BYREF( pItem ) )
return hb_itemUnRef( pItem );
else
return pItem;
}
return NULL;
}
/*
*/
void hb_memvarNewParameter( PHB_SYMB pSymbol, PHB_ITEM pValue )
@@ -643,7 +663,8 @@ void hb_memvarCreateFromItem( PHB_ITEM pMemvar, BYTE bScope, PHB_ITEM pValue )
/* find dynamic symbol or creeate one */
if( HB_IS_SYMBOL( pMemvar ) )
pDynVar = hb_dynsymGet( pMemvar->item.asSymbol.value->szName );
/* pDynVar = hb_dynsymGet( pMemvar->item.asSymbol.value->szName ); */
pDynVar = pMemvar->item.asSymbol.value->pDynSym;
else if( HB_IS_STRING( pMemvar ) )
pDynVar = hb_dynsymGet( pMemvar->item.asString.value );
else
@@ -1201,8 +1222,8 @@ HB_FUNC( __MVGET )
{
PHB_ITEM pValue;
pValue = hb_stackTopItem();
hb_stackPush();
pValue = hb_stackItemFromTop( -1 );
hb_memvarGetValue( pValue, pDynVar->pSymbol );
hb_itemReturnForward( pValue );
hb_stackDec();
@@ -1229,8 +1250,8 @@ HB_FUNC( __MVGET )
{
PHB_ITEM pValue;
pValue = hb_stackTopItem();
hb_stackPush();
pValue = hb_stackItemFromTop( -1 );
hb_memvarGetValue( pValue, pDynVar->pSymbol );
hb_itemReturnForward( pValue );
hb_stackDec();

1
harbour/source/vm/proc.c
View File

@@ -69,6 +69,7 @@
#include "hbvmopt.h"
#include "hbapi.h"
#include "hbapicls.h"
#include "hbapiitm.h"
#include "hbstack.h"

7
harbour/source/vm/pvalue.c
View File

@@ -58,10 +58,11 @@
HB_FUNC( HB_PVALUE )
{
USHORT uiParam = hb_parni( 1 );
PHB_ITEM *pBase = hb_stack.pItems + ( hb_stackBaseItem() )->item.asSymbol.stackbase; /* Skip function + self */
LONG lOffset = hb_stackBaseItem()->item.asSymbol.stackbase; /* Skip function + self */
PHB_ITEM pBase = hb_stackItem( lOffset );
if( uiParam && uiParam <= ( *pBase )->item.asSymbol.paramcnt ) /* Valid number */
hb_itemReturn( *( pBase + 1 + uiParam ) );
if( uiParam && uiParam <= pBase->item.asSymbol.paramcnt ) /* Valid number */
hb_itemReturn( hb_stackItem( lOffset + 1 + uiParam ) );
else
hb_ret(); /* return NIL */
}

892
harbour/source/vm/runner.c
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More