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

2011-02-28 21:42 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

Browse Source 
* harbour/include/hbpp.h
  * harbour/include/hbapilng.h
  * harbour/include/hbapi.h
  * harbour/include/hbcomp.h
  * harbour/src/pp/pplib.c
  * harbour/src/pp/ppcore.c
  * harbour/src/common/hbstr.c
  * harbour/src/rtl/sha2.c
  * harbour/src/rtl/hbinet.c
  * harbour/src/compiler/ppcomp.c
  * harbour/src/compiler/hbfunchk.c
  * harbour/src/compiler/hbgenerr.c
  * harbour/contrib/hbtip/utils.c
    % added missing const to some variable declarations so they can be
      stored in readonly segments

  * harbour/doc/xhb-diff.txt
    ! fixed few typos
This commit is contained in:
Przemyslaw Czerpak
2011-02-28 20:43:05 +00:00
parent 0d92423b1c
commit f9823284df
15 changed files with 81 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
harbour/ChangeLog
View File

@@ -16,6 +16,26 @@
The license applies to all entries newer than 2009-04-28.
*/
2011-02-28 21:42 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/include/hbpp.h
* harbour/include/hbapilng.h
* harbour/include/hbapi.h
* harbour/include/hbcomp.h
* harbour/src/pp/pplib.c
* harbour/src/pp/ppcore.c
* harbour/src/common/hbstr.c
* harbour/src/rtl/sha2.c
* harbour/src/rtl/hbinet.c
* harbour/src/compiler/ppcomp.c
* harbour/src/compiler/hbfunchk.c
* harbour/src/compiler/hbgenerr.c
* harbour/contrib/hbtip/utils.c
% added missing const to some variable declarations so they can be
stored in readonly segments
* harbour/doc/xhb-diff.txt
! fixed few typos
2011-02-28 21:07 UTC+0100 Viktor Szakats (harbour.01 syenar.hu)
* include/hbgtinfo.ch
* src/rtl/hbgtcore.c

6
harbour/contrib/hbtip/utils.c
View File

@@ -130,7 +130,7 @@ typedef struct tag_mime
#define MIME_FLAG_CONTINUE 0x0008
#define MIME_TABLE_SIZE 71
static MIME_ENTRY s_mimeTable[ MIME_TABLE_SIZE ] =
static const MIME_ENTRY s_mimeTable[ MIME_TABLE_SIZE ] =
{
/* Dos/win executable */
/* 0*/ { 0, "MZ", "application/x-dosexec", 0, 0, 0 },
@@ -348,7 +348,7 @@ static const char * s_findExtMimeType( const char * cExt )
static const char * s_findMimeStringInTree( const char * cData, HB_ISIZ nLen, int iElem )
{
MIME_ENTRY * elem = s_mimeTable + iElem;
const MIME_ENTRY * elem = s_mimeTable + iElem;
HB_ISIZ nPos = elem->pos;
HB_ISIZ nDataLen = strlen( elem->pattern );
@@ -403,7 +403,7 @@ static const char * s_findStringMimeType( const char * cData, HB_ISIZ nLen )
for( iCount = 0; iCount < MIME_TABLE_SIZE; iCount++ )
{
MIME_ENTRY * elem = s_mimeTable + iCount;
const MIME_ENTRY * elem = s_mimeTable + iCount;
HB_ISIZ nPos = elem->pos;
HB_ISIZ nDataLen = strlen( elem->pattern );

8
harbour/doc/xhb-diff.txt
View File

@@ -1159,7 +1159,7 @@ not support strings with embedded 0 so they are not fully functional here.
### SYMBOL ITEMS AND FUNCTION REFERENCES ###
==================================================
Harbour support SYMBOL items ( VALTYPE(funcSym) == "S" ) which can be used
Harbour supports SYMBOL items ( VALTYPE(funcSym) == "S" ) which can be used
as function or message references. They have similar functionality to
SYMBOL objects in Class(y) and understands NAME, EXEC and EVAL messages.
They can be created literally by compiler using @<funcName>(), f.e:
@@ -1285,7 +1285,7 @@ xHarbour and Class(y) gives wrong results:
[var] [var3] [var3] [var3]
Please note that Harbour does not make any tricks with compile time static
bindings. It's uses only dynamic bindings and resolves all problems with
bindings. It uses only dynamic bindings and resolves all problems with
instance area super casting.
Correct instance area super casting is very important functionality when
@@ -1298,13 +1298,13 @@ important thing.
### OOP AND PRIVATE/HIDDEN DATAs ###
==========================================
In bigger projects where different programmers works on different classes
In bigger projects where different programmers work on different classes
which are later used as ancestors of some new classes it's extremely important
to give support for real private (hidden) data for each class programmer
which will not cause problems if name conflicts appears. Otherwise
each method and instance variable name used by each programmer has to be
agreed with project manager to eliminate possible name conflicts. In really
big projects such name conflicts can be nightmare which eliminates some
big projects such name conflicts can be nightmare a which eliminates some
languages.
Harbour resolves this problem automatically. All hidden variables and

2
harbour/include/hbapi.h
View File

@@ -916,7 +916,7 @@ extern HB_EXPORT HB_BOOL hb_hashDelAt( PHB_ITEM pHash, HB_SIZE nPos );
/* string management */
extern const char * hb_szAscii[ 256 ]; /* array of 1 character length strings */
extern const char * const hb_szAscii[ 256 ]; /* array of 1 character length strings */
extern HB_EXPORT int hb_stricmp( const char * s1, const char * s2 ); /* compare two strings without regards to case */
extern HB_EXPORT int hb_strnicmp( const char * s1, const char * s2, HB_SIZE nLen ); /* compare two string without regards to case, limited by length */

4
harbour/include/hbapilng.h
View File

@@ -74,10 +74,10 @@ HB_EXTERN_BEGIN
#define HB_LANG_ANNOUNCE( id ) HB_LANG_ANNOUNCE_( id )
#define HB_LANG_ANNOUNCE_( id ) HB_FUNC( HB_LANG_##id ) {}
typedef struct _HB_LANG
typedef const struct _HB_LANG
{
const void * pItemList[ HB_LANG_ITEM_MAX_ ];
} HB_LANG, * PHB_LANG, * HB_LANG_PTR;
} HB_LANG, * PHB_LANG;
extern HB_EXPORT PHB_LANG hb_vmLang( void );
extern HB_EXPORT void hb_vmSetLang( PHB_LANG pLang );

8
harbour/include/hbcomp.h
View File

@@ -176,8 +176,8 @@ extern void hb_compSwitchKill( HB_COMP_DECL, PFUNCTION );
extern void hb_compElseIfKill( PFUNCTION );
extern void hb_compLoopKill( PFUNCTION );
extern void hb_compGenError( HB_COMP_DECL, const char * szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 ); /* generic parsing error management function */
extern void hb_compGenWarning( HB_COMP_DECL, const char * szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2); /* generic parsing warning management function */
extern void hb_compGenError( HB_COMP_DECL, const char * const szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 ); /* generic parsing error management function */
extern void hb_compGenWarning( HB_COMP_DECL, const char * const szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2); /* generic parsing warning management function */
extern HB_SIZE hb_compGenJump( HB_ISIZ nOffset, HB_COMP_DECL ); /* generates the pcode to jump to a specific offset */
extern HB_SIZE hb_compGenJumpFalse( HB_ISIZ nOffset, HB_COMP_DECL ); /* generates the pcode to jump if false */
@@ -350,8 +350,8 @@ extern void hb_compI18nAddPlural( HB_COMP_DECL, const char ** szTexts, HB_ULONG
/* global readonly variables used by compiler
*/
extern const char * hb_comp_szErrors[];
extern const char * hb_comp_szWarnings[];
extern const char * const hb_comp_szErrors[];
extern const char * const hb_comp_szWarnings[];
/* table with PCODEs' length */
extern const HB_BYTE hb_comp_pcode_len[];

2
harbour/include/hbpp.h
View File

@@ -99,7 +99,7 @@ typedef HB_PP_CLOSE_FUNC_( HB_PP_CLOSE_FUNC );
typedef HB_PP_CLOSE_FUNC * PHB_PP_CLOSE_FUNC;
/* function to generate errors */
#define HB_PP_ERROR_FUNC_( func ) void func( void *, const char **, char, int, const char *, const char * )
#define HB_PP_ERROR_FUNC_( func ) void func( void *, const char * const *, char, int, const char *, const char * )
typedef HB_PP_ERROR_FUNC_( HB_PP_ERROR_FUNC );
typedef HB_PP_ERROR_FUNC * PHB_PP_ERROR_FUNC;

33
harbour/src/common/hbstr.c
View File

@@ -64,22 +64,23 @@
#include "hbapi.h"
#include "hbmath.h"
const char * hb_szAscii[ 256 ] = { "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08", "\x09", "\x0A", "\x0B", "\x0C", "\x0D", "\x0E", "\x0F",
"\x10", "\x11", "\x12", "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1A", "\x1B", "\x1C", "\x1D", "\x1E", "\x1F",
"\x20", "\x21", "\x22", "\x23", "\x24", "\x25", "\x26", "\x27", "\x28", "\x29", "\x2A", "\x2B", "\x2C", "\x2D", "\x2E", "\x2F",
"\x30", "\x31", "\x32", "\x33", "\x34", "\x35", "\x36", "\x37", "\x38", "\x39", "\x3A", "\x3B", "\x3C", "\x3D", "\x3E", "\x3F",
"\x40", "\x41", "\x42", "\x43", "\x44", "\x45", "\x46", "\x47", "\x48", "\x49", "\x4A", "\x4B", "\x4C", "\x4D", "\x4E", "\x4F",
"\x50", "\x51", "\x52", "\x53", "\x54", "\x55", "\x56", "\x57", "\x58", "\x59", "\x5A", "\x5B", "\x5C", "\x5D", "\x5E", "\x5F",
"\x60", "\x61", "\x62", "\x63", "\x64", "\x65", "\x66", "\x67", "\x68", "\x69", "\x6A", "\x6B", "\x6C", "\x6D", "\x6E", "\x6F",
"\x70", "\x71", "\x72", "\x73", "\x74", "\x75", "\x76", "\x77", "\x78", "\x79", "\x7A", "\x7B", "\x7C", "\x7D", "\x7E", "\x7F",
"\x80", "\x81", "\x82", "\x83", "\x84", "\x85", "\x86", "\x87", "\x88", "\x89", "\x8A", "\x8B", "\x8C", "\x8D", "\x8E", "\x8F",
"\x90", "\x91", "\x92", "\x93", "\x94", "\x95", "\x96", "\x97", "\x98", "\x99", "\x9A", "\x9B", "\x9C", "\x9D", "\x9E", "\x9F",
"\xA0", "\xA1", "\xA2", "\xA3", "\xA4", "\xA5", "\xA6", "\xA7", "\xA8", "\xA9", "\xAA", "\xAB", "\xAC", "\xAD", "\xAE", "\xAF",
"\xB0", "\xB1", "\xB2", "\xB3", "\xB4", "\xB5", "\xB6", "\xB7", "\xB8", "\xB9", "\xBA", "\xBB", "\xBC", "\xBD", "\xBE", "\xBF",
"\xC0", "\xC1", "\xC2", "\xC3", "\xC4", "\xC5", "\xC6", "\xC7", "\xC8", "\xC9", "\xCA", "\xCB", "\xCC", "\xCD", "\xCE", "\xCF",
"\xD0", "\xD1", "\xD2", "\xD3", "\xD4", "\xD5", "\xD6", "\xD7", "\xD8", "\xD9", "\xDA", "\xDB", "\xDC", "\xDD", "\xDE", "\xDF",
"\xE0", "\xE1", "\xE2", "\xE3", "\xE4", "\xE5", "\xE6", "\xE7", "\xE8", "\xE9", "\xEA", "\xEB", "\xEC", "\xED", "\xEE", "\xEF",
"\xF0", "\xF1", "\xF2", "\xF3", "\xF4", "\xF5", "\xF6", "\xF7", "\xF8", "\xF9", "\xFA", "\xFB", "\xFC", "\xFD", "\xFE", "\xFF" };
const char * const hb_szAscii[ 256 ] = {
"\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\x07", "\x08", "\x09", "\x0A", "\x0B", "\x0C", "\x0D", "\x0E", "\x0F",
"\x10", "\x11", "\x12", "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1A", "\x1B", "\x1C", "\x1D", "\x1E", "\x1F",
"\x20", "\x21", "\x22", "\x23", "\x24", "\x25", "\x26", "\x27", "\x28", "\x29", "\x2A", "\x2B", "\x2C", "\x2D", "\x2E", "\x2F",
"\x30", "\x31", "\x32", "\x33", "\x34", "\x35", "\x36", "\x37", "\x38", "\x39", "\x3A", "\x3B", "\x3C", "\x3D", "\x3E", "\x3F",
"\x40", "\x41", "\x42", "\x43", "\x44", "\x45", "\x46", "\x47", "\x48", "\x49", "\x4A", "\x4B", "\x4C", "\x4D", "\x4E", "\x4F",
"\x50", "\x51", "\x52", "\x53", "\x54", "\x55", "\x56", "\x57", "\x58", "\x59", "\x5A", "\x5B", "\x5C", "\x5D", "\x5E", "\x5F",
"\x60", "\x61", "\x62", "\x63", "\x64", "\x65", "\x66", "\x67", "\x68", "\x69", "\x6A", "\x6B", "\x6C", "\x6D", "\x6E", "\x6F",
"\x70", "\x71", "\x72", "\x73", "\x74", "\x75", "\x76", "\x77", "\x78", "\x79", "\x7A", "\x7B", "\x7C", "\x7D", "\x7E", "\x7F",
"\x80", "\x81", "\x82", "\x83", "\x84", "\x85", "\x86", "\x87", "\x88", "\x89", "\x8A", "\x8B", "\x8C", "\x8D", "\x8E", "\x8F",
"\x90", "\x91", "\x92", "\x93", "\x94", "\x95", "\x96", "\x97", "\x98", "\x99", "\x9A", "\x9B", "\x9C", "\x9D", "\x9E", "\x9F",
"\xA0", "\xA1", "\xA2", "\xA3", "\xA4", "\xA5", "\xA6", "\xA7", "\xA8", "\xA9", "\xAA", "\xAB", "\xAC", "\xAD", "\xAE", "\xAF",
"\xB0", "\xB1", "\xB2", "\xB3", "\xB4", "\xB5", "\xB6", "\xB7", "\xB8", "\xB9", "\xBA", "\xBB", "\xBC", "\xBD", "\xBE", "\xBF",
"\xC0", "\xC1", "\xC2", "\xC3", "\xC4", "\xC5", "\xC6", "\xC7", "\xC8", "\xC9", "\xCA", "\xCB", "\xCC", "\xCD", "\xCE", "\xCF",
"\xD0", "\xD1", "\xD2", "\xD3", "\xD4", "\xD5", "\xD6", "\xD7", "\xD8", "\xD9", "\xDA", "\xDB", "\xDC", "\xDD", "\xDE", "\xDF",
"\xE0", "\xE1", "\xE2", "\xE3", "\xE4", "\xE5", "\xE6", "\xE7", "\xE8", "\xE9", "\xEA", "\xEB", "\xEC", "\xED", "\xEE", "\xEF",
"\xF0", "\xF1", "\xF2", "\xF3", "\xF4", "\xF5", "\xF6", "\xF7", "\xF8", "\xF9", "\xFA", "\xFB", "\xFC", "\xFD", "\xFE", "\xFF" };
HB_SIZE hb_strAt( const char * szSub, HB_SIZE nSubLen, const char * szText, HB_SIZE nLen )
{

10
harbour/src/compiler/hbfunchk.c
View File

@@ -42,7 +42,7 @@ typedef struct
/* NOTE: THIS TABLE MUST BE SORTED ALPHABETICALLY
*/
static HB_FUNCINFO hb_StdFunc[] =
static const HB_FUNCINFO s_stdFunc[] =
{
{ "AADD" , 2, 2 },
{ "ABS" , 1, 1 },
@@ -113,7 +113,7 @@ static HB_FUNCINFO hb_StdFunc[] =
{ "YEAR" , 1, 1 }
};
#define HB_STD_FUNCOUNT ( sizeof( hb_StdFunc ) / sizeof( HB_FUNCINFO ) )
#define HB_STD_FUNCOUNT ( sizeof( s_stdFunc ) / sizeof( HB_FUNCINFO ) )
HB_BOOL hb_compFunCallCheck( HB_COMP_DECL, const char * szFuncCall, int iArgs )
{
@@ -129,7 +129,7 @@ HB_BOOL hb_compFunCallCheck( HB_COMP_DECL, const char * szFuncCall, int iArgs )
do
{
uiMiddle = ( uiFirst + uiLast ) >> 1;
iCmp = strncmp( szFuncCall, hb_StdFunc[ uiMiddle ].cFuncName, iLen );
iCmp = strncmp( szFuncCall, s_stdFunc[ uiMiddle ].cFuncName, iLen );
if( iCmp <= 0 )
uiLast = uiMiddle;
else
@@ -138,11 +138,11 @@ HB_BOOL hb_compFunCallCheck( HB_COMP_DECL, const char * szFuncCall, int iArgs )
while( uiFirst < uiLast );
if( uiFirst != uiMiddle )
iCmp = strncmp( szFuncCall, hb_StdFunc[ uiFirst ].cFuncName, iLen );
iCmp = strncmp( szFuncCall, s_stdFunc[ uiFirst ].cFuncName, iLen );
if( iCmp == 0 )
{
PHB_FUNCINFO pFunc = &hb_StdFunc[ uiFirst ];
const HB_FUNCINFO * pFunc = &s_stdFunc[ uiFirst ];
if( ( pFunc->iMinParam != -1 && iArgs < pFunc->iMinParam ) ||
( pFunc->iMaxParam != -1 && iArgs > pFunc->iMaxParam ) )

15
harbour/src/compiler/hbgenerr.c
View File

@@ -29,7 +29,7 @@
#include "hbcomp.h"
/* Table with parse errors */
const char * hb_comp_szErrors[] =
const char * const hb_comp_szErrors[] =
{
"Statement not allowed outside of procedure or function",
"Redefinition of procedure or function '%s'",
@@ -112,7 +112,7 @@ const char * hb_comp_szErrors[] =
/* NOTE: The first character stores the warning's level that triggers this
* warning. The warning's level is set by -w<n> command line option.
*/
const char * hb_comp_szWarnings[] =
const char * const hb_comp_szWarnings[] =
{
"1Ambiguous reference '%s'",
"1Ambiguous reference, assuming memvar '%s'",
@@ -150,7 +150,8 @@ const char * hb_comp_szWarnings[] =
};
static void hb_compDispMessage( HB_COMP_DECL, char cPrefix, int iValue,
const char * szText, const char * szPar1, const char * szPar2 )
const char * szText,
const char * szPar1, const char * szPar2 )
{
char buffer[ 512 ];
@@ -182,7 +183,9 @@ static void hb_compDispMessage( HB_COMP_DECL, char cPrefix, int iValue,
hb_compOutErr( HB_COMP_PARAM, "\n" );
}
void hb_compGenError( HB_COMP_DECL, const char * szErrors[], char cPrefix, int iError, const char * szError1, const char * szError2 )
void hb_compGenError( HB_COMP_DECL, const char * const szErrors[],
char cPrefix, int iError,
const char * szError1, const char * szError2 )
{
if( !HB_COMP_PARAM->fExit && ( cPrefix == 'F' || !HB_COMP_PARAM->fError ) )
{
@@ -204,7 +207,9 @@ void hb_compGenError( HB_COMP_DECL, const char * szErrors[], char cPrefix, int i
}
}
void hb_compGenWarning( HB_COMP_DECL, const char * szWarnings[], char cPrefix, int iWarning, const char * szWarning1, const char * szWarning2 )
void hb_compGenWarning( HB_COMP_DECL, const char * const szWarnings[],
char cPrefix, int iWarning,
const char * szWarning1, const char * szWarning2 )
{
const char * szText = szWarnings[ iWarning - 1 ];

3
harbour/src/compiler/ppcomp.c
View File

@@ -54,7 +54,8 @@
#include "hbcomp.h"
static void hb_pp_ErrorGen( void * cargo,
const char * szMsgTable[], char cPrefix, int iErrorCode,
const char * const szMsgTable[],
char cPrefix, int iErrorCode,
const char * szParam1, const char * szParam2 )
{
HB_COMP_DECL = ( HB_COMP_PTR ) cargo;

6
harbour/src/pp/ppcore.c
View File

@@ -104,14 +104,14 @@
/* warning messages */
static const char * hb_pp_szWarnings[] =
static const char * const hb_pp_szWarnings[] =
{
"1%s", /* C10?? */
"1Redefinition or duplicate definition of #define %s" /* C1005 */
};
/* error messages */
static const char * hb_pp_szErrors[] =
static const char * const hb_pp_szErrors[] =
{
"Illegal character '\\x%s'", /* C2004 */
"Unterminated string '%s'", /* C2007 */
@@ -224,7 +224,7 @@ static void hb_pp_disp( PHB_PP_STATE pState, const char * szMessage )
static void hb_pp_error( PHB_PP_STATE pState, char type, int iError, const char * szParam )
{
const char ** szMsgTable = type == 'W' ? hb_pp_szWarnings : hb_pp_szErrors;
const char * const * szMsgTable = type == 'W' ? hb_pp_szWarnings : hb_pp_szErrors;
if( pState->pErrorFunc )
{

2
harbour/src/pp/pplib.c
View File

@@ -60,7 +60,7 @@
HB_EXTERN_BEGIN
static void hb_pp_ErrorMessage( void * cargo, const char * szMsgTable[],
static void hb_pp_ErrorMessage( void * cargo, const char * const szMsgTable[],
char cPrefix, int iCode,
const char * szParam1, const char * szParam2 )
{

4
harbour/src/rtl/hbinet.c
View File

@@ -114,7 +114,7 @@ typedef struct
p = hb_itemPutPtrGC( p, s ); \
} while( 0 )
static const char * s_inetCRLF = "\r\n";
static const char * const s_inetCRLF = "\r\n";
static HB_COUNTER s_initialize = 1;
@@ -743,7 +743,7 @@ HB_FUNC( HB_INETRECVALL )
}
static void s_inetRecvPattern( const char ** patterns, int * patternsizes,
static void s_inetRecvPattern( const char * const * patterns, int * patternsizes,
int iPatternsCount, int iParam )
{
PHB_SOCKET_STRUCT socket = HB_PARSOCKET( 1 );

12
harbour/src/rtl/sha2.c
View File

@@ -143,27 +143,27 @@
# define _ULL( num ) num##ULL
#endif
uint32 sha224_h0[8] =
static const uint32 sha224_h0[8] =
{0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4};
uint32 sha256_h0[8] =
static const uint32 sha256_h0[8] =
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
uint64 sha384_h0[8] =
static const uint64 sha384_h0[8] =
{_ULL( 0xcbbb9d5dc1059ed8 ), _ULL( 0x629a292a367cd507 ),
_ULL( 0x9159015a3070dd17 ), _ULL( 0x152fecd8f70e5939 ),
_ULL( 0x67332667ffc00b31 ), _ULL( 0x8eb44a8768581511 ),
_ULL( 0xdb0c2e0d64f98fa7 ), _ULL( 0x47b5481dbefa4fa4 )};
uint64 sha512_h0[8] =
static const uint64 sha512_h0[8] =
{_ULL( 0x6a09e667f3bcc908 ), _ULL( 0xbb67ae8584caa73b ) ,
_ULL( 0x3c6ef372fe94f82b ), _ULL( 0xa54ff53a5f1d36f1 ) ,
_ULL( 0x510e527fade682d1 ), _ULL( 0x9b05688c2b3e6c1f ) ,
_ULL( 0x1f83d9abfb41bd6b ), _ULL( 0x5be0cd19137e2179 ) };
uint32 sha256_k[64] =
static const uint32 sha256_k[64] =
{0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -181,7 +181,7 @@ uint32 sha256_k[64] =
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
uint64 sha512_k[80] =
static const uint64 sha512_k[80] =
{_ULL( 0x428a2f98d728ae22 ), _ULL( 0x7137449123ef65cd ),
_ULL( 0xb5c0fbcfec4d3b2f ), _ULL( 0xe9b5dba58189dbbc ),
_ULL( 0x3956c25bf348b538 ), _ULL( 0x59f111f1b605d019 ),