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

see changelog

Browse Source
This commit is contained in:
Eddie Runia
1999-07-09 15:34:16 +00:00
parent 20d1b3ab8b
commit 795f8afb57
11 changed files with 130 additions and 1098 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
harbour/ChangeLog
View File

@@ -1,3 +1,17 @@
19990709-16:25 Eddie Runia
* build32.bat; source/runner/runner.c; source/runner/run_exp.h;
tests/working/hb32.bat; tests/working/runrdos.bat
- tests/working/runner.c; tests/working/run_exp.h
runner moved to /source/runner
* source/vm/initsymb.c; include/init.h
init symbols no longer worked both on Borland C++ Builder as well as
DJGPP
+ source/compiler/harbour.l
include bug for DJGPP resolved
* tests/working/ainstest.prg
copy error resolved
19990709-20:00 Andi Jahja <andij@aonlippo.co.id>
+ tests/broken/clasname.prg by Dave Pearson
+ tests/broken/statics1.prg by Bruno Cantero

2
harbour/build32.bat
View File

@@ -4,6 +4,6 @@ make -fmakefile.b32 > build32.err
make -fterminal.b32 >> build32.err
call bldgt32.bat >> build32.err
cd tests\working
call bld32exe.bat runner >> build32.err
call bld32exe.bat ..\..\source\runner\runner runner >> build32.err
cd ..\..
edit build32.err

26
harbour/include/init.h
View File

@@ -50,14 +50,14 @@ static SYMBOL symbols[] = {
static SYMBOL symbols[] = {
#define HB_INIT_SYMBOLS_END( func ) }; \
static void __attribute__ ((constructor)) func( void ) \
void __attribute__ ((constructor)) func( void ) \
{ \
ProcessSymbols( symbols, sizeof( symbols ) / sizeof( SYMBOL ) ); \
}
#define HB_CALL_ON_STARTUP_BEGIN( func ) \
static void __attribute__ ((constructor)) func( void ) {
void __attribute__ ((constructor)) func( void ) {
#define HB_CALL_ON_STARTUP_END( func ) }
#endif
@@ -68,13 +68,13 @@ static SYMBOL symbols[] = {
static SYMBOL symbols[] = {
#define HB_INIT_SYMBOLS_END( func ) }; \
static void func( void ) \
void func( void ) \
{ \
ProcessSymbols( symbols, sizeof( symbols ) / sizeof( SYMBOL ) ); \
}
#define HB_CALL_ON_STARTUP_BEGIN( func ) \
static void func( void ) {
void func( void ) {
#define HB_CALL_ON_STARTUP_END( func ) }
#endif
@@ -84,37 +84,37 @@ static SYMBOL symbols[] = {
static SYMBOL symbols[] = {
#define HB_INIT_SYMBOLS_END( func ) }; \
static int func( void ) \
int func( void ) \
{ \
ProcessSymbols( symbols, sizeof( symbols ) / sizeof( SYMBOL ) ); \
return 1; \
}; \
static int static_int_##func = func()
int static_int_##func = func()
#define HB_CALL_ON_STARTUP_BEGIN( func ) \
static int func( void ) {
int func( void ) {
#define HB_CALL_ON_STARTUP_END( func ) return 1; } \
static int static_int_##func = func()
int static_int_##func = func()
#endif
#ifdef __WATCOMC__
#define HB_INIT_SYMBOLS_BEGIN( func ) \
static SYMBOL symbols[] = {
SYMBOL symbols[] = {
#define HB_INIT_SYMBOLS_END( func ) }; \
static int func( void ) \
int func( void ) \
{ \
ProcessSymbols( symbols, sizeof( symbols ) / sizeof( SYMBOL ) ); \
return 1; \
}; \
static int static_int_##func = func()
int static_int_##func = func()
#define HB_CALL_ON_STARTUP_BEGIN( func ) \
static int func( void ) {
int func( void ) {
#define HB_CALL_ON_STARTUP_END( func ) return 1; }; \
static int static_int_##func = func()
int static_int_##func = func()
#endif
#endif /*HARBOUR_STRICT_ANSI_C */

6
harbour/source/compiler/harbour.l
View File

@@ -35,7 +35,11 @@
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "harboury.h"
#if __DJGPP__
#include "./harboury.h"
#else
#include "harboury.h"
#endif
#include "hbsetup.h" /* main configuration file */
#include "hberrors.h"
#include "hbdefs.h"

258
harbour/source/runner/run_exp.h
View File

@@ -7,105 +7,33 @@
* If the discussion has finished, it can be removed from here.
*
*/
HARBOUR HB___ACCEPT();
HARBOUR HB_OUTSTD();
HARBOUR HB_OUTERR();
HARBOUR HB_DEVPOS();
HARBOUR HB_DEVOUT();
HARBOUR HB_EJECT();
HARBOUR HB_QQOUT();
HARBOUR HB_QOUT();
HARBOUR HB_ERRORSYS();
HARBOUR HB_ERRORNEW();
HARBOUR HB_EVAL();
HARBOUR HB_VALTYPE();
HARBOUR HB_ASORT();
HARBOUR HB_STOD();
HARBOUR HB_SETCENTURY();
HARBOUR HB_SET();
HARBOUR HB_OS();
HARBOUR HB_FOPEN();
HARBOUR HB_FCREATE();
HARBOUR HB_FREAD();
HARBOUR HB_FWRITE();
HARBOUR HB_FERROR();
HARBOUR HB_FCLOSE();
HARBOUR HB_FERASE();
HARBOUR HB_FRENAME();
HARBOUR HB_FSEEK();
HARBOUR HB_FILE();
HARBOUR HB_FREADSTR();
HARBOUR HB_BIN2I();
HARBOUR HB_BIN2L();
HARBOUR HB_BIN2W();
HARBOUR HB_I2BIN();
HARBOUR HB_L2BIN();
HARBOUR HB_W2BIN();
HARBOUR HB_EXP();
HARBOUR HB_LOG();
HARBOUR HB_MOD();
HARBOUR HB_DEFAULT();
HARBOUR HB_TOCHAR();
HARBOUR HB_DEBUG();
HARBOUR HB_ISALPHA();
HARBOUR HB_ISDIGIT();
HARBOUR HB_ISUPPER();
HARBOUR HB_ISLOWER();
HARBOUR HB_LTRIM();
HARBOUR HB_TRIM();
HARBOUR HB_ALLTRIM();
HARBOUR HB_PADR();
HARBOUR HB_PAD();
HARBOUR HB_PADL();
HARBOUR HB_PADC();
HARBOUR HB_RAT();
HARBOUR HB_RIGHT();
HARBOUR HB_SPACE();
HARBOUR HB_STUFF();
HARBOUR HB_STRTRAN();
HARBOUR HB_DATETIME();
HARBOUR HB_DOW();
HARBOUR HB___ASTATIC();
HARBOUR HB___STATIC();
HARBOUR HB___GLOBALSTACKLEN();
HARBOUR HB___AGLOBALSTACK();
HARBOUR HB___STACKLEN();
HARBOUR HB___ASTACK();
HARBOUR HB___APARAM();
HARBOUR HB___ASTACK();
HARBOUR HB___ASTATIC();
HARBOUR HB___GLOBALSTACKLEN();
HARBOUR HB___STACKLEN();
HARBOUR HB___STATIC();
HARBOUR HB_ACOS();
HARBOUR HB_ASIN();
HARBOUR HB_ATAN();
HARBOUR HB_COS();
HARBOUR HB_COSH();
HARBOUR HB_LOG10();
HARBOUR HB_SIN();
HARBOUR HB_SINH();
HARBOUR HB_TAN();
HARBOUR HB_TANH();
HARBOUR HB_STRDUMP();
HARBOUR HB_STRTOKEN();
HARBOUR HB_ROT13();
HARBOUR HB_PVALUE();
HARBOUR HB_HB_FUSE();
HARBOUR HB_HB_FRECNO();
HARBOUR HB_HB_FLASTREC();
HARBOUR HB_HB_FGOTOP();
HARBOUR HB_HB_FGOBOTTOM();
HARBOUR HB_HB_FGOTO();
HARBOUR HB_HB_FEOF();
HARBOUR HB_HB_FREADLN();
HARBOUR HB_HB_FSKIP();
HARBOUR HB_GETENV();
HARBOUR HB_DIRECTORY();
HARBOUR HB_DATETIME();
HARBOUR HB_DEBUG();
HARBOUR HB_DEFAULT();
HARBOUR HB_ERRORNEW();
HARBOUR HB_ERRORSYS();
HARBOUR HB_EVAL();
HARBOUR HB_GT_ASCIISUM();
HARBOUR HB_GT_ASCPOS();
HARBOUR HB_GT_ATDIFF();
HARBOUR HB_GT_CHAREVEN();
HARBOUR HB_GT_CHARMIX();
HARBOUR HB_GT_CHARODD();
HARBOUR HB_GT_CHRCOUNT();
HARBOUR HB_GT_CHRTOTAL();
HARBOUR HB_GT_CHARMIX();
HARBOUR HB_GT_ASCIISUM();
HARBOUR HB_GT_CHRFIRST();
HARBOUR HB_GT_CHRTOTAL();
HARBOUR HB_GT_STRCOUNT();
HARBOUR HB_GT_STRCSPN();
HARBOUR HB_GT_STRDIFF();
@@ -113,12 +41,26 @@ HARBOUR HB_GT_STREXPAND();
HARBOUR HB_GT_STRLEFT();
HARBOUR HB_GT_STRPBRK();
HARBOUR HB_GT_STRRIGHT();
HARBOUR HB_MAXROW();
HARBOUR HB_MAXCOL();
HARBOUR HB_SETPRC();
HARBOUR HB_SCROLL();
HARBOUR HB_VERSION();
HARBOUR HB_SETFIXED();
HARBOUR HB_HB_FEOF();
HARBOUR HB_HB_FGOBOTTOM();
HARBOUR HB_HB_FGOTO();
HARBOUR HB_HB_FGOTOP();
HARBOUR HB_HB_FLASTREC();
HARBOUR HB_HB_FREADLN();
HARBOUR HB_HB_FRECNO();
HARBOUR HB_HB_FSKIP();
HARBOUR HB_HB_FUSE();
HARBOUR HB_LOG10();
HARBOUR HB_PVALUE();
HARBOUR HB_ROT13();
HARBOUR HB_SIN();
HARBOUR HB_SINH();
HARBOUR HB_STRDUMP();
HARBOUR HB_STRTOKEN();
HARBOUR HB_TAN();
HARBOUR HB_TANH();
HARBOUR HB_TOCHAR();
HARBOUR HB_VALTYPE();
/* Same story.
@@ -126,107 +68,35 @@ HARBOUR HB_SETFIXED();
Including Runner itself, since the first symbol gets executed by Harbour ;-)
*/
static SYMBOL symbols[] = {
HB_INIT_SYMBOLS_BEGIN( RUNNER )
{ "HB_RUN", FS_PUBLIC, HB_HB_RUN , 0 },
{ "__ACCEPT", FS_PUBLIC, HB___ACCEPT , 0 },
{ "OUTSTD", FS_PUBLIC, HB_OUTSTD , 0 },
{ "OUTERR", FS_PUBLIC, HB_OUTERR , 0 },
{ "DEVPOS", FS_PUBLIC, HB_DEVPOS , 0 },
{ "DEVOUT", FS_PUBLIC, HB_DEVOUT , 0 },
{ "EJECT", FS_PUBLIC, HB_EJECT , 0 },
{ "QQOUT", FS_PUBLIC, HB_QQOUT , 0 },
{ "QOUT", FS_PUBLIC, HB_QOUT , 0 },
{ "ERRORSYS", FS_PUBLIC, HB_ERRORSYS , 0 },
{ "ERRORNEW", FS_PUBLIC, HB_ERRORNEW , 0 },
{ "EVAL", FS_PUBLIC, HB_EVAL , 0 },
{ "VALTYPE", FS_PUBLIC, HB_VALTYPE , 0 },
{ "ASORT", FS_PUBLIC, HB_ASORT , 0 },
{ "STOD", FS_PUBLIC, HB_STOD , 0 },
{ "SETCENTURY", FS_PUBLIC, HB_SETCENTURY , 0 },
{ "SET", FS_PUBLIC, HB_SET , 0 },
{ "OS", FS_PUBLIC, HB_OS , 0 },
{ "FOPEN", FS_PUBLIC, HB_FOPEN , 0 },
{ "FCREATE", FS_PUBLIC, HB_FCREATE , 0 },
{ "FREAD", FS_PUBLIC, HB_FREAD , 0 },
{ "FWRITE", FS_PUBLIC, HB_FWRITE , 0 },
{ "FERROR", FS_PUBLIC, HB_FERROR , 0 },
{ "FCLOSE", FS_PUBLIC, HB_FCLOSE , 0 },
{ "FERASE", FS_PUBLIC, HB_FERASE , 0 },
{ "FRENAME", FS_PUBLIC, HB_FRENAME , 0 },
{ "FSEEK", FS_PUBLIC, HB_FSEEK , 0 },
{ "FILE", FS_PUBLIC, HB_FILE , 0 },
{ "FREADSTR", FS_PUBLIC, HB_FREADSTR , 0 },
{ "BIN2I", FS_PUBLIC, HB_BIN2I , 0 },
{ "BIN2L", FS_PUBLIC, HB_BIN2L , 0 },
{ "BIN2W", FS_PUBLIC, HB_BIN2W , 0 },
{ "I2BIN", FS_PUBLIC, HB_I2BIN , 0 },
{ "L2BIN", FS_PUBLIC, HB_L2BIN , 0 },
{ "W2BIN", FS_PUBLIC, HB_W2BIN , 0 },
{ "EXP", FS_PUBLIC, HB_EXP , 0 },
{ "LOG", FS_PUBLIC, HB_LOG , 0 },
{ "MOD", FS_PUBLIC, HB_MOD , 0 },
{ "DEFAULT", FS_PUBLIC, HB_DEFAULT , 0 },
{ "TOCHAR", FS_PUBLIC, HB_TOCHAR , 0 },
{ "DEBUG", FS_PUBLIC, HB_DEBUG , 0 },
{ "ISALPHA", FS_PUBLIC, HB_ISALPHA , 0 },
{ "ISDIGIT", FS_PUBLIC, HB_ISDIGIT , 0 },
{ "ISUPPER", FS_PUBLIC, HB_ISUPPER , 0 },
{ "ISLOWER", FS_PUBLIC, HB_ISLOWER , 0 },
{ "LTRIM", FS_PUBLIC, HB_LTRIM , 0 },
{ "TRIM", FS_PUBLIC, HB_TRIM , 0 },
{ "ALLTRIM", FS_PUBLIC, HB_ALLTRIM , 0 },
{ "PADR", FS_PUBLIC, HB_PADR , 0 },
{ "PAD", FS_PUBLIC, HB_PAD , 0 },
{ "PADL", FS_PUBLIC, HB_PADL , 0 },
{ "PADC", FS_PUBLIC, HB_PADC , 0 },
{ "RAT", FS_PUBLIC, HB_RAT , 0 },
{ "RIGHT", FS_PUBLIC, HB_RIGHT , 0 },
{ "SPACE", FS_PUBLIC, HB_SPACE , 0 },
{ "STUFF", FS_PUBLIC, HB_STUFF , 0 },
{ "STRTRAN", FS_PUBLIC, HB_STRTRAN , 0 },
{ "DATETIME", FS_PUBLIC, HB_DATETIME , 0 },
{ "DOW", FS_PUBLIC, HB_DOW , 0 },
{ "__ASTATIC", FS_PUBLIC, HB___ASTATIC , 0 },
{ "__STATIC", FS_PUBLIC, HB___STATIC , 0 },
{ "__GLOBALSTACKLEN", FS_PUBLIC, HB___GLOBALSTACKLEN, 0 },
{ "__AGLOBALSTACK", FS_PUBLIC, HB___AGLOBALSTACK, 0 },
{ "__STACKLEN", FS_PUBLIC, HB___STACKLEN , 0 },
{ "__ASTACK", FS_PUBLIC, HB___ASTACK , 0 },
{ "__APARAM", FS_PUBLIC, HB___APARAM , 0 },
{ "__ASTACK", FS_PUBLIC, HB___ASTACK , 0 },
{ "__ASTATIC", FS_PUBLIC, HB___ASTATIC , 0 },
{ "__GLOBALSTACKLEN", FS_PUBLIC, HB___GLOBALSTACKLEN, 0 },
{ "__STACKLEN", FS_PUBLIC, HB___STACKLEN , 0 },
{ "__STATIC", FS_PUBLIC, HB___STATIC , 0 },
{ "ACOS", FS_PUBLIC, HB_ACOS , 0 },
{ "ASIN", FS_PUBLIC, HB_ASIN , 0 },
{ "ATAN", FS_PUBLIC, HB_ATAN , 0 },
{ "COS", FS_PUBLIC, HB_COS , 0 },
{ "COSH", FS_PUBLIC, HB_COSH , 0 },
{ "LOG10", FS_PUBLIC, HB_LOG10 , 0 },
{ "SIN", FS_PUBLIC, HB_SIN , 0 },
{ "SINH", FS_PUBLIC, HB_SINH , 0 },
{ "TAN", FS_PUBLIC, HB_TAN , 0 },
{ "TANH", FS_PUBLIC, HB_TANH , 0 },
{ "STRDUMP", FS_PUBLIC, HB_STRDUMP , 0 },
{ "STRTOKEN", FS_PUBLIC, HB_STRTOKEN , 0 },
{ "ROT13", FS_PUBLIC, HB_ROT13 , 0 },
{ "PVALUE", FS_PUBLIC, HB_PVALUE , 0 },
{ "HB_FUSE", FS_PUBLIC, HB_HB_FUSE , 0 },
{ "HB_FRECNO", FS_PUBLIC, HB_HB_FRECNO , 0 },
{ "HB_FLASTREC", FS_PUBLIC, HB_HB_FLASTREC , 0 },
{ "HB_FGOTOP", FS_PUBLIC, HB_HB_FGOTOP , 0 },
{ "HB_FGOBOTTOM", FS_PUBLIC, HB_HB_FGOBOTTOM , 0 },
{ "HB_FGOTO", FS_PUBLIC, HB_HB_FGOTO , 0 },
{ "HB_FEOF", FS_PUBLIC, HB_HB_FEOF , 0 },
{ "HB_FREADLN", FS_PUBLIC, HB_HB_FREADLN , 0 },
{ "HB_FSKIP", FS_PUBLIC, HB_HB_FSKIP , 0 },
{ "GETENV", FS_PUBLIC, HB_GETENV , 0 },
{ "DIRECTORY", FS_PUBLIC, HB_DIRECTORY , 0 },
{ "DATETIME", FS_PUBLIC, HB_DATETIME , 0 },
{ "DEBUG", FS_PUBLIC, HB_DEBUG , 0 },
{ "DEFAULT", FS_PUBLIC, HB_DEFAULT , 0 },
{ "ERRORSYS", FS_PUBLIC, HB_ERRORSYS , 0 },
{ "ERRORNEW", FS_PUBLIC, HB_ERRORNEW , 0 },
{ "EVAL", FS_PUBLIC, HB_EVAL , 0 },
{ "GT_ASCIISUM", FS_PUBLIC, HB_GT_ASCIISUM , 0 },
{ "GT_ASCPOS", FS_PUBLIC, HB_GT_ASCPOS , 0 },
{ "GT_ATDIFF", FS_PUBLIC, HB_GT_ATDIFF , 0 },
{ "GT_CHAREVEN", FS_PUBLIC, HB_GT_CHAREVEN , 0 },
{ "GT_CHARODD", FS_PUBLIC, HB_GT_CHARODD , 0 },
{ "GT_CHRCOUNT", FS_PUBLIC, HB_GT_CHRCOUNT , 0 },
{ "GT_CHRTOTAL", FS_PUBLIC, HB_GT_CHRTOTAL , 0 },
{ "GT_CHARMIX", FS_PUBLIC, HB_GT_CHARMIX , 0 },
{ "GT_ASCIISUM", FS_PUBLIC, HB_GT_ASCIISUM , 0 },
{ "GT_CHRCOUNT", FS_PUBLIC, HB_GT_CHRCOUNT , 0 },
{ "GT_CHRFIRST", FS_PUBLIC, HB_GT_CHRFIRST , 0 },
{ "GT_CHRTOTAL", FS_PUBLIC, HB_GT_CHRTOTAL , 0 },
{ "GT_STRCOUNT", FS_PUBLIC, HB_GT_STRCOUNT , 0 },
{ "GT_STRCSPN", FS_PUBLIC, HB_GT_STRCSPN , 0 },
{ "GT_STRDIFF", FS_PUBLIC, HB_GT_STRDIFF , 0 },
@@ -234,13 +104,27 @@ static SYMBOL symbols[] = {
{ "GT_STRLEFT", FS_PUBLIC, HB_GT_STRLEFT , 0 },
{ "GT_STRPBRK", FS_PUBLIC, HB_GT_STRPBRK , 0 },
{ "GT_STRRIGHT", FS_PUBLIC, HB_GT_STRRIGHT , 0 },
{ "MAXROW", FS_PUBLIC, HB_MAXROW , 0 },
{ "MAXCOL", FS_PUBLIC, HB_MAXCOL , 0 },
{ "SETPRC", FS_PUBLIC, HB_SETPRC , 0 },
{ "SCROLL", FS_PUBLIC, HB_SCROLL , 0 },
{ "VERSION", FS_PUBLIC, HB_VERSION , 0 },
{ "SETFIXED", FS_PUBLIC, HB_SETFIXED , 0 }
};
{ "HB_FEOF", FS_PUBLIC, HB_HB_FEOF , 0 },
{ "HB_FGOBOTTOM", FS_PUBLIC, HB_HB_FGOBOTTOM , 0 },
{ "HB_FGOTO", FS_PUBLIC, HB_HB_FGOTO , 0 },
{ "HB_FGOTOP", FS_PUBLIC, HB_HB_FGOTOP , 0 },
{ "HB_FLASTREC", FS_PUBLIC, HB_HB_FLASTREC , 0 },
{ "HB_FRECNO", FS_PUBLIC, HB_HB_FRECNO , 0 },
{ "HB_FREADLN", FS_PUBLIC, HB_HB_FREADLN , 0 },
{ "HB_FSKIP", FS_PUBLIC, HB_HB_FSKIP , 0 },
{ "HB_FUSE", FS_PUBLIC, HB_HB_FUSE , 0 },
{ "LOG10", FS_PUBLIC, HB_LOG10 , 0 },
{ "PVALUE", FS_PUBLIC, HB_PVALUE , 0 },
{ "ROT13", FS_PUBLIC, HB_ROT13 , 0 },
{ "SIN", FS_PUBLIC, HB_SIN , 0 },
{ "SINH", FS_PUBLIC, HB_SINH , 0 },
{ "STRDUMP", FS_PUBLIC, HB_STRDUMP , 0 },
{ "STRTOKEN", FS_PUBLIC, HB_STRTOKEN , 0 },
{ "TAN", FS_PUBLIC, HB_TAN , 0 },
{ "TANH", FS_PUBLIC, HB_TANH , 0 },
{ "TOCHAR", FS_PUBLIC, HB_TOCHAR , 0 },
{ "VALTYPE", FS_PUBLIC, HB_VALTYPE , 0 }
HB_INIT_SYMBOLS_END( RUNNER );
#pragma startup RUNNER

76
harbour/source/runner/runner.c
View File

@@ -1,35 +1,8 @@
/*
* Runner - Dynamic Library load routine
*
* Copyright (C) 1999 Eddie Runia (eddie@runia.com)
* Part of the Harbour Project 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 of the License, or
* (at your option) any later version, with one exception:
*
* The exception is that if you link the Harbour Runtime Library (HRL)
* and/or the Harbour Virtual Machine (HVM) 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 HRL
* and/or HVM code into it.
*
* 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 program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit
* their web site at http://www.gnu.org/).
*/
#include "pcode.h"
#define FILE _FILE
#include <errorapi.h>
#include <stdio.h>
#include <init.h>
/* #if INTEL32 */
static BYTE prgFunction[] = { 0x68, 0x00, 0x00, 0x00, 0x00,
@@ -74,19 +47,19 @@ typedef struct
#define SYM_NOT_FOUND 0xFFFFFFFF /* Symbol not found.
FindSymbol */
PASM_CALL CreateFun( PSYMBOL, PBYTE ); /* Create a dynamic function*/
void Do( WORD );
ULONG FindSymbol( char *, PDYNFUNC, ULONG );
HARBOUR HB_HB_RUN(void);
void HRB_FileClose( _FILE * );
void HRB_FileRead ( char *, int, int, _FILE * );
_FILE *HRB_FileOpen ( char * );
void Push( PITEM );
void PushNil( void );
void PushSymbol( PSYMBOL );
BYTE ReadByte( _FILE * );
char *ReadId ( _FILE * );
long ReadLong( _FILE * );
static PASM_CALL CreateFun( PSYMBOL, PBYTE ); /* Create a dynamic function*/
void Do( WORD );
static ULONG FindSymbol( char *, PDYNFUNC, ULONG );
HARBOUR HB_HB_RUN();
static void HRB_FileClose( FILE * );
static void HRB_FileRead ( char *, int, int, FILE * );
static FILE *HRB_FileOpen ( char * );
void Push( PHB_ITEM );
void PushNil( void );
void PushSymbol( PSYMBOL );
BYTE ReadByte( FILE * );
char *ReadId ( FILE * );
long ReadLong( FILE * );
#include "run_exp.h"
@@ -100,8 +73,6 @@ long ReadLong( _FILE * );
*
*/
#include <init.h>
ULONG ulSymEntry = 0; /* Link enhancement */
/*
@@ -139,13 +110,13 @@ HARBOUR HB_HB_RUN( void )
if( file )
{
ulSymbols = ReadLong( file );
pSymRead = hb_xgrab( ulSymbols * sizeof( SYMBOL ) );
pSymRead = ( PSYMBOL )hb_xgrab( ulSymbols * sizeof( SYMBOL ) );
for( ul=0; ul < ulSymbols; ul++) /* Read symbols in .HRB */
{
pSymRead[ ul ].szName = ReadId( file );
pSymRead[ ul ].cScope = ReadByte( file );
pSymRead[ ul ].pFunPtr = (void *) ReadByte( file );
pSymRead[ ul ].pFunPtr = ( HARBOURFUNC ) ReadByte( file );
pSymRead[ ul ].pDynSym = NULL;
}
@@ -156,7 +127,7 @@ HARBOUR HB_HB_RUN( void )
pDynFunc[ ul ].szName = ReadId( file );
ulSize = ReadLong( file ) + 1; /* Read size of function */
pDynFunc[ ul ].pCode = hb_xgrab( ulSize );
pDynFunc[ ul ].pCode = ( PBYTE )hb_xgrab( ulSize );
HRB_FileRead( pDynFunc[ ul ].pCode, 1, ulSize, file );
/* Read the block */
@@ -184,7 +155,7 @@ HARBOUR HB_HB_RUN( void )
pSymRead[ ul ].pFunPtr = pDynFunc[ ulPos ].pAsmCall->pFunPtr;
}
else
pSymRead[ ul ].pFunPtr = (void *) SYM_EXTERN;
pSymRead[ ul ].pFunPtr = ( HARBOURFUNC ) SYM_EXTERN;
}
if( ( (ULONG) pSymRead[ ul ].pFunPtr ) == SYM_EXTERN )
{ /* External function */
@@ -288,14 +259,13 @@ static ULONG FindSymbol( char *szName, PDYNFUNC pDynFunc, ULONG ulLoaded )
Read the next (zero terminated) identifier */
char *ReadId( FILE *file )
{
char *szFileName;
char *szTemp; /* Temporary buffer */
char *szIdx;
char *szRet;
BYTE bCont = TRUE;
szTemp = hb_xgrab( 256 );
szTemp = ( char * )hb_xgrab( 256 );
szIdx = szTemp;
do
{
@@ -331,7 +301,7 @@ long ReadLong( FILE *file )
if( cLong[3] ) /* Convert to long if ok */
{
PITEM pError = hb_errNew();
PHB_ITEM pError = hb_errNew();
hb_errPutDescription(pError, "Error reading .HRB file");
hb_errLaunch(pError);
hb_errRelease(pError);
@@ -351,7 +321,7 @@ static void HRB_FileRead( char *cBuffer, int iSize, int iCount, FILE *fStream )
{
if( iCount != (int) fread( cBuffer, iSize, iCount, fStream ) )
{ /* Read error */
PITEM pError = hb_errNew();
PHB_ITEM pError = hb_errNew();
hb_errPutDescription(pError, "Error reading .HRB file");
hb_errLaunch(pError);
hb_errRelease(pError);

4
harbour/source/vm/initsymb.c
View File

@@ -153,7 +153,6 @@ void InitSymbolTable( void )
/*
* The symbol tables from runtime support modules start here
*/
#ifdef HARBOUR_STRICT_ANSI_C
Arrays__InitSymbols();
Classes__InitSymbols();
Console__InitSymbols();
@@ -168,10 +167,9 @@ void InitSymbolTable( void )
Set__InitSymbols();
Strings__InitSymbols();
#ifdef HARBOUR_STRICT_CLIPPER_COMPATIBILITY
Strings__InitInfinity
Strings__InitInfinity();
#endif
Transfrm__InitSymbols();
#endif
/*
* The system symbol table with runtime functions HAVE TO be called last

258
harbour/tests/working/ainstest.prg
View File

@@ -1,261 +1,3 @@
/*
* $Doc$
* $Description$ Debug function tests.
* Based on classes.prg
* $Requirement$ source\tools\stringp.prg
* source\rtl\objfunc.prg
* source\rtl\asort.prg
* $Date$
* $End$
*
* Copyright (C) 1999 Eddie Runia <eddie@runia.com>
* www - http://www.harbour-project.org
*
* Placed in the public domain
*
*/
function Main()
local oForm := TForm():New()
local nNumber := 15
QOut( oForm:ClassName() )
oForm:Show()
QOut()
QOut( "-OBJECT additions-" )
QOut( "What is in oForm ? " )
Debug( oForm:Transfer() )
QOut( "Does transfer exists ? ", IsMessage( oForm, "Transfer" ) )
QOut( "Is transfer DATA ? ", IsData ( oForm, "Transfer" ) )
QOut( "Is transfer METHOD ? ", IsMethod ( oForm, "Transfer" ) )
QOut( "Does nLeft exists ? ", IsMessage( oForm, "nLeft" ) )
QOut( "Is nLeft DATA ? ", IsData ( oForm, "nLeft" ) )
QOut( "Is nLeft METHOD ? ", IsMethod ( oForm, "nLeft" ) )
QOut( "Does unknown exists ? ", IsMessage( oForm, "Unknown" ) )
QOut( "Is unknown DATA ? ", IsData ( oForm, "Unknown" ) )
QOut( "Is unknown METHOD ? ", IsMethod ( oForm, "Unknown" ) )
QOut( "Set nLeft to 50 and nRight to 100" )
oForm:Transfer( {"nLeft", 50}, {"nRight", 100} )
Debug( oForm:Transfer() )
Pause()
QOut( "-DEBUG Functions-")
QOut( "-Statics-" )
Debug( __aStatic() )
QOut( "-Global Stack-" )
Debug ( __aGlobalStack() )
QOut( "-Local Stack-" )
Debug ( __aStack() )
QOut( "-Parameters-" )
Debug ( __aParam() )
Pause()
FuncSecond( 241, "Hello" )
return nil
function Pause()
return __Accept("")
function FuncSecond( nParam, cParam, uParam )
local cWhat := "Something"
local nNumber := 2
local xParam
local xStack
QOut()
QOut( "-Second procedure-")
QOut()
QOut( "-Statics-" )
Debug ( __aStatic() )
QOut()
QOut( "-Global Stack- Len=", __GlobalStackLen() )
Debug ( __aGlobalStack() )
QOut()
QOut( "-Local Stack- Len=", __StackLen() )
xStack := Debug ( __aStack() )
QOut()
QOut( "-Parameters-" )
xParam := Debug( __aParam() )
if xParam[ xStack[ 7 ] ] == "Hello"
QOut( ":-)" )
endif
Pause()
return nil
/* $Doc$
* $FuncName$ <oForm> TForm()
* $Description$ Returns TForm object
* $End$ */
function TForm()
static oClass
if oClass == nil
oClass = TClass():New( "TFORM" ) // starts a new class definition
oClass:AddData( "cName" ) // define this class objects datas
oClass:AddData( "nTop" )
oClass:AddData( "nLeft" )
oClass:AddData( "nBottom" )
oClass:AddData( "nRight" )
oClass:AddVirtual( "aExcept" ) // Export exceptions
oClass:AddMethod( "New", @New() ) // define this class objects methods
oClass:AddMethod( "Show", @Show() )
oClass:AddMethod( "Transfer", @Transfer() )
oClass:Create() // builds this class
endif
return oClass:Instance() // builds an object of this class
/* $Doc$
* $FuncName$ <oForm> TForm:New()
* $Description$ Constructor
* $End$ */
static function New()
local Self := QSelf()
::nTop = 10
::nLeft = 10
::nBottom = 20
::nRight = 40
return Self
/* $Doc$
* $FuncName$ TForm:Show()
* $Description$ Show a form
* $End$ */
static function Show()
local Self := QSelf()
QOut( "lets show a form from here :-)" )
return nil
//
// <xRet> TForm:Transfer( [<xArg,..>] )
//
// Generic object import and export function
//
// <xArg> is present.
//
// Maximum number of arguments passed is limited to 10 !
//
// An argument can be one of the following :
//
// { <cSymbol>, <xValue> } Set DATA <cSymbol> to <xValue>
// { { <cSym1>, <xVal1> }, { <cSym2>, <xVal2> }, ... }
// Set a whole list symbols to value
// Normal way of set objects from external
// sources, like memo files.
// <oObject> Set self according to the DATA
// contained in <oObject>
// Can be used to transfer info from
// one class to another
//
// If <xArg> is not present, the current object will be returned as an array
// for description see aoSet / aoGet.
//
// The method aExcept() is called to determine the DATA which should not
// be returned. Eg. hWnd ( do not copy this DATA from external source )
//
// Say we want to copy oSource into oTarget we say :
//
// oTarget:Transfer( oSource )
//
// If we do not want 'cName' duplicated we have to use aoGet :
//
// aNewExcept := aClone( oSource:aExcept() )
// aAdd( aNewExcept, "cName" ) /* Add cName to exception list */
// oTarget:Transfer( aoGet( oSource, aNewExcept ) )
// /* Get DATA from oSource with new exceptions */
// /* Transfer DATA to oTarget */
//
// To set two DATA of oTarget :
//
// oTarget:Transfer( { "nLeft", 10 }, { "nRight", 5 } )
//
// or :
//
// aCollect := {}
// aAdd( aCollect, { "nLeft" , 10 } )
// aAdd( aCollect, { "nRight", 5 } )
// oTarget:Transfer( aCollect )
//
// Copy oSource to a memo field :
//
// DbObject->Memo := oSource:Transfer()
//
// (Re)create oTarget from the memo field :
//
// oTarget := TTarget():New()
// oTarget:Transfer( DbObject->Memo )
//
static function Transfer( x1,x2,x3,x4,x5,x6,x7,x8,x9,x10 /* etc */ )
local self := QSelf()
local aParam := __aParam()
local nLen := PCount()
local xRet
local xData
local n
if nLen == 0
xRet := aOGet( self, ::aExcept() )
else
for n := 1 to nLen
xData := aParam[ n ]
if ValType( xData ) == "A"
if ValType( xData[1] ) == "A" // 2D array passed
xRet := aOSet( self, xData )
else // 1D array passed
xRet := aOSet( self, {xData} )
endif
elseif ValType( xData ) == "O" // Object passed
xRet := ::Transfer( xData:Transfer() )
elseif ValType( xData ) != "U"
QOut( "TRANSFER: Incorrect argument(", n, ") ", xData )
endif
next n
endif
return xRet
//
// Array test aIns / aDel / aSize / aFill
//

130
harbour/tests/working/run_exp.h
View File

@@ -1,130 +0,0 @@
/*
*
* This file contains the exportable functions available to the Harbour program
*
* Currently being discussed in 'Static initializers'
*
* If the discussion has finished, it can be removed from here.
*
*/
HARBOUR HB___AGLOBALSTACK();
HARBOUR HB___APARAM();
HARBOUR HB___ASTACK();
HARBOUR HB___ASTATIC();
HARBOUR HB___GLOBALSTACKLEN();
HARBOUR HB___STACKLEN();
HARBOUR HB___STATIC();
HARBOUR HB_ACOS();
HARBOUR HB_ASIN();
HARBOUR HB_ATAN();
HARBOUR HB_COS();
HARBOUR HB_COSH();
HARBOUR HB_DATETIME();
HARBOUR HB_DEBUG();
HARBOUR HB_DEFAULT();
HARBOUR HB_ERRORNEW();
HARBOUR HB_ERRORSYS();
HARBOUR HB_EVAL();
HARBOUR HB_GT_ASCIISUM();
HARBOUR HB_GT_ASCPOS();
HARBOUR HB_GT_ATDIFF();
HARBOUR HB_GT_CHAREVEN();
HARBOUR HB_GT_CHARMIX();
HARBOUR HB_GT_CHARODD();
HARBOUR HB_GT_CHRCOUNT();
HARBOUR HB_GT_CHRFIRST();
HARBOUR HB_GT_CHRTOTAL();
HARBOUR HB_GT_STRCOUNT();
HARBOUR HB_GT_STRCSPN();
HARBOUR HB_GT_STRDIFF();
HARBOUR HB_GT_STREXPAND();
HARBOUR HB_GT_STRLEFT();
HARBOUR HB_GT_STRPBRK();
HARBOUR HB_GT_STRRIGHT();
HARBOUR HB_HB_FEOF();
HARBOUR HB_HB_FGOBOTTOM();
HARBOUR HB_HB_FGOTO();
HARBOUR HB_HB_FGOTOP();
HARBOUR HB_HB_FLASTREC();
HARBOUR HB_HB_FREADLN();
HARBOUR HB_HB_FRECNO();
HARBOUR HB_HB_FSKIP();
HARBOUR HB_HB_FUSE();
HARBOUR HB_LOG10();
HARBOUR HB_PVALUE();
HARBOUR HB_ROT13();
HARBOUR HB_SIN();
HARBOUR HB_SINH();
HARBOUR HB_STRDUMP();
HARBOUR HB_STRTOKEN();
HARBOUR HB_TAN();
HARBOUR HB_TANH();
HARBOUR HB_TOCHAR();
HARBOUR HB_VALTYPE();
/* Same story.
All the function pointers of the internal functions
Including Runner itself, since the first symbol gets executed by Harbour ;-)
*/
static SYMBOL symbols[] = {
{ "HB_RUN", FS_PUBLIC, HB_HB_RUN , 0 },
{ "__AGLOBALSTACK", FS_PUBLIC, HB___AGLOBALSTACK, 0 },
{ "__APARAM", FS_PUBLIC, HB___APARAM , 0 },
{ "__ASTACK", FS_PUBLIC, HB___ASTACK , 0 },
{ "__ASTATIC", FS_PUBLIC, HB___ASTATIC , 0 },
{ "__GLOBALSTACKLEN", FS_PUBLIC, HB___GLOBALSTACKLEN, 0 },
{ "__STACKLEN", FS_PUBLIC, HB___STACKLEN , 0 },
{ "__STATIC", FS_PUBLIC, HB___STATIC , 0 },
{ "ACOS", FS_PUBLIC, HB_ACOS , 0 },
{ "ASIN", FS_PUBLIC, HB_ASIN , 0 },
{ "ATAN", FS_PUBLIC, HB_ATAN , 0 },
{ "COS", FS_PUBLIC, HB_COS , 0 },
{ "COSH", FS_PUBLIC, HB_COSH , 0 },
{ "DATETIME", FS_PUBLIC, HB_DATETIME , 0 },
{ "DEBUG", FS_PUBLIC, HB_DEBUG , 0 },
{ "DEFAULT", FS_PUBLIC, HB_DEFAULT , 0 },
{ "ERRORSYS", FS_PUBLIC, HB_ERRORSYS , 0 },
{ "ERRORNEW", FS_PUBLIC, HB_ERRORNEW , 0 },
{ "EVAL", FS_PUBLIC, HB_EVAL , 0 },
{ "GT_ASCIISUM", FS_PUBLIC, HB_GT_ASCIISUM , 0 },
{ "GT_ASCPOS", FS_PUBLIC, HB_GT_ASCPOS , 0 },
{ "GT_ATDIFF", FS_PUBLIC, HB_GT_ATDIFF , 0 },
{ "GT_CHAREVEN", FS_PUBLIC, HB_GT_CHAREVEN , 0 },
{ "GT_CHARODD", FS_PUBLIC, HB_GT_CHARODD , 0 },
{ "GT_CHARMIX", FS_PUBLIC, HB_GT_CHARMIX , 0 },
{ "GT_CHRCOUNT", FS_PUBLIC, HB_GT_CHRCOUNT , 0 },
{ "GT_CHRFIRST", FS_PUBLIC, HB_GT_CHRFIRST , 0 },
{ "GT_CHRTOTAL", FS_PUBLIC, HB_GT_CHRTOTAL , 0 },
{ "GT_STRCOUNT", FS_PUBLIC, HB_GT_STRCOUNT , 0 },
{ "GT_STRCSPN", FS_PUBLIC, HB_GT_STRCSPN , 0 },
{ "GT_STRDIFF", FS_PUBLIC, HB_GT_STRDIFF , 0 },
{ "GT_STREXPAND", FS_PUBLIC, HB_GT_STREXPAND , 0 },
{ "GT_STRLEFT", FS_PUBLIC, HB_GT_STRLEFT , 0 },
{ "GT_STRPBRK", FS_PUBLIC, HB_GT_STRPBRK , 0 },
{ "GT_STRRIGHT", FS_PUBLIC, HB_GT_STRRIGHT , 0 },
{ "HB_FEOF", FS_PUBLIC, HB_HB_FEOF , 0 },
{ "HB_FGOBOTTOM", FS_PUBLIC, HB_HB_FGOBOTTOM , 0 },
{ "HB_FGOTO", FS_PUBLIC, HB_HB_FGOTO , 0 },
{ "HB_FGOTOP", FS_PUBLIC, HB_HB_FGOTOP , 0 },
{ "HB_FLASTREC", FS_PUBLIC, HB_HB_FLASTREC , 0 },
{ "HB_FRECNO", FS_PUBLIC, HB_HB_FRECNO , 0 },
{ "HB_FREADLN", FS_PUBLIC, HB_HB_FREADLN , 0 },
{ "HB_FSKIP", FS_PUBLIC, HB_HB_FSKIP , 0 },
{ "HB_FUSE", FS_PUBLIC, HB_HB_FUSE , 0 },
{ "LOG10", FS_PUBLIC, HB_LOG10 , 0 },
{ "PVALUE", FS_PUBLIC, HB_PVALUE , 0 },
{ "ROT13", FS_PUBLIC, HB_ROT13 , 0 },
{ "SIN", FS_PUBLIC, HB_SIN , 0 },
{ "SINH", FS_PUBLIC, HB_SINH , 0 },
{ "STRDUMP", FS_PUBLIC, HB_STRDUMP , 0 },
{ "STRTOKEN", FS_PUBLIC, HB_STRTOKEN , 0 },
{ "TAN", FS_PUBLIC, HB_TAN , 0 },
{ "TANH", FS_PUBLIC, HB_TANH , 0 },
{ "TOCHAR", FS_PUBLIC, HB_TOCHAR , 0 },
{ "VALTYPE", FS_PUBLIC, HB_VALTYPE , 0 }
};

451
harbour/tests/working/runner.c
View File

@@ -1,451 +0,0 @@
/*
* Runner - Dynamic object load routine
*
* Copyright (C) 1999 Eddie Runia (eddie@runia.com)
* Part of the Harbour Project 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 of the License, or
* (at your option) any later version, with one exception:
*
* The exception is that if you link the Harbour Runtime Library (HRL)
* and/or the Harbour Virtual Machine (HVM) 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 HRL
* and/or HVM code into it.
*
* 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 program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit
* their web site at http://www.gnu.org/).
*/
#include <errorapi.h>
#include <stdio.h>
/* #if INTEL32 */
static BYTE prgFunction[] = { 0x68, 0x00, 0x00, 0x00, 0x00,
0x68, 0x00, 0x00, 0x00, 0x00,
0xE8, 0x00, 0x00, 0x00, 0x00,
0x83, 0xC4, 0x08,
0xC3 };
/* push offset pcode
push offset symbols
call near relative VirtualMachine
add esp, 8
ret near */
/* This is the assembler output from : VirtualMachine(pcode,symbols). */
/* #elseif INTEL16 */
/* #elseif MOTOROLA */
/* #elseif ... */
/* #endif */
typedef union
{
PBYTE pAsmData; /* The assembler bytes */
HARBOURFUNC pFunPtr; /* The (dynamic) harbour
function */
} ASM_CALL, *PASM_CALL;
typedef struct
{
char *szName; /* Name of the function */
PASM_CALL pAsmCall; /* Assembler call */
PBYTE pCode; /* P-code */
} DYNFUNC, *PDYNFUNC;
#define SYM_NOLINK 0 /* Symbol does not have to
be linked */
#define SYM_FUNC 1 /* Defined function */
#define SYM_EXTERN 2 /* Prev. defined function */
#define SYM_NOT_FOUND 0xFFFFFFFF /* Symbol not found.
FindSymbol */
static PASM_CALL CreateFun( PSYMBOL, PBYTE ); /* Create a dynamic function*/
void Do( WORD );
static ULONG FindSymbol( char *, PDYNFUNC, ULONG );
HARBOUR HB_HB_RUN();
static void HRB_FileClose( FILE * );
static void HRB_FileRead ( char *, int, int, FILE * );
static FILE *HRB_FileOpen ( char * );
void Push( PHB_ITEM );
void PushNil( void );
void PushSymbol( PSYMBOL );
BYTE ReadByte( FILE * );
char *ReadId ( FILE * );
long ReadLong( FILE * );
#include "run_exp.h"
/*
*
* This file contains the exportable functions available to the Harbour program
*
* Currently being discussed in 'Static initializers'
*
* If the discussion has finished, it can be removed from here.
*
*/
#include <init.h>
ULONG ulSymEntry = 0; /* Link enhancement */
/*
HB_Run( <cFile> )
This program will get the data from the .HRB file and run the p-code
contained in it.
In due time it should also be able to collect the data from the
binary/executable itself
*/
HARBOUR HB_HB_RUN( void )
{
char *szFileName;
FILE *file;
ULONG ulSymbols; /* Number of symbols */
ULONG ulFuncs; /* Number of functions */
ULONG ulSize; /* Size of function */
ULONG ul, ulPos;
int i;
PSYMBOL pSymRead; /* Symbols read */
PDYNFUNC pDynFunc; /* Functions read */
PDYNSYM pDynSym;
if( hb_pcount() == 0 )
printf( "\nPlease give HRB file name\n" );
else
{
szFileName = hb_parc( 1 );
file = HRB_FileOpen( szFileName ); /* Open as binary */
if( file )
{
ulSymbols = ReadLong( file );
pSymRead = ( PSYMBOL )hb_xgrab( ulSymbols * sizeof( SYMBOL ) );
for( ul=0; ul < ulSymbols; ul++) /* Read symbols in .HRB */
{
pSymRead[ ul ].szName = ReadId( file );
pSymRead[ ul ].cScope = ReadByte( file );
pSymRead[ ul ].pFunPtr = ( HARBOURFUNC ) ReadByte( file );
pSymRead[ ul ].pDynSym = NULL;
}
ulFuncs = ReadLong( file ); /* Read number of functions */
pDynFunc = ( PDYNFUNC ) hb_xgrab( ulFuncs * sizeof( DYNFUNC ) );
for( ul=0; ul < ulFuncs; ul++) /* Read symbols in .HRB */
{
pDynFunc[ ul ].szName = ReadId( file );
ulSize = ReadLong( file ) + 1; /* Read size of function */
pDynFunc[ ul ].pCode = ( PBYTE )hb_xgrab( ulSize );
HRB_FileRead( pDynFunc[ ul ].pCode, 1, ulSize, file );
/* Read the block */
pDynFunc[ ul ].pAsmCall = CreateFun( pSymRead,
pDynFunc[ ul ].pCode );
/* Create matching dynamic */
/* function */
}
ulSymEntry = 0;
for( ul = 0; ul < ulSymbols; ul++ ) /* Linker */
{
if( ( (ULONG) pSymRead[ ul ].pFunPtr ) == SYM_FUNC )
{
ulPos = FindSymbol( pSymRead[ ul ].szName, pDynFunc, ulFuncs );
if( ulPos != SYM_NOT_FOUND )
{
/* if( FindDynSym( pSymRead[ ul ].szName ) &&
!( pSymRead[ ul ].cScope & FS_STATIC ) )
{ */ /* Exists and NOT static ? */
/* printf( "\nDuplicate identifier '%s' %i.",
pSymRead[ ul ].szName, pSymRead[ul].cScope );
exit( 1 );
} */
pSymRead[ ul ].pFunPtr = pDynFunc[ ulPos ].pAsmCall->pFunPtr;
}
else
pSymRead[ ul ].pFunPtr = ( HARBOURFUNC ) SYM_EXTERN;
}
if( ( (ULONG) pSymRead[ ul ].pFunPtr ) == SYM_EXTERN )
{ /* External function */
pDynSym = FindDynSym( pSymRead[ ul ].szName );
if( !pDynSym )
{
printf( "\nUnknown or unregistered function '%s'.",
pSymRead[ ul ].szName );
exit( 1 );
}
pSymRead[ ul ].pFunPtr = pDynSym->pFunPtr;
}
}
ProcessSymbols( pSymRead, ulSymbols );
for( ul = 0; ul < ulSymbols; ul++ ) /* Check INIT functions */
{
if( pSymRead[ ul ].cScope & FS_INIT )
{
PushSymbol( pSymRead + ul );
PushNil();
for( i = 0; i < (hb_pcount() - 1); i++ )
Push( hb_param( i + 2, IT_ANY ) );
/* Push other cmdline params*/
Do( hb_pcount() - 1 ); /* Run init function */
}
}
PushSymbol( pSymRead );
PushNil();
for( i = 0; i < (hb_pcount() - 1); i++ )
Push( hb_param( i + 2, IT_ANY ) ); /* Push other cmdline params*/
Do( hb_pcount() - 1 ); /* Run the thing !!! */
for( ul = 0; ul < ulSymbols; ul++ ) /* Check EXIT functions */
{
if( pSymRead[ ul ].cScope & FS_EXIT )
{
PushSymbol( pSymRead + ul );
PushNil();
Do( 0 ); /* Run exit function */
pSymRead[ ul ].cScope = pSymRead[ ul ].cScope & (~FS_EXIT);
/* Exit function cannot be
handled by main in hvm.c */
}
}
for( ul = 0; ul < ulFuncs; ul++ )
{
hb_xfree( pDynFunc[ ul ].pAsmCall->pAsmData );
hb_xfree( pDynFunc[ ul ].pAsmCall );
hb_xfree( pDynFunc[ ul ].pCode );
hb_xfree( pDynFunc[ ul ].szName );
}
for( ul = 0; ul < ulSymbols; ul++ )
{
hb_xfree( pSymRead[ ul ].szName );
}
hb_xfree( pDynFunc );
hb_xfree( pSymRead );
HRB_FileClose( file );
}
else
{
printf( "\nCannot open %s\n", szFileName );
}
}
}
static ULONG FindSymbol( char *szName, PDYNFUNC pDynFunc, ULONG ulLoaded )
{
ULONG ulRet;
BYTE bFound;
if( ( ulSymEntry < ulLoaded ) && /* Is it a normal list ? */
!strcmp( szName, pDynFunc[ ulSymEntry ].szName ) )
ulRet = ulSymEntry++;
else
{
bFound = FALSE;
ulRet = 0;
while( !bFound && ulRet < ulLoaded )
{
if( !strcmp( szName, pDynFunc[ ulRet ].szName ) )
bFound = TRUE;
else
ulRet++;
}
if( !bFound )
ulRet = SYM_NOT_FOUND;
}
return( ulRet );
}
/* ReadId
Read the next (zero terminated) identifier */
char *ReadId( FILE *file )
{
char *szTemp; /* Temporary buffer */
char *szIdx;
char *szRet;
BYTE bCont = TRUE;
szTemp = ( char * )hb_xgrab( 256 );
szIdx = szTemp;
do
{
HRB_FileRead( szIdx, 1, 1, file );
if( *szIdx )
szIdx++;
else
bCont = FALSE;
} while( bCont );
szRet = (char *) hb_xgrab( szIdx - szTemp + 1 );
strcpy( szRet, szTemp );
hb_xfree( szTemp );
return( szRet );
}
BYTE ReadByte( FILE *file )
{
BYTE bRet;
HRB_FileRead( &bRet, 1, 1, file );
return( bRet );
}
long ReadLong( FILE *file )
{
char cLong[4]; /* Temporary long */
HRB_FileRead( cLong, 4, 1, file );
if( cLong[3] ) /* Convert to long if ok */
{
PHB_ITEM pError = hb_errNew();
hb_errPutDescription(pError, "Error reading .HRB file");
hb_errLaunch(pError);
hb_errRelease(pError);
return( NULL );
}
else
return( ( (BYTE) cLong[0] ) +
( (BYTE) cLong[1] ) * 0x100 +
( (BYTE) cLong[2] ) * 0x10000 +
( (BYTE) cLong[3] ) * 0x1000000 );
}
/* HRB_FileRead
Controlled read from file. If errornous -> Break */
static void HRB_FileRead( char *cBuffer, int iSize, int iCount, FILE *fStream )
{
if( iCount != (int) fread( cBuffer, iSize, iCount, fStream ) )
{ /* Read error */
PHB_ITEM pError = hb_errNew();
hb_errPutDescription(pError, "Error reading .HRB file");
hb_errLaunch(pError);
hb_errRelease(pError);
exit(1);
}
}
/* HRB_FileOpen
Open an .HRB file */
static FILE *HRB_FileOpen( char *szFileName )
{
return( fopen( szFileName, "rb" ) );
}
/* HRB_FileClose
Close an .HRB file */
static void HRB_FileClose( FILE *file )
{
fclose( file );
}
/* Patch an address of the dynamic function */
static void Patch( PBYTE pCode, ULONG ulOffset, void *Address )
{
/* #if 32 bits and low byte first */
pCode[ ulOffset ] = ( (ULONG) Address ) & 0xFF;
pCode[ ulOffset + 1 ] = ( (ULONG) Address >> 8 ) & 0xFF;
pCode[ ulOffset + 2 ] = ( (ULONG) Address >> 16 ) & 0xFF;
pCode[ ulOffset + 3 ] = ( (ULONG) Address >> 24 ) & 0xFF;
/* #elseif 16 bits and low byte first */
/* #elseif 32 bits and high byte first */
/* #elseif ... */
/* #endif */
}
/* Intel specific ?? Patch an address relative to the next instruction */
static void PatchRelative( PBYTE pCode, ULONG ulOffset,
void *Address, ULONG ulNext )
{
/* #if 32 bits and low byte first */
ULONG ulBase = (ULONG) pCode + ulNext;
/* Relative to next instruction */
ULONG ulRelative = (ULONG) Address - ulBase;
pCode[ ulOffset ] = ( ulRelative ) & 0xFF;
pCode[ ulOffset + 1 ] = ( ulRelative >> 8 ) & 0xFF;
pCode[ ulOffset + 2 ] = ( ulRelative >> 16 ) & 0xFF;
pCode[ ulOffset + 3 ] = ( ulRelative >> 24 ) & 0xFF;
/* #elseif 16 bits and low byte first */
/* #elseif 32 bits and high byte first */
/* #elseif ... */
/* #endif */
}
/*
Create dynamic function.
This function is needed, since it will allow the existing strategy of
function pointers to work properly.
For each Harbour function a little program calling the virtual machine
should be present (see : *.c)
Since these programs no longer exists when using this system, they should
be create dynamically at run-time.
If a .PRG contains 10 functions, 10 dynamic functions are created which
are all the same :-) except for 2 pointers.
*/
static PASM_CALL CreateFun( PSYMBOL pSymbols, PBYTE pCode )
{
PASM_CALL asmRet = (PASM_CALL) hb_xgrab( sizeof( ASM_CALL ) );
asmRet->pAsmData = (PBYTE) hb_xgrab( sizeof( prgFunction ) );
memcpy( asmRet->pAsmData, prgFunction, sizeof( prgFunction ) );
/* Copy new assembler code in */
/* #if INTEL32 */
Patch( asmRet->pAsmData, 1, pSymbols ); /* Insert pointer to testsym */
Patch( asmRet->pAsmData, 6, pCode); /* Insert pointer to testcode */
PatchRelative( asmRet->pAsmData, 11, &VirtualMachine, 15 );
/* Insert pointer to VirtualMachine() */
/* #elseif INTEL16 */
/* #elseif MOTOROLA */
/* #elseif ... */
/* #endif */
return( asmRet );
}

3
harbour/tests/working/runrdos.bat
View File

@@ -1,4 +1,5 @@
rem runner.c -> runner.exe using gcc (djgpp)
make -r -fmakerunr.dos runner
make -r -fmakerunr.dos ../../source/runner/runner
move ..\..\source\runner\runner.exe .