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

See ChangeLog entry 19990616-22:50 EDT David G. Holm <dholm@jsd-llc.com>

Browse Source
This commit is contained in:
David G. Holm
1999-06-17 03:57:19 +00:00
parent 28fa2ea3e0
commit 887ef3cdc6
10 changed files with 188 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
harbour/ChangeLog
View File

@@ -1,3 +1,24 @@
19990616-22:50 EDT David G. Holm <dholm@jsd-llc.com>
* source/hbpp/hbppint.c
- Added ParseDefine( "__HARBOUR__" ) to Hbpp_init()
* source/rtl/arrays.c
- Added missing symbols to symbol table
* source/rtl/console.c
- Added missing symbols to symbol table
* source/rtl/dates.c
- Added symbol table
* source/rtl/math.c
- Added HARBOUR HB_ROUND() function
* source/rtl/strings.c
- Added missing symbols to symbol table
* source/rtl/transfrm.c
- Added symbol table
* source/vm/initsymb.c
- Added calls to Dates__InitSymbols() and Transfrm__InitSymbols()
+ tests/working/round.prg
- New function to test ROUND() function uses OUTSTD() to allow
easy checking of Harbour results against Clipper results
19990616-21:40 CET Eddie Runia
* tests/working/dosshell.prg
new version added

3
harbour/source/hbpp/hbppint.c
View File

@@ -17,6 +17,7 @@
#include <stdio.h>
#include "harb.h"
extern int ParseDefine( char* );
extern int ParseDirective( char* );
extern int ParseExpression( char*, char* );
extern int RdStr(FILE*,char *,int,int,char*,int*,int*);
@@ -52,6 +53,8 @@ void Hbpp_init ( void )
aDefnew = ( DEFINES * ) _xgrab( sizeof(DEFINES) * 50 );
aCommnew = ( COMMANDS * ) _xgrab( sizeof(COMMANDS) * INITIAL_ACOM_SIZE );
aTranslates = ( TRANSLATES * ) _xgrab( sizeof(TRANSLATES) * 50 );
ParseDefine( "__HARBOUR__" );
}
int PreProcess( FILE* handl_i, FILE* handl_o, char *sOut )

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

@@ -6,6 +6,7 @@
#include <extend.h>
#include <ctoharb.h>
HARBOUR HB_AADD(void);
HARBOUR HB_ACLONE(void);
HARBOUR HB_ACOPY(void);
HARBOUR HB_ADEL(void);
@@ -19,6 +20,7 @@ HARBOUR HB_ASORT(void);
HARBOUR HB_ATAIL(void);
static SYMBOL symbols[] = {
{ "AADD", FS_PUBLIC, HB_AADD , 0 },
{ "ACLONE", FS_PUBLIC, HB_ACLONE , 0 },
{ "ACOPY", FS_PUBLIC, HB_ACOPY , 0 },
{ "ADEL", FS_PUBLIC, HB_ADEL , 0 },

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

@@ -19,6 +19,7 @@
#endif
HARBOUR HB___ACCEPT(void);
HARBOUR HB_COL( void );
HARBOUR HB_DEVOUT( void );
HARBOUR HB_DEVPOS( void );
HARBOUR HB___EJECT( void );
@@ -28,6 +29,7 @@ HARBOUR HB_OUTSTD( void );
HARBOUR HB_OUTERR( void );
HARBOUR HB_PCOL( void );
HARBOUR HB_PROW( void );
HARBOUR HB_ROW( void );
HARBOUR HB_SCROLL( void );
HARBOUR HB_SETPOS( void );
HARBOUR HB_SETPRC( void );
@@ -37,6 +39,7 @@ HARBOUR HB_QQOUT( void );
static SYMBOL symbols[] = {
{ "__ACCEPT", FS_PUBLIC, HB___ACCEPT, 0 },
{ "__EJECT" , FS_PUBLIC, HB___EJECT , 0 },
{ "COL" , FS_PUBLIC, HB_COL , 0 },
{ "DEVOUT" , FS_PUBLIC, HB_DEVOUT , 0 },
{ "DEVPOS" , FS_PUBLIC, HB_DEVPOS , 0 },
{ "MAXCOL" , FS_PUBLIC, HB_MAXCOL , 0 },
@@ -45,6 +48,7 @@ static SYMBOL symbols[] = {
{ "OUTSTD" , FS_PUBLIC, HB_OUTSTD , 0 },
{ "PCOL" , FS_PUBLIC, HB_PCOL , 0 },
{ "PROW" , FS_PUBLIC, HB_PROW , 0 },
{ "ROW" , FS_PUBLIC, HB_ROW , 0 },
{ "SCROLL" , FS_PUBLIC, HB_SCROLL , 0 },
{ "SETPOS" , FS_PUBLIC, HB_SETPOS , 0 },
{ "SETPRC" , FS_PUBLIC, HB_SETPRC , 0 },

35
harbour/source/rtl/dates.c
View File

@@ -20,6 +20,41 @@ extern STACK stack;
extern char *hb_monthsname[];
extern char *hb_daysname[];
HARBOUR HB_CDOW( void );
HARBOUR HB_CMONTH( void );
HARBOUR HB_CTOD( void );
HARBOUR HB_DATE( void );
HARBOUR HB_DAY( void );
HARBOUR HB_DOW( void );
HARBOUR HB_DTOC( void );
HARBOUR HB_DTOS( void );
HARBOUR HB_MONTH( void );
HARBOUR HB_SECONDS( void );
HARBOUR HB_STOD( void );
HARBOUR HB_TIME( void );
HARBOUR HB_YEAR( void );
static SYMBOL symbols[] = {
{ "HB_CDOW", FS_PUBLIC, HB_CDOW, 0 },
{ "HB_CMONTH", FS_PUBLIC, HB_CMONTH, 0 },
{ "HB_CTOD", FS_PUBLIC, HB_CTOD, 0 },
{ "HB_DATE", FS_PUBLIC, HB_DATE, 0 },
{ "HB_DAY", FS_PUBLIC, HB_DAY, 0 },
{ "HB_DOW", FS_PUBLIC, HB_DOW, 0 },
{ "HB_DTOC", FS_PUBLIC, HB_DTOC, 0 },
{ "HB_DTOS", FS_PUBLIC, HB_DTOS, 0 },
{ "HB_MONTH", FS_PUBLIC, HB_MONTH, 0 },
{ "HB_SECONDS", FS_PUBLIC, HB_SECONDS, 0 },
{ "HB_STOD", FS_PUBLIC, HB_STOD, 0 },
{ "HB_TIME", FS_PUBLIC, HB_TIME, 0 },
{ "HB_YEAR", FS_PUBLIC, HB_YEAR, 0 }
};
void Dates__InitSymbols( void )
{
ProcessSymbols( symbols, sizeof(symbols)/sizeof( SYMBOL ) );
}
double hb__seconds( void )
{
#if defined(__TURBOC__) || defined(__BORLANDC__) || defined(__DJGPP__)

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

@@ -14,6 +14,7 @@ HARBOUR HB_LOG( void );
HARBOUR HB_MAX( void );
HARBOUR HB_MIN( void );
HARBOUR HB_MOD( void );
HARBOUR HB_ROUND( void );
HARBOUR HB_SQRT( void );
static SYMBOL symbols[] = {
@@ -24,6 +25,7 @@ static SYMBOL symbols[] = {
{ "MAX" , FS_PUBLIC, HB_MAX , 0 },
{ "MIN" , FS_PUBLIC, HB_MIN , 0 },
{ "MOD" , FS_PUBLIC, HB_MOD , 0 },
{ "ROUND", FS_PUBLIC, HB_ROUND, 0 },
{ "SQRT" , FS_PUBLIC, HB_SQRT , 0 }
};
@@ -282,6 +284,51 @@ FUNCTION MOD(cl_num, cl_base)
}
}
HARBOUR HB_ROUND( void )
{
if( _pcount() == 2 )
{
if( _param(1, IT_NUMERIC) && _param( 2, IT_NUMERIC ) )
{
int iSize = 64, iDec = _parni( 2 );
char * szResult;
double dResult = _parnd( 1 );
if( iDec < 1 ) iDec = 0;
else if( dResult != 0.0 )
{
double dAdjust = pow( 10, iDec );
dResult = floor( dResult * dAdjust + 0.5 );
dResult = dResult / dAdjust;
}
szResult = _xgrab( iSize + iDec );
if( szResult )
{
sprintf( szResult, "%*.*f", iSize, iDec, dResult );
dResult = atof( szResult );
_xfree( szResult );
}
_retnd( dResult );
stack.Return.wDec = iDec;
}
else
{
PHB_ITEM pError = _errNew();
_errPutDescription(pError, "Argument error: ROUND");
_errLaunch(pError);
_errRelease(pError);
}
}
else
{
/* QUESTION: Clipper catches this at compile time! */
PHB_ITEM pError = _errNew();
_errPutDescription(pError, "Incorrect number of arguments: INT");
_errLaunch(pError);
_errRelease(pError);
}
}
HARBOUR HB_SQRT( void )
{
if( _pcount() == 1 )

53
harbour/source/rtl/strings.c
View File

@@ -11,35 +11,60 @@ extern STACK stack;
#define HB_ISSPACE(c) ((c) == 9 || (c) == 10 || (c) == 13 || (c) == 32)
HARBOUR HB_ALLTRIM( void );
HARBOUR HB_ASC( void );
HARBOUR HB_AT( void );
HARBOUR HB_CHR( void );
HARBOUR HB_ISALPHA( void );
HARBOUR HB_ISDIGIT( void );
HARBOUR HB_ISUPPER( void );
HARBOUR HB_ISLOWER( void );
HARBOUR HB_LEFT( void );
HARBOUR HB_LOWER( void );
HARBOUR HB_LTRIM( void );
HARBOUR HB_PAD( void );
HARBOUR HB_PADC( void );
HARBOUR HB_PADL( void );
HARBOUR HB_PADR( void );
HARBOUR HB_RAT( void );
HARBOUR HB_REPLICATE( void );
HARBOUR HB_RIGHT( void );
HARBOUR HB_RTRIM( void );
HARBOUR HB_SPACE( void );
HARBOUR HB_STR( void );
HARBOUR HB_STRTRAN( void );
HARBOUR HB_STUFF( void );
HARBOUR HB_SUBSTR( void );
HARBOUR HB_TRIM( void );
HARBOUR HB_UPPER( void );
HARBOUR HB_VAL( void );
static SYMBOL symbols[] = {
{ "ALLTRIM", FS_PUBLIC, HB_ALLTRIM, 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 },
{ "PAD" , FS_PUBLIC, HB_PAD , 0 },
{ "PADC" , FS_PUBLIC, HB_PADC , 0 },
{ "PADL" , FS_PUBLIC, HB_PADL , 0 },
{ "PADR" , FS_PUBLIC, HB_PADR , 0 },
{ "RAT" , FS_PUBLIC, HB_RAT , 0 },
{ "RIGHT" , FS_PUBLIC, HB_RIGHT , 0 },
{ "STRTRAN", FS_PUBLIC, HB_STRTRAN, 0 },
{ "STUFF" , FS_PUBLIC, HB_STUFF , 0 },
{ "TRIM" , FS_PUBLIC, HB_TRIM , 0 }
{ "ALLTRIM" , FS_PUBLIC, HB_ALLTRIM, 0 },
{ "HB_ASC" , FS_PUBLIC, HB_ASC , 0 },
{ "HB_AT" , FS_PUBLIC, HB_AT , 0 },
{ "HB_CHR" , FS_PUBLIC, HB_CHR , 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 },
{ "HB_LEFT" , FS_PUBLIC, HB_LEFT , 0 },
{ "HB_LOWER" , FS_PUBLIC, HB_LOWER , 0 },
{ "HB_LTRIM" , FS_PUBLIC, HB_LTRIM , 0 },
{ "PAD" , FS_PUBLIC, HB_PAD , 0 },
{ "PADC" , FS_PUBLIC, HB_PADC , 0 },
{ "PADL" , FS_PUBLIC, HB_PADL , 0 },
{ "PADR" , FS_PUBLIC, HB_PADR , 0 },
{ "RAT" , FS_PUBLIC, HB_RAT , 0 },
{ "HB_REPLICATE" , FS_PUBLIC, HB_REPLICATE , 0 },
{ "RIGHT" , FS_PUBLIC, HB_RIGHT , 0 },
{ "HB_RTRIM" , FS_PUBLIC, HB_RTRIM , 0 },
{ "STR" , FS_PUBLIC, HB_STR , 0 },
{ "STRTRAN" , FS_PUBLIC, HB_STRTRAN, 0 },
{ "STUFF" , FS_PUBLIC, HB_STUFF , 0 },
{ "HB_SUBSTR" , FS_PUBLIC, HB_SUBSTR , 0 },
{ "TRIM" , FS_PUBLIC, HB_TRIM , 0 },
{ "HB_UPPER" , FS_PUBLIC, HB_UPPER , 0 },
{ "HB_VAL" , FS_PUBLIC, HB_VAL , 0 }
};
void Strings__InitSymbols( void )

11
harbour/source/rtl/transfrm.c
View File

@@ -13,6 +13,17 @@
/* Date : 29/04/1999 */
/* */
HARBOUR HB_TRANSFORM( void );
static SYMBOL symbols[] = {
{ "HB_TRANSFORM" , FS_PUBLIC, HB_TRANSFORM , 0 }
};
void Transfrm__InitSymbols( void )
{
ProcessSymbols( symbols, sizeof(symbols)/sizeof( SYMBOL ) );
}
extern STACK stack;
void StackPop( void ); /* TOFIX: Should go away */

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

@@ -10,6 +10,7 @@
extern void Arrays__InitSymbols( void );
extern void Classes__InitSymbols( void );
extern void Console__InitSymbols( void );
extern void Dates__InitSymbols( void );
extern void Descend__InitSymbols( void );
extern void Dir__InitSymbols( void );
extern void Environ__InitSymbols( void );
@@ -19,6 +20,7 @@ extern void Math__InitSymbols( void );
extern void Memotran__InitSymbols( void );
extern void Set__InitSymbols( void );
extern void Strings__InitSymbols( void );
extern void Transfrm__InitSymbols( void );
void ProcessSymbols( SYMBOL *, WORD );
@@ -144,6 +146,7 @@ void InitSymbolTable( void )
Arrays__InitSymbols();
Classes__InitSymbols();
Console__InitSymbols();
Dates__InitSymbols();
Descend__InitSymbols();
Dir__InitSymbols();
Environ__InitSymbols();
@@ -153,6 +156,7 @@ void InitSymbolTable( void )
Memotran__InitSymbols();
Set__InitSymbols();
Strings__InitSymbols();
Transfrm__InitSymbols();
/*
* The system symbol table with runtime functions HAVE TO be called last

22
harbour/tests/working/round.prg Normal file
View File

@@ -0,0 +1,22 @@
// Testing Harbour rounding.
#ifdef __HARBOUR__
#define NewLine CHR(10)
#else
#define NewLine CHR(13)+CHR(10)
#endif
function main()
local n, value := -5
for n := 1 to 10000
OUTSTD(NewLine)
OUTSTD(value)
OUTSTD(round(value, 3))
OUTSTD(round(value, 2))
OUTSTD(round(value, 1))
OUTSTD(round(value, 0))
value += 0.001
next
return nil