TDE
/
tdelibs
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdelibs
0
0
Fork 0
Code Issues Releases Wiki Activity

Removed explicit usage of the 'register' keyword.

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit aa98dbfe80)
r14.0.x
Michele Calgaro 5 years ago
parent 9c1e136983
commit 41e0f335b5
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF
50 changed files with 415 additions and 415 deletions
Show Stats Download Patch File Download Diff File

4
dcop/KDE-ICE/Xtrans.c
Unescape View File

@ -1261,7 +1261,7 @@ static int TRANS(ReadV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt)
len = iov->iov_len; len = iov->iov_len;
base = iov->iov_base; base = iov->iov_base;
while (len > 0) { while (len > 0) {
register int nbytes; int nbytes;
nbytes = TRANS(Read) (ciptr, base, len); nbytes = TRANS(Read) (ciptr, base, len);
if (nbytes < 0 && total == 0) return -1; if (nbytes < 0 && total == 0) return -1;
if (nbytes <= 0) return total; if (nbytes <= 0) return total;
@ -1293,7 +1293,7 @@ static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt)
len = iov->iov_len; len = iov->iov_len;
base = iov->iov_base; base = iov->iov_base;
while (len > 0) { while (len > 0) {
register int nbytes; int nbytes;
nbytes = TRANS(Write) (ciptr, base, len); nbytes = TRANS(Write) (ciptr, base, len);
if (nbytes < 0 && total == 0) return -1; if (nbytes < 0 && total == 0) return -1;
if (nbytes <= 0) return total; if (nbytes <= 0) return total;

4
dcop/KDE-ICE/iceauth.c
Unescape View File

@ -45,7 +45,7 @@ extern Time_t time ();
#define Time_t time_t #define Time_t time_t
#endif #endif
static int binaryEqual (register const char *a, register const char *b, register unsigned len); static int binaryEqual (register const char *a, const char *b, unsigned len);
static int was_called_state; static int was_called_state;
@ -264,7 +264,7 @@ char **errorStringRet;
* local routines * local routines
*/ */
static int binaryEqual (register const char *a, register const char *b, register unsigned len) static int binaryEqual (register const char *a, const char *b, unsigned len)
{ {
while (len--) while (len--)
if (*a++ != *b++) if (*a++ != *b++)

16
dcop/KDE-ICE/misc.c
Unescape View File

@ -233,12 +233,12 @@ IceConn iceConn;
Status Status
_IceRead (iceConn, nbytes, ptr) _IceRead (iceConn, nbytes, ptr)
register IceConn iceConn; IceConn iceConn;
unsigned long nbytes; unsigned long nbytes;
register char *ptr; char *ptr;
{ {
register unsigned long nleft; unsigned long nleft;
nleft = nbytes; nleft = nbytes;
while (nleft > 0) while (nleft > 0)
@ -335,8 +335,8 @@ register char *ptr;
void void
_IceReadSkip (iceConn, nbytes) _IceReadSkip (iceConn, nbytes)
register IceConn iceConn; IceConn iceConn;
register unsigned long nbytes; unsigned long nbytes;
{ {
char temp[512]; char temp[512];
@ -359,12 +359,12 @@ register unsigned long nbytes;
void void
_IceWrite (iceConn, nbytes, ptr) _IceWrite (iceConn, nbytes, ptr)
register IceConn iceConn; IceConn iceConn;
unsigned long nbytes; unsigned long nbytes;
register char *ptr; char *ptr;
{ {
register unsigned long nleft; unsigned long nleft;
nleft = nbytes; nleft = nbytes;
while (nleft > 0) while (nleft > 0)

38
dcop/dcopidl/scanner.cc
Unescape View File

@ -1209,9 +1209,9 @@ extern int yylex (void);
*/ */
YY_DECL YY_DECL
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp, *yy_bp; char *yy_cp, *yy_bp;
register int yy_act; int yy_act;
#line 148 "scanner.ll" #line 148 "scanner.ll"
@ -1270,7 +1270,7 @@ YY_DECL
yy_match: yy_match:
do do
{ {
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{ {
yy_current_state = (int) yy_def[yy_current_state]; yy_current_state = (int) yy_def[yy_current_state];
@ -1909,9 +1909,9 @@ ECHO;
*/ */
static int yy_get_next_buffer (void) static int yy_get_next_buffer (void)
{ {
register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
register char *source = (yytext_ptr); char *source = (yytext_ptr);
register int number_to_move, i; int number_to_move, i;
int ret_val; int ret_val;
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
@ -2014,8 +2014,8 @@ static int yy_get_next_buffer (void)
static yy_state_type yy_get_previous_state (void) static yy_state_type yy_get_previous_state (void)
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp; char *yy_cp;
yy_current_state = (yy_start); yy_current_state = (yy_start);
@ -2024,7 +2024,7 @@ static int yy_get_next_buffer (void)
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
{ {
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{ {
yy_current_state = (int) yy_def[yy_current_state]; yy_current_state = (int) yy_def[yy_current_state];
@ -2045,9 +2045,9 @@ static int yy_get_next_buffer (void)
*/ */
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
{ {
register int yy_is_jam; int yy_is_jam;
register YY_CHAR yy_c = 1; YY_CHAR yy_c = 1;
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{ {
yy_current_state = (int) yy_def[yy_current_state]; yy_current_state = (int) yy_def[yy_current_state];
@ -2062,9 +2062,9 @@ static int yy_get_next_buffer (void)
return yy_is_jam ? 0 : yy_current_state; return yy_is_jam ? 0 : yy_current_state;
} }
static void yyunput (int c, register char * yy_bp ) static void yyunput (int c, char * yy_bp )
{ {
register char *yy_cp; char *yy_cp;
yy_cp = (yy_c_buf_p); yy_cp = (yy_c_buf_p);
@ -2074,10 +2074,10 @@ static int yy_get_next_buffer (void)
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */ { /* need to shift things up to make room */
/* +2 for EOB chars. */ /* +2 for EOB chars. */
register int number_to_move = (yy_n_chars) + 2; int number_to_move = (yy_n_chars) + 2;
register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
register char *source = char *source =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
@ -2694,7 +2694,7 @@ int yylex_destroy (void)
#ifndef yytext_ptr #ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
{ {
register int i; int i;
for ( i = 0; i < n; ++i ) for ( i = 0; i < n; ++i )
s1[i] = s2[i]; s1[i] = s2[i];
} }
@ -2703,7 +2703,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
#ifdef YY_NEED_STRLEN #ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * s ) static int yy_flex_strlen (yyconst char * s )
{ {
register int n; int n;
for ( n = 0; s[n]; ++n ) for ( n = 0; s[n]; ++n )
; ;

6
dcop/dcopserver.cpp
Unescape View File

@ -118,7 +118,7 @@ static Bool HostBasedAuthProc ( char* /*hostname*/)
extern "C" { extern "C" {
extern IceWriteHandler _kde_IceWriteHandler; extern IceWriteHandler _kde_IceWriteHandler;
extern IceIOErrorHandler _kde_IceIOErrorHandler; extern IceIOErrorHandler _kde_IceIOErrorHandler;
void DCOPIceWriteChar(register IceConn iceConn, unsigned long nbytes, char *ptr); void DCOPIceWriteChar(IceConn iceConn, unsigned long nbytes, char *ptr);
} }
static TQCString readQCString(TQDataStream &ds) static TQCString readQCString(TQDataStream &ds)
@ -237,7 +237,7 @@ static unsigned long writeIceData(IceConn iceConn, unsigned long nbytes, char *p
return 0; return 0;
} }
void DCOPIceWriteChar(register IceConn iceConn, unsigned long nbytes, char *ptr) void DCOPIceWriteChar(IceConn iceConn, unsigned long nbytes, char *ptr)
{ {
DCOPConnection* conn = the_server->findConn( iceConn ); DCOPConnection* conn = the_server->findConn( iceConn );
#ifdef DCOP_DEBUG #ifdef DCOP_DEBUG
@ -384,7 +384,7 @@ tqWarning("[dcopserver] slotOutputRead() more data to send.");
} }
} }
static void DCOPIceSendData(register IceConn _iceConn, static void DCOPIceSendData(IceConn _iceConn,
const TQByteArray &_data) const TQByteArray &_data)
{ {
if (_iceConn->outbufptr > _iceConn->outbuf) if (_iceConn->outbufptr > _iceConn->outbuf)

16
kab/addressbook.cc
Unescape View File

@ -407,7 +407,7 @@ AddressBook::AddressBook(TQWidget* parent, const char* name, bool loadit)
entries(new StringKabKeyMap), entries(new StringKabKeyMap),
state(NoFile) state(NoFile)
{ {
register bool GUARD; GUARD=true; bool GUARD; GUARD=true;
// ########################################################################### // ###########################################################################
TQString dir, filename; TQString dir, filename;
bool createBackup=true; bool createBackup=true;
@ -647,7 +647,7 @@ AddressBook::ErrorCode AddressBook::load(const TQString& filename)
AddressBook::ErrorCode AddressBook::ErrorCode
AddressBook::getListOfNames(TQStringList* strings, bool reverse, bool initials) AddressBook::getListOfNames(TQStringList* strings, bool reverse, bool initials)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::getListOfNames: called.\n"; kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::getListOfNames: called.\n";
StringKabKeyMap::iterator pos; StringKabKeyMap::iterator pos;
@ -702,7 +702,7 @@ AddressBook::literalName(const KabKey& key, TQString& text, bool rev, bool init)
AddressBook::ErrorCode AddressBook::ErrorCode
AddressBook::literalName(const Entry& entry, TQString& text, bool rev, bool init) AddressBook::literalName(const Entry& entry, TQString& text, bool rev, bool init)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::literalName: called.\n"; kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::literalName: called.\n";
TQString firstname, middlename, lastname, nameprefix; TQString firstname, middlename, lastname, nameprefix;
@ -817,7 +817,7 @@ AddressBook::dataFileChanged()
void void
AddressBook::configFileChanged() AddressBook::configFileChanged()
{ {
register bool GUARD; GUARD=true; bool GUARD; GUARD=true;
// ########################################################################### // ###########################################################################
if(!config->load()) if(!config->load())
{ {
@ -835,7 +835,7 @@ AddressBook::configFileChanged()
void void
AddressBook::reloaded(QConfigDB* db) AddressBook::reloaded(QConfigDB* db)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
if(db==data) if(db==data)
{ {
@ -924,7 +924,7 @@ AddressBook::getEntry(const KabKey& key, Entry& entry)
AddressBook::ErrorCode AddressBook::ErrorCode
AddressBook::getEntry(const KabKey& key, Section*& section) AddressBook::getEntry(const KabKey& key, Section*& section)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::getEntry: searching entry " kdDebug(GUARD, KAB_KDEBUG_AREA) << "AddressBook::getEntry: searching entry "
"with key " << key.getKey().data() << endl; "with key " << key.getKey().data() << endl;
@ -1004,7 +1004,7 @@ AddressBook::getKey(int index, KabKey& key)
AddressBook::ErrorCode AddressBook::ErrorCode
AddressBook::getIndex(const KabKey& key, int& index) AddressBook::getIndex(const KabKey& key, int& index)
{ {
register bool GUARD; GUARD=true; bool GUARD; GUARD=true;
// ########################################################################### // ###########################################################################
StringKabKeyMap::iterator pos; StringKabKeyMap::iterator pos;
// ----- // -----
@ -1283,7 +1283,7 @@ AddressBook::nextAvailEntryKey()
AddressBook::ErrorCode AddressBook::ErrorCode
AddressBook::updateMirrorMap() AddressBook::updateMirrorMap()
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) kdDebug(GUARD, KAB_KDEBUG_AREA)
<< "AddressBook::updateMirrorMap: updating mirror map.\n"; << "AddressBook::updateMirrorMap: updating mirror map.\n";

114
kab/qconfigDB.cc
Unescape View File

@ -55,7 +55,7 @@ static bool isComment(TQCString line)
static void tokenize(list<TQCString>& res, const TQCString& text, char tr, bool strict=false) static void tokenize(list<TQCString>& res, const TQCString& text, char tr, bool strict=false)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "tokenize: called." << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "tokenize: called." << endl;
int eins=0, zwei=0; int eins=0, zwei=0;
@ -99,7 +99,7 @@ static void tokenize(list<TQCString>& res, const TQCString& text, char tr, bool
static TQCString ReadLineFromStream(TQTextStream& stream) static TQCString ReadLineFromStream(TQTextStream& stream)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "ReadLineFromStream:: reading line." << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "ReadLineFromStream:: reading line." << endl;
TQCString line; TQCString line;
@ -174,7 +174,7 @@ KeyValueMap::size() const
void void
KeyValueMap::clear() KeyValueMap::clear()
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::clear: erasing map contents ... " << endl; "KeyValueMap::clear: erasing map contents ... " << endl;
@ -191,7 +191,7 @@ KeyValueMap::clear()
bool bool
KeyValueMap::fill(const TQString& filename, bool force, bool relax) KeyValueMap::fill(const TQString& filename, bool force, bool relax)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
TQFile file(filename); TQFile file(filename);
TQCString line; TQCString line;
@ -231,7 +231,7 @@ KeyValueMap::fill(const TQString& filename, bool force, bool relax)
bool bool
KeyValueMap::save(const TQString& filename, bool force) KeyValueMap::save(const TQString& filename, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::save: saving data to -->" << "KeyValueMap::save: saving data to -->" <<
@ -271,7 +271,7 @@ KeyValueMap::save(const TQString& filename, bool force)
bool bool
KeyValueMap::save(TQTextStream& file, int count) KeyValueMap::save(TQTextStream& file, int count)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::save: saving data to given output stream." << endl; "KeyValueMap::save: saving data to given output stream." << endl;
@ -318,7 +318,7 @@ KeyValueMap::parseComplexString
int& noOfChars) // no of chars that represented the int& noOfChars) // no of chars that represented the
const // complex string in the original const // complex string in the original
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
int first; int first;
TQCString temp(2*orig.length()); TQCString temp(2*orig.length());
@ -415,7 +415,7 @@ KeyValueMap::parseComplexString
TQCString TQCString
KeyValueMap::makeComplexString(const TQCString& orig) KeyValueMap::makeComplexString(const TQCString& orig)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::makeComplexString: coding the string\n -->" "KeyValueMap::makeComplexString: coding the string\n -->"
@ -468,7 +468,7 @@ KeyValueMap::makeComplexString(const TQCString& orig)
bool bool
KeyValueMap::getRaw(const TQCString& key, TQCString& value) const KeyValueMap::getRaw(const TQCString& key, TQCString& value) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::getRaw: trying to get raw value for key \"" << key << "\" ...\n"; "KeyValueMap::getRaw: trying to get raw value for key \"" << key << "\" ...\n";
@ -490,7 +490,7 @@ KeyValueMap::getRaw(const TQCString& key, TQCString& value) const
bool bool
KeyValueMap::insertRaw(const TQCString& key, const TQCString& value, bool force) KeyValueMap::insertRaw(const TQCString& key, const TQCString& value, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insertRaw: inserting uncoded value " "KeyValueMap::insertRaw: inserting uncoded value "
@ -535,7 +535,7 @@ KeyValueMap::insertRaw(const TQCString& key, const TQCString& value, bool force)
bool bool
KeyValueMap::insert(const TQCString& key, const TQCString& value, bool force) KeyValueMap::insert(const TQCString& key, const TQCString& value, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insert: inserting value\n -->" "KeyValueMap::insert: inserting value\n -->"
@ -556,7 +556,7 @@ KeyValueMap::insert(const TQCString& key, const TQCString& value, bool force)
bool bool
KeyValueMap::insertLine(TQCString line, bool force, bool relax, bool encode) KeyValueMap::insertLine(TQCString line, bool force, bool relax, bool encode)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insertLine: inserting line -->"<<line<<"<--.\n"; "KeyValueMap::insertLine: inserting line -->"<<line<<"<--.\n";
@ -611,7 +611,7 @@ KeyValueMap::insertLine(TQCString line, bool force, bool relax, bool encode)
bool bool
KeyValueMap::get(const TQCString& key, TQCString& value) const KeyValueMap::get(const TQCString& key, TQCString& value) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[string]: " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[string]: "
"trying to get value for key \"" << key << "\" ... " << endl; "trying to get value for key \"" << key << "\" ... " << endl;
@ -651,7 +651,7 @@ KeyValueMap::get(const TQCString& key, TQCString& value) const
bool bool
KeyValueMap::insert(const TQCString& key, const TQString& value, bool force) KeyValueMap::insert(const TQCString& key, const TQString& value, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
TQCString v; TQCString v;
// ----- // -----
@ -668,7 +668,7 @@ KeyValueMap::insert(const TQCString& key, const TQString& value, bool force)
bool bool
KeyValueMap::get(const TQCString& key, TQString& value) const KeyValueMap::get(const TQCString& key, TQString& value) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[QString]: trying to get " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[QString]: trying to get "
"a TQString value for key " << key << endl; "a TQString value for key " << key << endl;
@ -694,7 +694,7 @@ KeyValueMap::get(const TQCString& key, TQString& value) const
bool bool
KeyValueMap::insert(const TQCString& key, const bool& value, bool force) KeyValueMap::insert(const TQCString& key, const bool& value, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[bool]: trying to " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[bool]: trying to "
"insert \"" "insert \""
@ -709,7 +709,7 @@ KeyValueMap::insert(const TQCString& key, const bool& value, bool force)
bool bool
KeyValueMap::get(const TQCString& key, bool& value) const KeyValueMap::get(const TQCString& key, bool& value) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[bool]: trying to get " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[bool]: trying to get "
"BOOL value for key " << key << endl; "BOOL value for key " << key << endl;
@ -750,7 +750,7 @@ KeyValueMap::get(const TQCString& key, bool& value) const
bool bool
KeyValueMap::insert(const TQCString& key, const long& value, bool force) KeyValueMap::insert(const TQCString& key, const long& value, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[int]: trying to " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[int]: trying to "
"insert value \""<<value << "\" for key\n -->"<<key<<"<--.\n"; "insert value \""<<value << "\" for key\n -->"<<key<<"<--.\n";
@ -764,7 +764,7 @@ KeyValueMap::insert(const TQCString& key, const long& value, bool force)
bool bool
KeyValueMap::get(const TQCString& key, long& value) const KeyValueMap::get(const TQCString& key, long& value) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[int]: trying to get " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[int]: trying to get "
"INTEGER value for key " << key << endl; "INTEGER value for key " << key << endl;
@ -796,7 +796,7 @@ KeyValueMap::get(const TQCString& key, long& value) const
bool bool
KeyValueMap::insert(const TQCString& key, const list<long>& values, bool force) KeyValueMap::insert(const TQCString& key, const list<long>& values, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[long int list]: " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[long int list]: "
"trying to insert long int list into map." << endl; "trying to insert long int list into map." << endl;
@ -823,7 +823,7 @@ KeyValueMap::insert(const TQCString& key, const list<long>& values, bool force)
bool bool
KeyValueMap::get(const TQCString& key, list<long>& values) const KeyValueMap::get(const TQCString& key, list<long>& values) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[long int list]: trying " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[long int list]: trying "
"to decode int list for key " << key << endl; "to decode int list for key " << key << endl;
@ -871,7 +871,7 @@ KeyValueMap::get(const TQCString& key, list<long>& values) const
bool bool
KeyValueMap::insert(const TQCString& key, const list<int>& values, bool force) KeyValueMap::insert(const TQCString& key, const list<int>& values, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[int list]: trying to " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[int list]: trying to "
"insert int list into map." << endl; "insert int list into map." << endl;
@ -898,7 +898,7 @@ KeyValueMap::insert(const TQCString& key, const list<int>& values, bool force)
bool bool
KeyValueMap::get(const TQCString& key, list<int>& values) const KeyValueMap::get(const TQCString& key, list<int>& values) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[int list]: trying to " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[int list]: trying to "
"decode int list for key " << key << endl; "decode int list for key " << key << endl;
@ -946,7 +946,7 @@ KeyValueMap::get(const TQCString& key, list<int>& values) const
bool bool
KeyValueMap::insert(const TQCString& key, const double& value, bool force) KeyValueMap::insert(const TQCString& key, const double& value, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA).form("KeyValueMap::insert[double]: trying to " kdDebug(GUARD, KAB_KDEBUG_AREA).form("KeyValueMap::insert[double]: trying to "
"insert value \"%f\" for key\n -->", value) << key << "<--.\n"; "insert value \"%f\" for key\n -->", value) << key << "<--.\n";
@ -960,7 +960,7 @@ KeyValueMap::insert(const TQCString& key, const double& value, bool force)
bool bool
KeyValueMap::get(const TQCString& key, double& value) const KeyValueMap::get(const TQCString& key, double& value) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[double]: trying to get " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[double]: trying to get "
"FLOAT value for key " << key << endl; "FLOAT value for key " << key << endl;
@ -993,7 +993,7 @@ KeyValueMap::get(const TQCString& key, double& value) const
bool bool
KeyValueMap::get(const TQCString& key, list<TQCString>& values) const KeyValueMap::get(const TQCString& key, list<TQCString>& values) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
kdDebug(!values.empty(), KAB_KDEBUG_AREA) << "KeyValueMap::get[string list]: " kdDebug(!values.empty(), KAB_KDEBUG_AREA) << "KeyValueMap::get[string list]: "
"attention!\n \"values\" list reference is not " "attention!\n \"values\" list reference is not "
"empty!" << endl; "empty!" << endl;
@ -1070,7 +1070,7 @@ KeyValueMap::get(const TQCString& key, list<TQCString>& values) const
bool bool
KeyValueMap::insert(const TQCString& key, const list<TQCString>& values, bool force) KeyValueMap::insert(const TQCString& key, const list<TQCString>& values, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[string list]: " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[string list]: "
"coding string list." << endl; "coding string list." << endl;
@ -1102,7 +1102,7 @@ KeyValueMap::insert(const TQCString& key, const list<TQCString>& values, bool fo
bool bool
KeyValueMap::get(const TQCString& key, TQStrList& values) const KeyValueMap::get(const TQCString& key, TQStrList& values) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
kdDebug(!values.isEmpty(), KAB_KDEBUG_AREA) << "KeyValueMap::get[QStrList]: " kdDebug(!values.isEmpty(), KAB_KDEBUG_AREA) << "KeyValueMap::get[QStrList]: "
"attention!\n \"values\" list reference is not " "attention!\n \"values\" list reference is not "
"empty!" << endl; "empty!" << endl;
@ -1178,7 +1178,7 @@ KeyValueMap::get(const TQCString& key, TQStrList& values) const
bool bool
KeyValueMap::insert(const TQCString& key, const TQStrList& values, bool force) KeyValueMap::insert(const TQCString& key, const TQStrList& values, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insert[QStrList]: coding string list." << endl; "KeyValueMap::insert[QStrList]: coding string list." << endl;
@ -1209,7 +1209,7 @@ KeyValueMap::insert(const TQCString& key, const TQStrList& values, bool force)
bool bool
KeyValueMap::get(const TQCString& key, TQStringList& values) const KeyValueMap::get(const TQCString& key, TQStringList& values) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
kdDebug(!values.isEmpty(), KAB_KDEBUG_AREA) << "KeyValueMap::get" kdDebug(!values.isEmpty(), KAB_KDEBUG_AREA) << "KeyValueMap::get"
"[QStringList]: attention!\n \"values\" list reference" "[QStringList]: attention!\n \"values\" list reference"
" is not empty!" << endl; " is not empty!" << endl;
@ -1242,7 +1242,7 @@ KeyValueMap::get(const TQCString& key, TQStringList& values) const
bool bool
KeyValueMap::insert(const TQCString& key, const TQStringList& values, bool force) KeyValueMap::insert(const TQCString& key, const TQStringList& values, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insert[QStringList]: coding TQStringList." << endl; "KeyValueMap::insert[QStringList]: coding TQStringList." << endl;
@ -1265,7 +1265,7 @@ KeyValueMap::insert(const TQCString& key, const TQStringList& values, bool force
bool bool
KeyValueMap::insert(const TQCString& key, const list<double>& values, bool force) KeyValueMap::insert(const TQCString& key, const list<double>& values, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[double list]: trying " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[double list]: trying "
"to insert double list into map." << endl; "to insert double list into map." << endl;
@ -1293,7 +1293,7 @@ KeyValueMap::insert(const TQCString& key, const list<double>& values, bool force
bool bool
KeyValueMap::get(const TQCString& key, list<double>& values) const KeyValueMap::get(const TQCString& key, list<double>& values) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[double list]: trying to " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[double list]: trying to "
"decode double list for key " << key << endl; "decode double list for key " << key << endl;
@ -1336,7 +1336,7 @@ KeyValueMap::get(const TQCString& key, list<double>& values) const
bool bool
KeyValueMap::insert(const TQCString& key, const TQDate& value, bool force) KeyValueMap::insert(const TQCString& key, const TQDate& value, bool force)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[QDate]: trying to " kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::insert[QDate]: trying to "
"insert TQDate into map." << endl; "insert TQDate into map." << endl;
@ -1360,7 +1360,7 @@ KeyValueMap::insert(const TQCString& key, const TQDate& value, bool force)
bool bool
KeyValueMap::get(const TQCString& key, TQDate& date) const KeyValueMap::get(const TQCString& key, TQDate& date) const
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[QDate]: trying to decode" kdDebug(GUARD, KAB_KDEBUG_AREA) << "KeyValueMap::get[QDate]: trying to decode"
" TQDate for key " << key << endl; " TQDate for key " << key << endl;
@ -1420,7 +1420,7 @@ Section::Section(const KeyValueMap& contents)
bool bool
Section::add(const TQCString& name) Section::add(const TQCString& name)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::add: adding section \"" kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::add: adding section \""
<<name<<"\" to " <<name<<"\" to "
@ -1455,7 +1455,7 @@ Section::add(const TQCString& name)
bool bool
Section::add(const TQCString& name, Section* section) Section::add(const TQCString& name, Section* section)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
if(sections.insert(StringSectionMap::value_type(name, section)).second) if(sections.insert(StringSectionMap::value_type(name, section)).second)
{ {
@ -1473,7 +1473,7 @@ Section::add(const TQCString& name, Section* section)
bool bool
Section::find(const TQCString& name, StringSectionMap::iterator& result) Section::find(const TQCString& name, StringSectionMap::iterator& result)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::find: trying to get section " kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::find: trying to get section "
"\""<<name<<"\" ... \n"; "\""<<name<<"\" ... \n";
@ -1549,7 +1549,7 @@ Section::insertIndentSpace(TQTextStream& file, int level)
bool bool
Section::save(TQTextStream& stream, int level) Section::save(TQTextStream& stream, int level)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
StringSectionMap::iterator pos; StringSectionMap::iterator pos;
// ----- // -----
@ -1592,7 +1592,7 @@ Section::save(TQTextStream& stream, int level)
bool bool
Section::readSection(TQTextStream& file, bool finish) Section::readSection(TQTextStream& file, bool finish)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::readSection: reading section." << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::readSection: reading section." << endl;
TQCString line; TQCString line;
@ -1661,7 +1661,7 @@ Section::readSection(TQTextStream& file, bool finish)
bool bool
Section::isBeginOfSection(TQCString line) Section::isBeginOfSection(TQCString line)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
line=line.simplifyWhiteSpace(); line=line.simplifyWhiteSpace();
if(line.isEmpty() || line.length()<2) if(line.isEmpty() || line.length()<2)
@ -1687,7 +1687,7 @@ Section::isBeginOfSection(TQCString line)
bool bool
Section::isEndOfSection(TQCString line) Section::isEndOfSection(TQCString line)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::isEndOfSection: is " kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::isEndOfSection: is "
<< line <<" the end of" << line <<" the end of"
@ -1728,7 +1728,7 @@ Section::isEndOfSection(TQCString line)
TQCString TQCString
Section::nameOfSection(const TQCString& line) Section::nameOfSection(const TQCString& line)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ########################################################################### // ###########################################################################
int first=1, second; int first=1, second;
TQCString temp; TQCString temp;
@ -1849,7 +1849,7 @@ bool QConfigDB::invariant()
bool bool
QConfigDB::get(const list<TQCString>& key, KeyValueMap*& map) QConfigDB::get(const list<TQCString>& key, KeyValueMap*& map)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::get: trying to get keys ... " << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::get: trying to get keys ... " << endl;
Section* section=&top; Section* section=&top;
@ -1960,7 +1960,7 @@ QConfigDB::get(const TQCString& key, KeyValueMap*& map)
list<TQCString> list<TQCString>
QConfigDB::stringToKeylist(const TQCString& desc) QConfigDB::stringToKeylist(const TQCString& desc)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::stringToKeylist: parsing path " << desc << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::stringToKeylist: parsing path " << desc << endl;
// ############################################################################ // ############################################################################
list<TQCString> key; list<TQCString> key;
@ -2012,7 +2012,7 @@ QConfigDB::get(const TQCString& key, Section*& section)
bool bool
QConfigDB::get(const list<TQCString>& key, Section*& section) QConfigDB::get(const list<TQCString>& key, Section*& section)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::get: searching section ... " << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::get: searching section ... " << endl;
Section* temp=&top; Section* temp=&top;
@ -2044,7 +2044,7 @@ QConfigDB::isRO()
int int
QConfigDB::IsLocked(const TQString& file) QConfigDB::IsLocked(const TQString& file)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
TQString lockfile=file+".lock"; TQString lockfile=file+".lock";
int pid=-1; int pid=-1;
@ -2087,7 +2087,7 @@ QConfigDB::IsLocked(const TQString& file)
bool bool
QConfigDB::lock() QConfigDB::lock()
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
if(locked) if(locked)
{ {
@ -2108,7 +2108,7 @@ QConfigDB::lock()
bool bool
QConfigDB::lock(const TQString& file) QConfigDB::lock(const TQString& file)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::lock: locking the file " kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::lock: locking the file "
<< file << endl; << file << endl;
@ -2143,7 +2143,7 @@ QConfigDB::lock(const TQString& file)
bool bool
QConfigDB::unlock() QConfigDB::unlock()
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::unlock: unlocking the file " kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::unlock: unlocking the file "
<< filename << endl; << filename << endl;
@ -2190,7 +2190,7 @@ QConfigDB::unlock()
void void
QConfigDB::CleanLockFiles(int) QConfigDB::CleanLockFiles(int)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
list<TQString>::iterator pos; list<TQString>::iterator pos;
// ----- // -----
@ -2236,7 +2236,7 @@ QConfigDB::watch(bool state)
bool bool
QConfigDB::CheckLockFile(const TQString& file) QConfigDB::CheckLockFile(const TQString& file)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::CheckLockFile: called." << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::CheckLockFile: called." << endl;
int pid; int pid;
@ -2270,7 +2270,7 @@ QConfigDB::CheckLockFile(const TQString& file)
bool bool
QConfigDB::checkFileChanged() QConfigDB::checkFileChanged()
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
// kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::checkFileChanged: called." << endl; // kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::checkFileChanged: called." << endl;
if(filename.isEmpty()) if(filename.isEmpty())
@ -2308,7 +2308,7 @@ QConfigDB::checkFileChanged()
bool bool
QConfigDB::storeFileAge() QConfigDB::storeFileAge()
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::storeFileAge: called." << endl; kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::storeFileAge: called." << endl;
TQFileInfo file(filename); TQFileInfo file(filename);
@ -2329,7 +2329,7 @@ QConfigDB::storeFileAge()
bool bool
QConfigDB::setFileName(const TQString& filename_, bool mustexist, bool readonly_) QConfigDB::setFileName(const TQString& filename_, bool mustexist, bool readonly_)
{ {
register bool GUARD; GUARD=false; bool GUARD; GUARD=false;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::setFileName: setting filename " kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::setFileName: setting filename "
"to \"" "to \""
@ -2443,7 +2443,7 @@ QConfigDB::fileName()
bool bool
QConfigDB::save(const char* header, bool force) QConfigDB::save(const char* header, bool force)
{ {
register bool GUARD; GUARD=true; bool GUARD; GUARD=true;
// ############################################################################ // ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"QConfigDB::save: saving database -->" << filename << "<--.\n"; "QConfigDB::save: saving database -->" << filename << "<--.\n";
@ -2522,7 +2522,7 @@ QConfigDB::save(const char* header, bool force)
bool bool
QConfigDB::load() QConfigDB::load()
{ {
register bool GUARD; GUARD=false ; bool GUARD; GUARD=false ;
// ############################################################################ // ############################################################################
TQFile file(filename); TQFile file(filename);
// ----- // -----

10
kjs/dtoa.cpp
Unescape View File

@ -610,9 +610,9 @@ s2b
static int static int
hi0bits hi0bits
(register ULong x) (ULong x)
{ {
register int k = 0; int k = 0;
if (!(x & 0xffff0000)) { if (!(x & 0xffff0000)) {
k = 16; k = 16;
@ -642,8 +642,8 @@ hi0bits
lo0bits lo0bits
(ULong *y) (ULong *y)
{ {
register int k; int k;
register ULong x = *y; ULong x = *y;
if (x & 7) { if (x & 7) {
if (x & 1) if (x & 1)
@ -1035,7 +1035,7 @@ diff
ulp ulp
(double dx) (double dx)
{ {
register Long L; Long L;
U x, a; U x, a;
dval(x) = dx; dval(x) = dx;

12
tdeabc/vcard/Enum.cpp
Unescape View File

@ -433,12 +433,12 @@ static signed char b64dec[] = {
char * char *
VCARD::decodeBase64(const char * s, unsigned long srcl, unsigned long & len) VCARD::decodeBase64(const char * s, unsigned long srcl, unsigned long & len)
{ {
register unsigned char c; unsigned char c;
register unsigned long e(0); unsigned long e(0);
len = 0; len = 0;
unsigned const char * src = (unsigned const char *)s; unsigned const char * src = (unsigned const char *)s;
char * ret = new char[srcl + (srcl / 4 + 1)]; char * ret = new char[srcl + (srcl / 4 + 1)];
register char *d = ret; char *d = ret;
while (srcl--) { // Critical loop while (srcl--) { // Critical loop
c = *src++; c = *src++;
int dec = b64dec[c]; int dec = b64dec[c];
@ -468,12 +468,12 @@ VCARD::decodeBase64(const char * s, unsigned long srcl, unsigned long & len)
char * char *
VCARD::encodeBase64(const char * src, unsigned long srcl, unsigned long & destl) VCARD::encodeBase64(const char * src, unsigned long srcl, unsigned long & destl)
{ {
register const unsigned char *s = (unsigned char *)src; const unsigned char *s = (unsigned char *)src;
register unsigned long i = ((srcl + 2) / 3) * 4; unsigned long i = ((srcl + 2) / 3) * 4;
destl = i += 2 * ((i / 60) + 1); destl = i += 2 * ((i / 60) + 1);
i = 0; i = 0;
char * ret = new char[destl]; char * ret = new char[destl];
register unsigned char *d((unsigned char *)ret); unsigned char *d((unsigned char *)ret);
while (srcl != 0) { // Critical loop while (srcl != 0) { // Critical loop
*d++ = B64[s[0] >> 2]; *d++ = B64[s[0] >> 2];
*d++ = B64[((s[0] << 4) + (--srcl == 0 ? 0 : s[1] >> 4)) & 0x3f]; *d++ = B64[((s[0] << 4) + (--srcl == 0 ? 0 : s[1] >> 4)) & 0x3f];

6
tdeabc/vcard/RToken.cpp
Unescape View File

@ -40,11 +40,11 @@ RTokenise(const char * str, const char * delim, TQStrList & l)
char * len = (char *)(str + strlen(str)); // End of string. char * len = (char *)(str + strlen(str)); // End of string.
register char * rstart = new char[strlen(str) + 1]; char * rstart = new char[strlen(str) + 1];
register char * r = rstart; char * r = rstart;
register const char * i = str; // Cursor. const char * i = str; // Cursor.
while (i <= len) { while (i <= len) {

2
tdecore/kbufferedio.cpp
Unescape View File

@ -174,7 +174,7 @@ int TDEBufferedIO::unreadBlock(const char *data, uint len)
unsigned TDEBufferedIO::consumeReadBuffer(unsigned nbytes, char *destbuffer, bool discard) unsigned TDEBufferedIO::consumeReadBuffer(unsigned nbytes, char *destbuffer, bool discard)
{ {
{ {
register unsigned u = readBufferSize(); unsigned u = readBufferSize();
if (nbytes > u) if (nbytes > u)
nbytes = u; // we can't consume more than there is nbytes = u; // we can't consume more than there is
} }

12
tdecore/kentities.c
Unescape View File

@ -73,7 +73,7 @@ inline
#endif #endif
#endif #endif
static unsigned int static unsigned int
hash_Entity (register const char *str, register unsigned int len) hash_Entity (register const char *str, unsigned int len)
{ {
static const unsigned short asso_values[] = static const unsigned short asso_values[] =
{ {
@ -104,7 +104,7 @@ hash_Entity (register const char *str, register unsigned int len)
932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932,
932, 932, 932, 932, 932, 932, 932 932, 932, 932, 932, 932, 932, 932
}; };
register int hval = len; int hval = len;
switch (hval) switch (hval)
{ {
@ -140,7 +140,7 @@ hash_Entity (register const char *str, register unsigned int len)
__inline __inline
#endif #endif
const struct entity * const struct entity *
kde_findEntity (register const char *str, register unsigned int len) kde_findEntity (register const char *str, unsigned int len)
{ {
enum enum
{ {
@ -815,15 +815,15 @@ kde_findEntity (register const char *str, register unsigned int len)
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
{ {
register int key = hash_Entity (str, len); int key = hash_Entity (str, len);
if (key <= MAX_HASH_VALUE && key >= 0) if (key <= MAX_HASH_VALUE && key >= 0)
{ {
register int index = lookup[key]; int index = lookup[key];
if (index >= 0) if (index >= 0)
{ {
register const char *s = wordlist_Entity[index].name; const char *s = wordlist_Entity[index].name;
if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
return &wordlist_Entity[index]; return &wordlist_Entity[index];

2
tdecore/kextsock.cpp
Unescape View File

@ -1509,7 +1509,7 @@ TQT_TQIO_LONG KExtendedSocket::tqwriteBlock(const char *data, TQT_TQIO_ULONG len
// LOCK BUFFER MUTEX // LOCK BUFFER MUTEX
register unsigned wsize = writeBufferSize(); unsigned wsize = writeBufferSize();
if (d->outMaxSize == (int)wsize) // (int) to get rid of annoying warning if (d->outMaxSize == (int)wsize) // (int) to get rid of annoying warning
{ {
// buffer is full! // buffer is full!

2
tdecore/kmdcodec.cpp
Unescape View File

@ -139,7 +139,7 @@ const unsigned int KCodecs::maxQPLineLength = 70;
// strchr(3) for broken systems. // strchr(3) for broken systems.
static int rikFindChar(register const char * _s, const char c) static int rikFindChar(register const char * _s, const char c)
{ {
register const char * s = _s; const char * s = _s;
while (true) while (true)
{ {

2
tdecore/kstringhandler.cpp
Unescape View File

@ -567,7 +567,7 @@ TQString KStringHandler::obscure( const TQString &str )
bool KStringHandler::isUtf8(const char *buf) bool KStringHandler::isUtf8(const char *buf)
{ {
int i, n; int i, n;
register unsigned char c; unsigned char c;
bool gotone = false; bool gotone = false;
if (!buf) if (!buf)

10
tdecore/tdeconfigbackend.cpp
Unescape View File

@ -114,8 +114,8 @@ static TQCString printableToString(const char *str, int l)
static TQCString stringToPrintable(const TQCString& str){ static TQCString stringToPrintable(const TQCString& str){
TQCString result(str.length()*2); // Maximum 2x as long as source string TQCString result(str.length()*2); // Maximum 2x as long as source string
register char *r = const_cast<TQCString&>(result).data(); char *r = const_cast<TQCString&>(result).data();
register char *s = const_cast<TQCString&>(str).data(); char *s = const_cast<TQCString&>(str).data();
if (!s) return TQCString(""); if (!s) return TQCString("");
@ -166,7 +166,7 @@ static TQCString stringToPrintable(const TQCString& str){
static TQCString decodeGroup(const char*s, int l) static TQCString decodeGroup(const char*s, int l)
{ {
TQCString result(l); TQCString result(l);
register char *r = result.data(); char *r = result.data();
l--; // Correct for trailing \0 l--; // Correct for trailing \0
while(l) while(l)
@ -198,8 +198,8 @@ static TQCString encodeGroup(const TQCString &str)
{ {
int l = str.length(); int l = str.length();
TQCString result(l*2+1); TQCString result(l*2+1);
register char *r = const_cast<TQCString&>(result).data(); char *r = const_cast<TQCString&>(result).data();
register char *s = const_cast<TQCString&>(str).data(); char *s = const_cast<TQCString&>(str).data();
while(l) while(l)
{ {
if ((*s == '[') || (*s == ']')) if ((*s == '[') || (*s == ']'))

2
tdecore/tdehw/tdehardwaredevices.cpp
Unescape View File

@ -106,7 +106,7 @@ timespec diff(timespec start, timespec end)
// This routine is courtsey of an answer on "Stack Overflow" // This routine is courtsey of an answer on "Stack Overflow"
// It takes an LSB-first int and makes it an MSB-first int (or vice versa) // It takes an LSB-first int and makes it an MSB-first int (or vice versa)
unsigned int reverse_bits(register unsigned int x) unsigned int reverse_bits(unsigned int x)
{ {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1)); x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2)); x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));

6
tdecore/tdelocale.cpp
Unescape View File

@ -1976,7 +1976,7 @@ TQString TDELocale::formatDateTime(const TQDateTime &pDateTime,
TQString i18n(const char* text) TQString i18n(const char* text)
{ {
register TDELocale *instance = TDEGlobal::locale(); TDELocale *instance = TDEGlobal::locale();
if (instance) if (instance)
return instance->translate(text); return instance->translate(text);
return TQString::fromUtf8(text); return TQString::fromUtf8(text);
@ -1984,7 +1984,7 @@ TQString i18n(const char* text)
TQString i18n(const char* index, const char *text) TQString i18n(const char* index, const char *text)
{ {
register TDELocale *instance = TDEGlobal::locale(); TDELocale *instance = TDEGlobal::locale();
if (instance) if (instance)
return instance->translate(index, text); return instance->translate(index, text);
return TQString::fromUtf8(text); return TQString::fromUtf8(text);
@ -1992,7 +1992,7 @@ TQString i18n(const char* index, const char *text)
TQString i18n(const char* singular, const char* plural, unsigned long n) TQString i18n(const char* singular, const char* plural, unsigned long n)
{ {
register TDELocale *instance = TDEGlobal::locale(); TDELocale *instance = TDEGlobal::locale();
if (instance) if (instance)
return instance->translate(singular, plural, n); return instance->translate(singular, plural, n);
if (n == 1) if (n == 1)

12
tdecore/tdesycocadict.cpp
Unescape View File

@ -182,7 +182,7 @@ uint
KSycocaDict::hashKey( const TQString &key) KSycocaDict::hashKey( const TQString &key)
{ {
int l = key.length(); int l = key.length();
register uint h = 0; uint h = 0;
for(uint i = 0; i < mHashList.count(); i++) for(uint i = 0; i < mHashList.count(); i++)
{ {
@ -217,10 +217,10 @@ calcDiversity(KSycocaDictStringList *d, int pos, int sz)
pos = -pos-1; pos = -pos-1;
for(string_entry *entry=d->first(); entry; entry = d->next()) for(string_entry *entry=d->first(); entry; entry = d->next())
{ {
register int l = entry->length; int l = entry->length;
if (pos < l && pos != 0) if (pos < l && pos != 0)
{ {
register uint hash = ((entry->hash * 13) + (entry->key[l-pos].cell() % 29)) & 0x3ffffff; uint hash = ((entry->hash * 13) + (entry->key[l-pos].cell() % 29)) & 0x3ffffff;
matrix[ hash % usz ] = true; matrix[ hash % usz ] = true;
} }
} }
@ -232,7 +232,7 @@ calcDiversity(KSycocaDictStringList *d, int pos, int sz)
{ {
if (pos < entry->length) if (pos < entry->length)
{ {
register uint hash = ((entry->hash * 13) + (entry->key[pos].cell() % 29)) & 0x3ffffff; uint hash = ((entry->hash * 13) + (entry->key[pos].cell() % 29)) & 0x3ffffff;
matrix[ hash % usz ] = true; matrix[ hash % usz ] = true;
} }
} }
@ -257,7 +257,7 @@ addDiversity(KSycocaDictStringList *d, int pos)
pos = -pos-1; pos = -pos-1;
for(string_entry *entry=d->first(); entry; entry = d->next()) for(string_entry *entry=d->first(); entry; entry = d->next())
{ {
register int l = entry->length; int l = entry->length;
if (pos < l) if (pos < l)
entry->hash = ((entry->hash * 13) + (entry->key[l-pos].cell() % 29)) & 0x3fffffff; entry->hash = ((entry->hash * 13) + (entry->key[l-pos].cell() % 29)) & 0x3fffffff;
} }
@ -306,7 +306,7 @@ KSycocaDict::save(TQDataStream &str)
// use "almost prime" number for sz (to calculate diversity) and later // use "almost prime" number for sz (to calculate diversity) and later
// for the table size of big tables // for the table size of big tables
// int sz = d->count()*5-1; // int sz = d->count()*5-1;
register unsigned int sz = count()*4 + 1; unsigned int sz = count()*4 + 1;
while(!(((sz % 3) && (sz % 5) && (sz % 7) && (sz % 11) && (sz % 13)))) sz+=2; while(!(((sz % 3) && (sz % 5) && (sz % 7) && (sz % 11) && (sz % 13)))) sz+=2;
int maxDiv = 0; int maxDiv = 0;

104
tdefx/kimageeffect.cpp
Unescape View File

@ -136,7 +136,7 @@ TQImage KImageEffect::gradient(const TQSize &size, const TQColor &ca,
return image; return image;
} }
register int x, y; int x, y;
rDiff = (rcb = cb.red()) - (rca = ca.red()); rDiff = (rcb = cb.red()) - (rca = ca.red());
gDiff = (gcb = cb.green()) - (gca = ca.green()); gDiff = (gcb = cb.green()) - (gca = ca.green());
@ -147,9 +147,9 @@ TQImage KImageEffect::gradient(const TQSize &size, const TQColor &ca,
uint *p; uint *p;
uint rgb; uint rgb;
register int rl = rca << 16; int rl = rca << 16;
register int gl = gca << 16; int gl = gca << 16;
register int bl = bca << 16; int bl = bca << 16;
if( eff == VerticalGradient ) { if( eff == VerticalGradient ) {
@ -424,7 +424,7 @@ TQImage KImageEffect::unbalancedGradient(const TQSize &size, const TQColor &ca,
return image; return image;
} }
register int x, y; int x, y;
unsigned int *scanline; unsigned int *scanline;
rDiff = (rcb = cb.red()) - (rca = ca.red()); rDiff = (rcb = cb.red()) - (rca = ca.red());
@ -949,7 +949,7 @@ TQImage& KImageEffect::modulate(TQImage &image, TQImage &modImage, bool reverse,
TQColor clr; TQColor clr;
int mod=0; int mod=0;
unsigned int x1, x2, y1, y2; unsigned int x1, x2, y1, y2;
register int x, y; int x, y;
// for image, we handle only depth 32 // for image, we handle only depth 32
if (image.depth()<32) image = image.convertDepth(32); if (image.depth()<32) image = image.convertDepth(32);
@ -1280,12 +1280,12 @@ TQImage& KImageEffect::blend(const TQColor& clr, TQImage& dst, float opacity)
clr.rgb(&rcol, &gcol, &bcol); clr.rgb(&rcol, &gcol, &bcol);
#ifdef WORDS_BIGENDIAN // ARGB (skip alpha) #ifdef WORDS_BIGENDIAN // ARGB (skip alpha)
register unsigned char *data = (unsigned char *)dst.bits() + 1; unsigned char *data = (unsigned char *)dst.bits() + 1;
#else // BGRA #else // BGRA
register unsigned char *data = (unsigned char *)dst.bits(); unsigned char *data = (unsigned char *)dst.bits();
#endif #endif
for (register int i=0; i<pixels; i++) for (int i=0; i<pixels; i++)
{ {
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
*data += (unsigned char)((rcol - *data) * opacity); *data += (unsigned char)((rcol - *data) * opacity);
@ -1513,14 +1513,14 @@ TQImage& KImageEffect::blend(TQImage& src, TQImage& dst, float opacity)
{ {
#ifdef WORDS_BIGENDIAN // ARGB (skip alpha) #ifdef WORDS_BIGENDIAN // ARGB (skip alpha)
register unsigned char *data1 = (unsigned char *)dst.bits() + 1; unsigned char *data1 = (unsigned char *)dst.bits() + 1;
register unsigned char *data2 = (unsigned char *)src.bits() + 1; unsigned char *data2 = (unsigned char *)src.bits() + 1;
#else // BGRA #else // BGRA
register unsigned char *data1 = (unsigned char *)dst.bits(); unsigned char *data1 = (unsigned char *)dst.bits();
register unsigned char *data2 = (unsigned char *)src.bits(); unsigned char *data2 = (unsigned char *)src.bits();
#endif #endif
for (register int i=0; i<pixels; i++) for (int i=0; i<pixels; i++)
{ {
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
*data1 += (unsigned char)((*(data2++) - *data1) * opacity); *data1 += (unsigned char)((*(data2++) - *data1) * opacity);
@ -1582,7 +1582,7 @@ TQImage& KImageEffect::blend(TQImage &image, float initial_intensity,
var = -var; var = -var;
} }
register int x, y; int x, y;
unsigned int *data = (unsigned int *)image.bits(); unsigned int *data = (unsigned int *)image.bits();
@ -1790,7 +1790,7 @@ TQImage& KImageEffect::blend(TQImage &image1, TQImage &image2,
unsigned int x1, x2, x3, y1, y2, y3; unsigned int x1, x2, x3, y1, y2, y3;
unsigned int a; unsigned int a;
register int x, y; int x, y;
// for image1 and image2, we only handle depth 32 // for image1 and image2, we only handle depth 32
if (image1.depth()<32) image1 = image1.convertDepth(32); if (image1.depth()<32) image1 = image1.convertDepth(32);
@ -1884,7 +1884,7 @@ TQImage& KImageEffect::hash(TQImage &image, Lighting lite, unsigned int spacing)
return image; return image;
} }
register int x, y; int x, y;
unsigned int *data = (unsigned int *)image.bits(); unsigned int *data = (unsigned int *)image.bits();
unsigned int ind; unsigned int ind;
@ -2142,9 +2142,9 @@ TQImage& KImageEffect::toGray(TQImage &img, bool fast)
if(fast){ if(fast){
if (img.depth() == 32) { if (img.depth() == 32) {
register uchar * r(img.bits()); uchar * r(img.bits());
register uchar * g(img.bits() + 1); uchar * g(img.bits() + 1);
register uchar * b(img.bits() + 2); uchar * b(img.bits() + 2);
uchar * end(img.bits() + img.numBytes()); uchar * end(img.bits() + img.numBytes());
@ -2161,11 +2161,11 @@ TQImage& KImageEffect::toGray(TQImage &img, bool fast)
{ {
for (int i = 0; i < img.numColors(); i++) for (int i = 0; i < img.numColors(); i++)
{ {
register uint r = tqRed(img.color(i)); uint r = tqRed(img.color(i));
register uint g = tqGreen(img.color(i)); uint g = tqGreen(img.color(i));
register uint b = tqBlue(img.color(i)); uint b = tqBlue(img.color(i));
register uint gray = (((r + g) >> 1) + b) >> 1; uint gray = (((r + g) >> 1) + b) >> 1;
img.setColor(i, tqRgba(gray, gray, gray, tqAlpha(img.color(i)))); img.setColor(i, tqRgba(gray, gray, gray, tqAlpha(img.color(i))));
} }
} }
@ -2408,10 +2408,10 @@ bool KImageEffect::blend(
output = lower.copy(); output = lower.copy();
register uchar *i, *o; uchar *i, *o;
register int a; int a;
register int col; int col;
register int w = upper.width(); int w = upper.width();
int row(upper.height() - 1); int row(upper.height() - 1);
do { do {
@ -2490,10 +2490,10 @@ bool KImageEffect::blend(
// output.setAlphaBuffer(true); // I should do some benchmarks to see if // output.setAlphaBuffer(true); // I should do some benchmarks to see if
// this is worth the effort // this is worth the effort
register TQRgb *i, *o, *b; TQRgb *i, *o, *b;
register int a; int a;
register int j,k; int j,k;
for (j=0; j<ch; j++) for (j=0; j<ch; j++)
{ {
b=reinterpret_cast<TQRgb *>(&const_cast<TQImage&>(lower).scanLine(y+j) [ (x+cw) << 2 ]); b=reinterpret_cast<TQRgb *>(&const_cast<TQImage&>(lower).scanLine(y+j) [ (x+cw) << 2 ]);
@ -2549,9 +2549,9 @@ bool KImageEffect::blendOnLower(
if ( cw <= 0 || ch <= 0 ) return true; if ( cw <= 0 || ch <= 0 ) return true;
} }
register uchar *i, *b; uchar *i, *b;
register int a; int a;
register int k; int k;
for (int j=0; j<ch; j++) for (int j=0; j<ch; j++)
{ {
@ -3102,7 +3102,7 @@ unsigned int KImageEffect::generateNoise(unsigned int pixel,
} }
case PoissonNoise: case PoissonNoise:
{ {
register int int
i; i;
for (i=0; alpha > exp(-SigmaPoisson*pixel); i++) for (i=0; alpha > exp(-SigmaPoisson*pixel); i++)
@ -3709,7 +3709,7 @@ void KImageEffect::normalize(TQImage &image)
TQ_INT64 number_pixels; TQ_INT64 number_pixels;
int x, y; int x, y;
unsigned int *p, *q; unsigned int *p, *q;
register long i; long i;
unsigned long threshold_intensity; unsigned long threshold_intensity;
unsigned char r, g, b, a; unsigned char r, g, b, a;
@ -4016,7 +4016,7 @@ TQImage KImageEffect::edge(TQImage &image, double radius)
{ {
double *kernel; double *kernel;
int width; int width;
register long i; long i;
TQImage dest; TQImage dest;
if(radius == 50.0){ if(radius == 50.0){
@ -4054,7 +4054,7 @@ TQImage KImageEffect::emboss(TQImage &image, double radius, double sigma)
{ {
double alpha, *kernel; double alpha, *kernel;
int j, width; int j, width;
register long i, u, v; long i, u, v;
TQImage dest; TQImage dest;
if(sigma == 0.0){ if(sigma == 0.0){
@ -4099,10 +4099,10 @@ void KImageEffect::blurScanLine(double *kernel, int width,
unsigned int *src, unsigned int *dest, unsigned int *src, unsigned int *dest,
int columns) int columns)
{ {
register double *p; double *p;
unsigned int *q; unsigned int *q;
register int x; int x;
register long i; long i;
double red, green, blue, alpha; double red, green, blue, alpha;
double scale = 0.0; double scale = 0.0;
@ -4239,7 +4239,7 @@ int KImageEffect::getBlurKernel(int width, double sigma, double **kernel)
{ {
#define KernelRank 3 #define KernelRank 3
double alpha, normalize; double alpha, normalize;
register long i; long i;
int bias; int bias;
assert(sigma != 0.0); assert(sigma != 0.0);
@ -4352,8 +4352,8 @@ bool KImageEffect::convolveImage(TQImage *image, TQImage *dest,
long width; long width;
double red, green, blue, alpha; double red, green, blue, alpha;
double normalize, *normal_kernel; double normalize, *normal_kernel;
register const double *k; const double *k;
register unsigned int *q; unsigned int *q;
int x, y, mx, my, sx, sy; int x, y, mx, my, sx, sy;
long i; long i;
int mcx, mcy; int mcx, mcy;
@ -4425,7 +4425,7 @@ int KImageEffect::getOptimalKernelWidth(double radius, double sigma)
{ {
double normalize, value; double normalize, value;
long width; long width;
register long u; long u;
assert(sigma != 0.0); assert(sigma != 0.0);
if(radius > 0.0) if(radius > 0.0)
@ -4453,7 +4453,7 @@ TQImage KImageEffect::sharpen(TQImage &image, double radius, double sigma)
{ {
double alpha, normalize, *kernel; double alpha, normalize, *kernel;
int width; int width;
register long i, u, v; long i, u, v;
TQImage dest; TQImage dest;
if(sigma == 0.0){ if(sigma == 0.0){
@ -4957,12 +4957,12 @@ TQImage KImageEffect::convertToPremultipliedAlpha(TQImage input) {
int w = alphaImage.width(); int w = alphaImage.width();
int h = alphaImage.height(); int h = alphaImage.height();
register int r; int r;
register int g; int g;
register int b; int b;
register int a; int a;
register float alpha_adjust; float alpha_adjust;
register TQRgb l; TQRgb l;
TQRgb *ls; TQRgb *ls;
for (int y = 0; y < h; ++y) { for (int y = 0; y < h; ++y) {
ls = (TQRgb *)alphaImage.scanLine( y ); ls = (TQRgb *)alphaImage.scanLine( y );

2
tdefx/kpixmap.cpp
Unescape View File

@ -34,7 +34,7 @@
// Based on Qt's image conversion functions // Based on Qt's image conversion functions
static bool kdither_32_to_8( const TQImage *src, TQImage *dst ) static bool kdither_32_to_8( const TQImage *src, TQImage *dst )
{ {
// register QRgb *p; // TQRgb *p;
uchar *b; uchar *b;
int y; int y;

8
tdefx/kpixmapeffect.cpp
Unescape View File

@ -30,15 +30,15 @@ KPixmap& KPixmapEffect::gradient(KPixmap &pixmap, const TQColor &ca,
int rDiff, gDiff, bDiff; int rDiff, gDiff, bDiff;
int rca, gca, bca /*, rcb, gcb, bcb*/; int rca, gca, bca /*, rcb, gcb, bcb*/;
register int x, y; int x, y;
rDiff = (/*rcb = */ cb.red()) - (rca = ca.red()); rDiff = (/*rcb = */ cb.red()) - (rca = ca.red());
gDiff = (/*gcb = */ cb.green()) - (gca = ca.green()); gDiff = (/*gcb = */ cb.green()) - (gca = ca.green());
bDiff = (/*bcb = */ cb.blue()) - (bca = ca.blue()); bDiff = (/*bcb = */ cb.blue()) - (bca = ca.blue());
register int rl = rca << 16; int rl = rca << 16;
register int gl = gca << 16; int gl = gca << 16;
register int bl = bca << 16; int bl = bca << 16;
int rcdelta = ((1<<16) / (eff == VerticalGradient ? pixmap.height() : pixmap.width())) * rDiff; int rcdelta = ((1<<16) / (eff == VerticalGradient ? pixmap.height() : pixmap.width())) * rDiff;
int gcdelta = ((1<<16) / (eff == VerticalGradient ? pixmap.height() : pixmap.width())) * gDiff; int gcdelta = ((1<<16) / (eff == VerticalGradient ? pixmap.height() : pixmap.width())) * gDiff;

20
tdefx/tdestyle.cpp
Unescape View File

@ -2031,11 +2031,11 @@ void TransparencyHandler::rightShadow(TQImage& dst)
// blend top-right corner. // blend top-right corner.
int pixels = dst.width() * dst.height(); int pixels = dst.width() * dst.height();
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
register unsigned char* data = dst.bits() + 1; // Skip alpha unsigned char* data = dst.bits() + 1; // Skip alpha
#else #else
register unsigned char* data = dst.bits(); // Skip alpha unsigned char* data = dst.bits(); // Skip alpha
#endif #endif
for(register int i = 0; i < 16; i++) { for(int i = 0; i < 16; i++) {
if (have_composite) { if (have_composite) {
data++; data++;
data++; data++;
@ -2051,8 +2051,8 @@ void TransparencyHandler::rightShadow(TQImage& dst)
} }
pixels -= 32; // tint right strip without rounded edges. pixels -= 32; // tint right strip without rounded edges.
register int c = 0; int c = 0;
for(register int i = 0; i < pixels; i++) { for(int i = 0; i < pixels; i++) {
if (have_composite) { if (have_composite) {
data++; data++;
data++; data++;
@ -2070,7 +2070,7 @@ void TransparencyHandler::rightShadow(TQImage& dst)
} }
// tint bottom edge // tint bottom edge
for(register int i = 0; i < 16; i++) { for(int i = 0; i < 16; i++) {
if (have_composite) { if (have_composite) {
data++; data++;
data++; data++;
@ -2099,15 +2099,15 @@ void TransparencyHandler::bottomShadow(TQImage& dst)
double* corner = const_cast<double*>(bottom_left_corner); double* corner = const_cast<double*>(bottom_left_corner);
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
register unsigned char* data = dst.bits() + 1; // Skip alpha unsigned char* data = dst.bits() + 1; // Skip alpha
#else #else
register unsigned char* data = dst.bits(); // Skip alpha unsigned char* data = dst.bits(); // Skip alpha
#endif #endif
for(int y = 0; y < 4; y++) for(int y = 0; y < 4; y++)
{ {
// Bottom-left Corner // Bottom-left Corner
for(register int x = 0; x < 4; x++) { for(int x = 0; x < 4; x++) {
if (have_composite) { if (have_composite) {
data++; data++;
data++; data++;
@ -2124,7 +2124,7 @@ void TransparencyHandler::bottomShadow(TQImage& dst)
} }
// Scanline // Scanline
for(register int x = 0; x < width; x++) { for(int x = 0; x < width; x++) {
if (have_composite) { if (have_composite) {
data++; data++;
data++; data++;

14
tdehtml/css/cssproperties.c
Unescape View File

@ -39,7 +39,7 @@ struct props {
int id; int id;
}; };
static const struct props * findProp (register const char *str, register unsigned int len); static const struct props * findProp (register const char *str, unsigned int len);
/* maximum key range = 469, duplicates = 0 */ /* maximum key range = 469, duplicates = 0 */
#ifdef __GNUC__ #ifdef __GNUC__
@ -50,7 +50,7 @@ inline
#endif #endif
#endif #endif
static unsigned int static unsigned int
hash_prop (register const char *str, register unsigned int len) hash_prop (register const char *str, unsigned int len)
{ {
static const unsigned short asso_values[] = static const unsigned short asso_values[] =
{ {
@ -81,7 +81,7 @@ hash_prop (register const char *str, register unsigned int len)
472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
472, 472, 472, 472, 472, 472 472, 472, 472, 472, 472, 472
}; };
register int hval = len; int hval = len;
switch (hval) switch (hval)
{ {
@ -189,7 +189,7 @@ hash_prop (register const char *str, register unsigned int len)
__inline __inline
#endif #endif
const struct props * const struct props *
findProp (register const char *str, register unsigned int len) findProp (register const char *str, unsigned int len)
{ {
enum enum
{ {
@ -516,15 +516,15 @@ findProp (register const char *str, register unsigned int len)
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
{ {
register int key = hash_prop (str, len); int key = hash_prop (str, len);
if (key <= MAX_HASH_VALUE && key >= 0) if (key <= MAX_HASH_VALUE && key >= 0)
{ {
register int index = lookup[key]; int index = lookup[key];
if (index >= 0) if (index >= 0)
{ {
register const char *s = wordlist_prop[index].name; const char *s = wordlist_prop[index].name;
if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
return &wordlist_prop[index]; return &wordlist_prop[index];

14
tdehtml/css/cssvalues.c
Unescape View File

@ -39,7 +39,7 @@ struct css_value {
int id; int id;
}; };
static const css_value* findValue (register const char *str, register unsigned int len); static const css_value* findValue (register const char *str, unsigned int len);
/* maximum key range = 2876, duplicates = 0 */ /* maximum key range = 2876, duplicates = 0 */
#ifdef __GNUC__ #ifdef __GNUC__
@ -50,7 +50,7 @@ inline
#endif #endif
#endif #endif
static unsigned int static unsigned int
hash_val (register const char *str, register unsigned int len) hash_val (register const char *str, unsigned int len)
{ {
static const unsigned short asso_values[] = static const unsigned short asso_values[] =
{ {
@ -81,7 +81,7 @@ hash_val (register const char *str, register unsigned int len)
2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
2876, 2876, 2876, 2876, 2876, 2876, 2876 2876, 2876, 2876, 2876, 2876, 2876, 2876
}; };
register int hval = 0; int hval = 0;
switch (len) switch (len)
{ {
@ -177,7 +177,7 @@ hash_val (register const char *str, register unsigned int len)
__inline __inline
#endif #endif
const struct css_value * const struct css_value *
findValue (register const char *str, register unsigned int len) findValue (register const char *str, unsigned int len)
{ {
enum enum
{ {
@ -1036,15 +1036,15 @@ findValue (register const char *str, register unsigned int len)
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
{ {
register int key = hash_val (str, len); int key = hash_val (str, len);
if (key <= MAX_HASH_VALUE && key >= 0) if (key <= MAX_HASH_VALUE && key >= 0)
{ {
register int index = lookup[key]; int index = lookup[key];
if (index >= 0) if (index >= 0)
{ {
register const char *s = wordlist_value[index].name; const char *s = wordlist_value[index].name;
if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
return &wordlist_value[index]; return &wordlist_value[index];

2
tdehtml/css/makeprop
Unescape View File

@ -23,7 +23,7 @@
# #
grep "^[^\#]" cssproperties.in > cssproperties.strip grep "^[^\#]" cssproperties.in > cssproperties.strip
echo -e '%{\n/* This file is automatically generated from cssproperties.in by makeprop, do not edit */\n/* Copyright 1999 W. Bastian */\n#include "cssproperties.h"\n%}\nstruct props {\n const char *name;\n int id;\n};\n\nstatic const struct props * findProp (register const char *str, register unsigned int len);\n\n%%' > cssproperties.gperf echo -e '%{\n/* This file is automatically generated from cssproperties.in by makeprop, do not edit */\n/* Copyright 1999 W. Bastian */\n#include "cssproperties.h"\n%}\nstruct props {\n const char *name;\n int id;\n};\n\nstatic const struct props * findProp (register const char *str, unsigned int len);\n\n%%' > cssproperties.gperf
cat cssproperties.strip | awk '{ do { prop = $0; gsub("-", "_"); print prop ", CSS_PROP_" toupper($0) } while (getline) }' >> cssproperties.gperf cat cssproperties.strip | awk '{ do { prop = $0; gsub("-", "_"); print prop ", CSS_PROP_" toupper($0) } while (getline) }' >> cssproperties.gperf
echo '%%' >> cssproperties.gperf echo '%%' >> cssproperties.gperf
echo -e '/* This file is automatically generated from cssproperties.in by makeprop, do not edit */\n/* Copyright 1998 W. Bastian */\n\n#ifndef CSSPROPERTIES_H\n#define CSSPROPERTIES_H\n\nDOM::DOMString getPropertyName(unsigned short id) KDE_NO_EXPORT;\n' > cssproperties.h echo -e '/* This file is automatically generated from cssproperties.in by makeprop, do not edit */\n/* Copyright 1998 W. Bastian */\n\n#ifndef CSSPROPERTIES_H\n#define CSSPROPERTIES_H\n\nDOM::DOMString getPropertyName(unsigned short id) KDE_NO_EXPORT;\n' > cssproperties.h

2
tdehtml/css/makevalues
Unescape View File

@ -24,7 +24,7 @@
# #
grep "^[^\#]" cssvalues.in > cssvalues.strip grep "^[^\#]" cssvalues.in > cssvalues.strip
echo -e '%{\n/* This file is automatically generated from cssvalues.in by makevalues, do not edit */\n/* Copyright 1999 W. Bastian */\n#include "cssvalues.h"\n%}\nstruct css_value {\n const char *name;\n int id;\n};\n\nstatic const css_value* findValue (register const char *str, register unsigned int len);\n\n%%' > cssvalues.gperf echo -e '%{\n/* This file is automatically generated from cssvalues.in by makevalues, do not edit */\n/* Copyright 1999 W. Bastian */\n#include "cssvalues.h"\n%}\nstruct css_value {\n const char *name;\n int id;\n};\n\nstatic const css_value* findValue (register const char *str, unsigned int len);\n\n%%' > cssvalues.gperf
cat cssvalues.strip | awk '{ do { prop = $0; gsub("-", "_"); print prop ", CSS_VAL_" toupper($0) } while (getline) }' >> cssvalues.gperf cat cssvalues.strip | awk '{ do { prop = $0; gsub("-", "_"); print prop ", CSS_VAL_" toupper($0) } while (getline) }' >> cssvalues.gperf
echo '%%' >> cssvalues.gperf echo '%%' >> cssvalues.gperf
echo -e '/* This file is automatically generated from cssvalues.in by echo -e '/* This file is automatically generated from cssvalues.in by

16
tdehtml/css/parser.cpp
Unescape View File

@ -385,7 +385,7 @@ union yyalloc
# define YYCOPY(To, From, Count) \ # define YYCOPY(To, From, Count) \
do \ do \
{ \ { \
register YYSIZE_T yyi; \ YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \ for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \ (To)[yyi] = (From)[yyi]; \
} \ } \
@ -1122,7 +1122,7 @@ yystrlen (yystr)
const char *yystr; const char *yystr;
# endif # endif
{ {
register const char *yys = yystr; const char *yys = yystr;
while (*yys++ != '\0') while (*yys++ != '\0')
continue; continue;
@ -1147,8 +1147,8 @@ yystpcpy (yydest, yysrc)
const char *yysrc; const char *yysrc;
# endif # endif
{ {
register char *yyd = yydest; char *yyd = yydest;
register const char *yys = yysrc; const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0') while ((*yyd++ = *yys++) != '\0')
continue; continue;
@ -1338,8 +1338,8 @@ YYSTYPE yylval;
/* Number of syntax errors so far. */ /* Number of syntax errors so far. */
int yynerrs; int yynerrs;
register int yystate; int yystate;
register int yyn; int yyn;
int yyresult; int yyresult;
/* Number of tokens to shift before error messages enabled. */ /* Number of tokens to shift before error messages enabled. */
int yyerrstatus; int yyerrstatus;
@ -1357,12 +1357,12 @@ int yynerrs;
/* The state stack. */ /* The state stack. */
short int yyssa[YYINITDEPTH]; short int yyssa[YYINITDEPTH];
short int *yyss = yyssa; short int *yyss = yyssa;
register short int *yyssp; short int *yyssp;
/* The semantic value stack. */ /* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa; YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp; YYSTYPE *yyvsp;

8
tdehtml/css/tokenizer.cpp
Unescape View File

@ -592,9 +592,9 @@ static yyconst short int yy_chk[1695] =
YY_DECL YY_DECL
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register unsigned short *yy_cp, *yy_bp; unsigned short *yy_cp, *yy_bp;
register int yy_act; int yy_act;
#line 25 "tokenizer.flex" #line 25 "tokenizer.flex"
@ -617,7 +617,7 @@ YY_DECL
yy_match: yy_match:
do do
{ {
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;

10
tdehtml/html/doctypes.cpp
Unescape View File

@ -51,7 +51,7 @@ inline
#endif #endif
#endif #endif
static unsigned int static unsigned int
hash (register const char *str, register unsigned int len) hash (register const char *str, unsigned int len)
{ {
static const unsigned short asso_values[] = static const unsigned short asso_values[] =
{ {
@ -82,7 +82,7 @@ hash (register const char *str, register unsigned int len)
731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731, 731,
731, 731, 731, 731, 731, 731 731, 731, 731, 731, 731, 731
}; };
register int hval = len; int hval = len;
switch (hval) switch (hval)
{ {
@ -334,7 +334,7 @@ hash (register const char *str, register unsigned int len)
__inline __inline
#endif #endif
const struct PubIDInfo * const struct PubIDInfo *
findDoctypeEntry (register const char *str, register unsigned int len) findDoctypeEntry (register const char *str, unsigned int len)
{ {
enum enum
{ {
@ -1160,11 +1160,11 @@ findDoctypeEntry (register const char *str, register unsigned int len)
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
{ {
register int key = hash (str, len); int key = hash (str, len);
if (key <= MAX_HASH_VALUE && key >= 0) if (key <= MAX_HASH_VALUE && key >= 0)
{ {
register const char *s = wordlist[key].name; const char *s = wordlist[key].name;
if (*str == *s && !strcmp (str + 1, s + 1)) if (*str == *s && !strcmp (str + 1, s + 1))
return &wordlist[key]; return &wordlist[key];

12
tdehtml/misc/htmlattrs.c
Unescape View File

@ -57,7 +57,7 @@ inline
#endif #endif
#endif #endif
static unsigned int static unsigned int
hash_attr (register const char *str, register unsigned int len) hash_attr (register const char *str, unsigned int len)
{ {
static const unsigned short asso_values[] = static const unsigned short asso_values[] =
{ {
@ -88,7 +88,7 @@ hash_attr (register const char *str, register unsigned int len)
577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
577, 577, 577, 577, 577, 577, 577 577, 577, 577, 577, 577, 577, 577
}; };
register int hval = len; int hval = len;
switch (hval) switch (hval)
{ {
@ -831,19 +831,19 @@ inline
#endif #endif
#endif #endif
const struct attrs * const struct attrs *
findAttr (register const char *str, register unsigned int len) findAttr (register const char *str, unsigned int len)
{ {
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
{ {
register int key = hash_attr (str, len); int key = hash_attr (str, len);
if (key <= MAX_HASH_VALUE && key >= 0) if (key <= MAX_HASH_VALUE && key >= 0)
{ {
register int index = lookup[key]; int index = lookup[key];
if (index >= 0) if (index >= 0)
{ {
register const char *s = wordlist_attr[index].name + spool_attr; const char *s = wordlist_attr[index].name + spool_attr;
if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0') if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
return &wordlist_attr[index]; return &wordlist_attr[index];

12
tdehtml/misc/htmltags.c
Unescape View File

@ -48,7 +48,7 @@ inline
#endif #endif
#endif #endif
static unsigned int static unsigned int
hash_tag (register const char *str, register unsigned int len) hash_tag (register const char *str, unsigned int len)
{ {
static const unsigned short asso_values[] = static const unsigned short asso_values[] =
{ {
@ -79,7 +79,7 @@ hash_tag (register const char *str, register unsigned int len)
346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346, 346,
346, 346, 346, 346, 346, 346, 346 346, 346, 346, 346, 346, 346, 346
}; };
register int hval = len; int hval = len;
switch (hval) switch (hval)
{ {
@ -338,7 +338,7 @@ static const struct spool_Tag_t spool_Tag_contents =
__inline __inline
#endif #endif
const struct tags * const struct tags *
findTag (register const char *str, register unsigned int len) findTag (register const char *str, unsigned int len)
{ {
enum enum
{ {
@ -615,17 +615,17 @@ findTag (register const char *str, register unsigned int len)
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
{ {
register int key = hash_tag (str, len); int key = hash_tag (str, len);
if (key <= MAX_HASH_VALUE && key >= 0) if (key <= MAX_HASH_VALUE && key >= 0)
{ {
register int index = lookup[key]; int index = lookup[key];
if (index >= 0) if (index >= 0)
{ {
if (len == lengthtable[index]) if (len == lengthtable[index])
{ {
register const char *s = wordlist_tag[index].name + spool_Tag; const char *s = wordlist_tag[index].name + spool_Tag;
if (*str == *s && !memcmp (str + 1, s + 1, len - 1)) if (*str == *s && !memcmp (str + 1, s + 1, len - 1))
return &wordlist_tag[index]; return &wordlist_tag[index];

6
tdeinit/setproctitle.cpp
Unescape View File

@ -136,7 +136,7 @@ char *LastArgv = NULL; /* end of argv */
void void
tdeinit_initsetproctitle(int argc, char **argv, char **envp) tdeinit_initsetproctitle(int argc, char **argv, char **envp)
{ {
register int i, envpsize = 0; int i, envpsize = 0;
#if !defined(HAVE_NSGETENVIRON) || !defined(HAVE_CRT_EXTERNS_H) #if !defined(HAVE_NSGETENVIRON) || !defined(HAVE_CRT_EXTERNS_H)
extern char **environ; extern char **environ;
#endif #endif
@ -199,8 +199,8 @@ static void
setproctitle(const char *fmt, ...) setproctitle(const char *fmt, ...)
{ {
# if SPT_TYPE != SPT_NONE # if SPT_TYPE != SPT_NONE
register char *p; char *p;
register int i; int i;
SETPROC_STATIC char buf[SPT_BUFSIZE]; SETPROC_STATIC char buf[SPT_BUFSIZE];
va_list ap; va_list ap;
# if SPT_TYPE == SPT_PSTAT # if SPT_TYPE == SPT_PSTAT

42
tdeio/tdeio/lex.c
Unescape View File

@ -590,9 +590,9 @@ YY_MALLOC_DECL
YY_DECL YY_DECL
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp, *yy_bp; char *yy_cp, *yy_bp;
register int yy_act; int yy_act;
#line 21 "lex.l" #line 21 "lex.l"
@ -639,7 +639,7 @@ YY_DECL
yy_match: yy_match:
do do
{ {
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -949,9 +949,9 @@ case YY_STATE_EOF(INITIAL):
static int yy_get_next_buffer() static int yy_get_next_buffer()
{ {
register char *dest = yy_current_buffer->yy_ch_buf; char *dest = yy_current_buffer->yy_ch_buf;
register char *source = yytext_ptr; char *source = yytext_ptr;
register int number_to_move, i; int number_to_move, i;
int ret_val; int ret_val;
if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
@ -1081,14 +1081,14 @@ static int yy_get_next_buffer()
static yy_state_type yy_get_previous_state() static yy_state_type yy_get_previous_state()
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp; char *yy_cp;
yy_current_state = yy_start; yy_current_state = yy_start;
for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
{ {
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -1120,10 +1120,10 @@ static yy_state_type yy_try_NUL_trans( yy_current_state )
yy_state_type yy_current_state; yy_state_type yy_current_state;
#endif #endif
{ {
register int yy_is_jam; int yy_is_jam;
register char *yy_cp = yy_c_buf_p; char *yy_cp = yy_c_buf_p;
register YY_CHAR yy_c = 1; YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -1144,14 +1144,14 @@ yy_state_type yy_current_state;
#ifndef YY_NO_UNPUT #ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS #ifdef YY_USE_PROTOS
static void yyunput( int c, register char *yy_bp ) static void yyunput( int c, char *yy_bp )
#else #else
static void yyunput( c, yy_bp ) static void yyunput( c, yy_bp )
int c; int c;
register char *yy_bp; char *yy_bp;
#endif #endif
{ {
register char *yy_cp = yy_c_buf_p; char *yy_cp = yy_c_buf_p;
/* undo effects of setting up yytext */ /* undo effects of setting up yytext */
*yy_cp = yy_hold_char; *yy_cp = yy_hold_char;
@ -1159,10 +1159,10 @@ register char *yy_bp;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
{ /* need to shift things up to make room */ { /* need to shift things up to make room */
/* +2 for EOB chars. */ /* +2 for EOB chars. */
register int number_to_move = yy_n_chars + 2; int number_to_move = yy_n_chars + 2;
register char *dest = &yy_current_buffer->yy_ch_buf[ char *dest = &yy_current_buffer->yy_ch_buf[
yy_current_buffer->yy_buf_size + 2]; yy_current_buffer->yy_buf_size + 2];
register char *source = char *source =
&yy_current_buffer->yy_ch_buf[number_to_move]; &yy_current_buffer->yy_ch_buf[number_to_move];
while ( source > yy_current_buffer->yy_ch_buf ) while ( source > yy_current_buffer->yy_ch_buf )
@ -1618,7 +1618,7 @@ yyconst char *s2;
int n; int n;
#endif #endif
{ {
register int i; int i;
for ( i = 0; i < n; ++i ) for ( i = 0; i < n; ++i )
s1[i] = s2[i]; s1[i] = s2[i];
} }
@ -1632,7 +1632,7 @@ static int yy_flex_strlen( s )
yyconst char *s; yyconst char *s;
#endif #endif
{ {
register int n; int n;
for ( n = 0; s[n]; ++n ) for ( n = 0; s[n]; ++n )
; ;

16
tdeio/tdeio/yacc.c
Unescape View File

@ -219,7 +219,7 @@ union yyalloc
# define YYCOPY(To, From, Count) \ # define YYCOPY(To, From, Count) \
do \ do \
{ \ { \
register YYSIZE_T yyi; \ YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \ for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \ (To)[yyi] = (From)[yyi]; \
} \ } \
@ -694,7 +694,7 @@ yystrlen (yystr)
const char *yystr; const char *yystr;
# endif # endif
{ {
register const char *yys = yystr; const char *yys = yystr;
while (*yys++ != '\0') while (*yys++ != '\0')
continue; continue;
@ -719,8 +719,8 @@ yystpcpy (yydest, yysrc)
const char *yysrc; const char *yysrc;
# endif # endif
{ {
register char *yyd = yydest; char *yyd = yydest;
register const char *yys = yysrc; const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0') while ((*yyd++ = *yys++) != '\0')
continue; continue;
@ -855,8 +855,8 @@ yyparse ()
#endif #endif
{ {
register int yystate; int yystate;
register int yyn; int yyn;
int yyresult; int yyresult;
/* Number of tokens to shift before error messages enabled. */ /* Number of tokens to shift before error messages enabled. */
int yyerrstatus; int yyerrstatus;
@ -874,12 +874,12 @@ yyparse ()
/* The state stack. */ /* The state stack. */
short int yyssa[YYINITDEPTH]; short int yyssa[YYINITDEPTH];
short int *yyss = yyssa; short int *yyss = yyssa;
register short int *yyssp; short int *yyssp;
/* The semantic value stack. */ /* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa; YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp; YYSTYPE *yyvsp;

2
tdeioslave/iso/libisofs/bswap.h
Unescape View File

@ -39,7 +39,7 @@ inline static unsigned int ByteSwap32(unsigned int x)
inline static unsigned long long int ByteSwap64(unsigned long long int x) inline static unsigned long long int ByteSwap64(unsigned long long int x)
{ {
register union { __extension__ unsigned long long int __ll; union { __extension__ unsigned long long int __ll;
unsigned int __l[2]; } __x; unsigned int __l[2]; } __x;
asm("xchgl %0,%1": asm("xchgl %0,%1":
"=r"(__x.__l[0]),"=r"(__x.__l[1]): "=r"(__x.__l[0]),"=r"(__x.__l[1]):

4
tdeioslave/iso/libisofs/isofs.c
Unescape View File

@ -164,7 +164,7 @@ int ReadBootTable(readfunc *read,long long sector, boot_head *head, void *udata)
int i,end=0; int i,end=0;
unsigned short sum; unsigned short sum;
boot_entry *defcur=NULL,*deflast=NULL; boot_entry *defcur=NULL,*deflast=NULL;
register struct validation_entry *ventry=NULL; struct validation_entry *ventry=NULL;
head->sections=NULL; head->sections=NULL;
head->defentry=NULL; head->defentry=NULL;
@ -538,7 +538,7 @@ int ProcessDir(readfunc *read,int extent,int size,dircallback *callback,void *ud
*/ */
int JolietLevel(struct iso_volume_descriptor *ivd) { int JolietLevel(struct iso_volume_descriptor *ivd) {
int ret=0; int ret=0;
register struct iso_supplementary_descriptor *isd; struct iso_supplementary_descriptor *isd;
isd = (struct iso_supplementary_descriptor *) ivd; isd = (struct iso_supplementary_descriptor *) ivd;

20
tdeprint/fooparser.cpp
Unescape View File

@ -369,9 +369,9 @@ __yy_memcpy (to, from, count)
char *from; char *from;
unsigned int count; unsigned int count;
{ {
register char *f = from; char *f = from;
register char *t = to; char *t = to;
register int i = count; int i = count;
while (i-- > 0) while (i-- > 0)
*t++ = *f++; *t++ = *f++;
@ -384,9 +384,9 @@ __yy_memcpy (to, from, count)
static void static void
__yy_memcpy (char *to, char *from, unsigned int count) __yy_memcpy (char *to, char *from, unsigned int count)
{ {
register char *t = to; char *t = to;
register char *f = from; char *f = from;
register int i = count; int i = count;
while (i-- > 0) while (i-- > 0)
*t++ = *f++; *t++ = *f++;
@ -429,10 +429,10 @@ int
yyparse(YYPARSE_PARAM_ARG) yyparse(YYPARSE_PARAM_ARG)
YYPARSE_PARAM_DECL YYPARSE_PARAM_DECL
{ {
register int yystate; int yystate;
register int yyn; int yyn;
register short *yyssp; short *yyssp;
register YYSTYPE *yyvsp; YYSTYPE *yyvsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */ int yyerrstatus; /* number of tokens to shift before error messages enabled */
int yychar1 = 0; /* lookahead token as an internal (translated) token number */ int yychar1 = 0; /* lookahead token as an internal (translated) token number */

42
tdeprint/fooscanner.cpp
Unescape View File

@ -614,9 +614,9 @@ YY_MALLOC_DECL
YY_DECL YY_DECL
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp, *yy_bp; char *yy_cp, *yy_bp;
register int yy_act; int yy_act;
#line 47 "./fooscanner.l" #line 47 "./fooscanner.l"
@ -664,7 +664,7 @@ YY_DECL
yy_match: yy_match:
do do
{ {
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -954,9 +954,9 @@ case YY_STATE_EOF(INITIAL):
static int yy_get_next_buffer() static int yy_get_next_buffer()
{ {
register char *dest = yy_current_buffer->yy_ch_buf; char *dest = yy_current_buffer->yy_ch_buf;
register char *source = yytext_ptr; char *source = yytext_ptr;
register int number_to_move, i; int number_to_move, i;
int ret_val; int ret_val;
if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
@ -1086,15 +1086,15 @@ static int yy_get_next_buffer()
static yy_state_type yy_get_previous_state() static yy_state_type yy_get_previous_state()
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp; char *yy_cp;
yy_current_state = yy_start; yy_current_state = yy_start;
yy_current_state += YY_AT_BOL(); yy_current_state += YY_AT_BOL();
for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
{ {
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -1126,10 +1126,10 @@ static yy_state_type yy_try_NUL_trans( yy_current_state )
yy_state_type yy_current_state; yy_state_type yy_current_state;
#endif #endif
{ {
register int yy_is_jam; int yy_is_jam;
register char *yy_cp = yy_c_buf_p; char *yy_cp = yy_c_buf_p;
register YY_CHAR yy_c = 1; YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -1150,14 +1150,14 @@ yy_state_type yy_current_state;
#ifndef YY_NO_UNPUT #ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS #ifdef YY_USE_PROTOS
static void yyunput( int c, register char *yy_bp ) static void yyunput( int c, char *yy_bp )
#else #else
static void yyunput( c, yy_bp ) static void yyunput( c, yy_bp )
int c; int c;
register char *yy_bp; char *yy_bp;
#endif #endif
{ {
register char *yy_cp = yy_c_buf_p; char *yy_cp = yy_c_buf_p;
/* undo effects of setting up yytext */ /* undo effects of setting up yytext */
*yy_cp = yy_hold_char; *yy_cp = yy_hold_char;
@ -1165,10 +1165,10 @@ register char *yy_bp;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
{ /* need to shift things up to make room */ { /* need to shift things up to make room */
/* +2 for EOB chars. */ /* +2 for EOB chars. */
register int number_to_move = yy_n_chars + 2; int number_to_move = yy_n_chars + 2;
register char *dest = &yy_current_buffer->yy_ch_buf[ char *dest = &yy_current_buffer->yy_ch_buf[
yy_current_buffer->yy_buf_size + 2]; yy_current_buffer->yy_buf_size + 2];
register char *source = char *source =
&yy_current_buffer->yy_ch_buf[number_to_move]; &yy_current_buffer->yy_ch_buf[number_to_move];
while ( source > yy_current_buffer->yy_ch_buf ) while ( source > yy_current_buffer->yy_ch_buf )
@ -1625,7 +1625,7 @@ yyconst char *s2;
int n; int n;
#endif #endif
{ {
register int i; int i;
for ( i = 0; i < n; ++i ) for ( i = 0; i < n; ++i )
s1[i] = s2[i]; s1[i] = s2[i];
} }
@ -1639,7 +1639,7 @@ static int yy_flex_strlen( s )
yyconst char *s; yyconst char *s;
#endif #endif
{ {
register int n; int n;
for ( n = 0; s[n]; ++n ) for ( n = 0; s[n]; ++n )
; ;

16
tdeprint/ppdparser.cpp
Unescape View File

@ -225,7 +225,7 @@ union yyalloc
# define YYCOPY(To, From, Count) \ # define YYCOPY(To, From, Count) \
do \ do \
{ \ { \
register YYSIZE_T yyi; \ YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \ for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \ (To)[yyi] = (From)[yyi]; \
} \ } \
@ -704,7 +704,7 @@ yystrlen (yystr)
const char *yystr; const char *yystr;
# endif # endif
{ {
register const char *yys = yystr; const char *yys = yystr;
while (*yys++ != '\0') while (*yys++ != '\0')
continue; continue;
@ -729,8 +729,8 @@ yystpcpy (yydest, yysrc)
const char *yysrc; const char *yysrc;
# endif # endif
{ {
register char *yyd = yydest; char *yyd = yydest;
register const char *yys = yysrc; const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0') while ((*yyd++ = *yys++) != '\0')
continue; continue;
@ -860,8 +860,8 @@ yyparse ()
#endif #endif
{ {
register int yystate; int yystate;
register int yyn; int yyn;
int yyresult; int yyresult;
/* Number of tokens to shift before error messages enabled. */ /* Number of tokens to shift before error messages enabled. */
int yyerrstatus; int yyerrstatus;
@ -879,12 +879,12 @@ yyparse ()
/* The state stack. */ /* The state stack. */
short yyssa[YYINITDEPTH]; short yyssa[YYINITDEPTH];
short *yyss = yyssa; short *yyss = yyssa;
register short *yyssp; short *yyssp;
/* The semantic value stack. */ /* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa; YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp; YYSTYPE *yyvsp;

42
tdeprint/ppdscanner.cpp
Unescape View File

@ -719,9 +719,9 @@ YY_MALLOC_DECL
YY_DECL YY_DECL
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp, *yy_bp; char *yy_cp, *yy_bp;
register int yy_act; int yy_act;
#line 59 "./ppdscanner.l" #line 59 "./ppdscanner.l"
@ -771,7 +771,7 @@ YY_DECL
yy_match: yy_match:
do do
{ {
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -1155,9 +1155,9 @@ case YY_STATE_EOF(constr):
static int yy_get_next_buffer() static int yy_get_next_buffer()
{ {
register char *dest = yy_current_buffer->yy_ch_buf; char *dest = yy_current_buffer->yy_ch_buf;
register char *source = yytext_ptr; char *source = yytext_ptr;
register int number_to_move, i; int number_to_move, i;
int ret_val; int ret_val;
if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
@ -1287,14 +1287,14 @@ static int yy_get_next_buffer()
static yy_state_type yy_get_previous_state() static yy_state_type yy_get_previous_state()
{ {
register yy_state_type yy_current_state; yy_state_type yy_current_state;
register char *yy_cp; char *yy_cp;
yy_current_state = yy_start; yy_current_state = yy_start;
for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
{ {
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -1326,10 +1326,10 @@ static yy_state_type yy_try_NUL_trans( yy_current_state )
yy_state_type yy_current_state; yy_state_type yy_current_state;
#endif #endif
{ {
register int yy_is_jam; int yy_is_jam;
register char *yy_cp = yy_c_buf_p; char *yy_cp = yy_c_buf_p;
register YY_CHAR yy_c = 1; YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] ) if ( yy_accept[yy_current_state] )
{ {
yy_last_accepting_state = yy_current_state; yy_last_accepting_state = yy_current_state;
@ -1350,14 +1350,14 @@ yy_state_type yy_current_state;
#ifndef YY_NO_UNPUT #ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS #ifdef YY_USE_PROTOS
static void yyunput( int c, register char *yy_bp ) static void yyunput( int c, char *yy_bp )
#else #else
static void yyunput( c, yy_bp ) static void yyunput( c, yy_bp )
int c; int c;
register char *yy_bp; char *yy_bp;
#endif #endif
{ {
register char *yy_cp = yy_c_buf_p; char *yy_cp = yy_c_buf_p;
/* undo effects of setting up yytext */ /* undo effects of setting up yytext */
*yy_cp = yy_hold_char; *yy_cp = yy_hold_char;
@ -1365,10 +1365,10 @@ register char *yy_bp;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
{ /* need to shift things up to make room */ { /* need to shift things up to make room */
/* +2 for EOB chars. */ /* +2 for EOB chars. */
register int number_to_move = yy_n_chars + 2; int number_to_move = yy_n_chars + 2;
register char *dest = &yy_current_buffer->yy_ch_buf[ char *dest = &yy_current_buffer->yy_ch_buf[
yy_current_buffer->yy_buf_size + 2]; yy_current_buffer->yy_buf_size + 2];
register char *source = char *source =
&yy_current_buffer->yy_ch_buf[number_to_move]; &yy_current_buffer->yy_ch_buf[number_to_move];
while ( source > yy_current_buffer->yy_ch_buf ) while ( source > yy_current_buffer->yy_ch_buf )
@ -1824,7 +1824,7 @@ yyconst char *s2;
int n; int n;
#endif #endif
{ {
register int i; int i;
for ( i = 0; i < n; ++i ) for ( i = 0; i < n; ++i )
s1[i] = s2[i]; s1[i] = s2[i];
} }
@ -1838,7 +1838,7 @@ static int yy_flex_strlen( s )
yyconst char *s; yyconst char *s;
#endif #endif
{ {
register int n; int n;
for ( n = 0; s[n]; ++n ) for ( n = 0; s[n]; ++n )
; ;

2
tderandr/libtderandr.cc
Unescape View File

@ -45,7 +45,7 @@
// This routine is courtsey of an answer on "Stack Overflow" // This routine is courtsey of an answer on "Stack Overflow"
// It takes an LSB-first int and makes it an MSB-first int (or vice versa) // It takes an LSB-first int and makes it an MSB-first int (or vice versa)
unsigned int reverse_bits(register unsigned int x) unsigned int reverse_bits(unsigned int x)
{ {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1)); x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2)); x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));

40
tdespell2/plugins/ispell/correct.cpp
Unescape View File

@ -244,8 +244,8 @@ int compoundflag = COMPOUND_CONTROLLED;
int int
ISpellChecker::casecmp (char *a, char *b, int canonical) ISpellChecker::casecmp (char *a, char *b, int canonical)
{ {
register ichar_t * ap; ichar_t * ap;
register ichar_t * bp; ichar_t * bp;
ichar_t inta[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; ichar_t inta[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
ichar_t intb[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; ichar_t intb[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
@ -290,7 +290,7 @@ ISpellChecker::casecmp (char *a, char *b, int canonical)
void void
ISpellChecker::makepossibilities (ichar_t *word) ISpellChecker::makepossibilities (ichar_t *word)
{ {
register int i; int i;
for (i = 0; i < MAXPOSSIBLE; i++) for (i = 0; i < MAXPOSSIBLE; i++)
m_possibilities[i][0] = 0; m_possibilities[i][0] = 0;
@ -332,8 +332,8 @@ ISpellChecker::makepossibilities (ichar_t *word)
int int
ISpellChecker::insert (ichar_t *word) ISpellChecker::insert (ichar_t *word)
{ {
register int i; int i;
register char * realword; char * realword;
realword = ichartosstr (word, 0); realword = ichartosstr (word, 0);
for (i = 0; i < m_pcount; i++) for (i = 0; i < m_pcount; i++)
@ -381,9 +381,9 @@ ISpellChecker::wrongcapital (ichar_t *word)
void void
ISpellChecker::wrongletter (ichar_t *word) ISpellChecker::wrongletter (ichar_t *word)
{ {
register int i; int i;
register int j; int j;
register int n; int n;
ichar_t savechar; ichar_t savechar;
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN]; ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
@ -420,8 +420,8 @@ void
ISpellChecker::extraletter (ichar_t *word) ISpellChecker::extraletter (ichar_t *word)
{ {
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN]; ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p; ichar_t * p;
register ichar_t * r; ichar_t * r;
if (icharlen (word) < 2) if (icharlen (word) < 2)
return; return;
@ -445,9 +445,9 @@ void
ISpellChecker::missingletter (ichar_t *word) ISpellChecker::missingletter (ichar_t *word)
{ {
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN + 1]; ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN + 1];
register ichar_t * p; ichar_t * p;
register ichar_t * r; ichar_t * r;
register int i; int i;
icharcpy (newword + 1, word); icharcpy (newword + 1, word);
for (p = word, r = newword; *p != 0; ) for (p = word, r = newword; *p != 0; )
@ -489,7 +489,7 @@ void ISpellChecker::missingspace (ichar_t *word)
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN + 1]; ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN + 1];
int nfirsthalf; /* No. words saved in 1st half */ int nfirsthalf; /* No. words saved in 1st half */
int nsecondhalf; /* No. words saved in 2nd half */ int nsecondhalf; /* No. words saved in 2nd half */
register ichar_t * p; ichar_t * p;
ichar_t secondhalf[MAX_CAPS][INPUTWORDLEN + MAXAFFIXLEN]; ichar_t secondhalf[MAX_CAPS][INPUTWORDLEN + MAXAFFIXLEN];
int secondno; /* Index into second */ int secondno; /* Index into second */
@ -547,8 +547,8 @@ int
ISpellChecker::compoundgood (ichar_t *word, int pfxopts) ISpellChecker::compoundgood (ichar_t *word, int pfxopts)
{ {
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN]; ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p; ichar_t * p;
register ichar_t savech; ichar_t savech;
long secondcap; /* Capitalization of 2nd half */ long secondcap; /* Capitalization of 2nd half */
/* /*
@ -606,8 +606,8 @@ void
ISpellChecker::transposedletter (ichar_t *word) ISpellChecker::transposedletter (ichar_t *word)
{ {
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN]; ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p; ichar_t * p;
register ichar_t temp; ichar_t temp;
icharcpy (newword, word); icharcpy (newword, word);
for (p = newword; p[1] != 0; p++) for (p = newword; p[1] != 0; p++)
@ -752,12 +752,12 @@ ISpellChecker::save_root_cap (ichar_t *word, ichar_t *pattern,
int * nsaved) int * nsaved)
{ {
#ifndef NO_CAPITALIZATION_SUPPORT #ifndef NO_CAPITALIZATION_SUPPORT
register struct dent * dent; struct dent * dent;
#endif /* NO_CAPITALIZATION_SUPPORT */ #endif /* NO_CAPITALIZATION_SUPPORT */
int firstisupper; int firstisupper;
ichar_t newword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; ichar_t newword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
#ifndef NO_CAPITALIZATION_SUPPORT #ifndef NO_CAPITALIZATION_SUPPORT
register ichar_t * p; ichar_t * p;
int len; int len;
int i; int i;
int limit; int limit;

14
tdespell2/plugins/ispell/good.cpp
Unescape View File

@ -247,9 +247,9 @@ static int entryhasaffixes (struct dent *dent, struct success *hit)
*/ */
int ISpellChecker::cap_ok (ichar_t *word, struct success *hit, int len) int ISpellChecker::cap_ok (ichar_t *word, struct success *hit, int len)
{ {
register ichar_t * dword; ichar_t * dword;
register ichar_t * w; ichar_t * w;
register struct dent * dent; struct dent * dent;
ichar_t dentword[INPUTWORDLEN + MAXAFFIXLEN]; ichar_t dentword[INPUTWORDLEN + MAXAFFIXLEN];
int preadd; int preadd;
int prestrip; int prestrip;
@ -388,10 +388,10 @@ int ISpellChecker::good (ichar_t *w, int ignoreflagbits, int dummy, int pfxopts,
#endif #endif
{ {
ichar_t nword[INPUTWORDLEN + MAXAFFIXLEN]; ichar_t nword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p; ichar_t * p;
register ichar_t * q; ichar_t * q;
register int n; int n;
register struct dent * dp; struct dent * dp;
/* /*
** Make an uppercase copy of the word we are checking. ** Make an uppercase copy of the word we are checking.

4
tdespell2/plugins/ispell/hash.cpp
Unescape View File

@ -180,8 +180,8 @@
*/ */
int ISpellChecker::hash (ichar_t *s, int hashtblsize) int ISpellChecker::hash (ichar_t *s, int hashtblsize)
{ {
register long h = 0; long h = 0;
register int i; int i;
#ifdef ICHAR_IS_CHAR #ifdef ICHAR_IS_CHAR
for (i = 4; i-- && *s != 0; ) for (i = 4; i-- && *s != 0; )

20
tdespell2/plugins/ispell/lookup.cpp
Unescape View File

@ -266,13 +266,13 @@ int ISpellChecker::linit (char *hashname)
{ {
FILE* fpHash; FILE* fpHash;
register int i; int i;
register struct dent * dp; struct dent * dp;
struct flagent * entry; struct flagent * entry;
struct flagptr * ind; struct flagptr * ind;
int nextchar, x; int nextchar, x;
int viazero; int viazero;
register ichar_t * cp; ichar_t * cp;
if ((fpHash = fopen (hashname, "rb")) == NULL) if ((fpHash = fopen (hashname, "rb")) == NULL)
{ {
@ -571,7 +571,7 @@ int ISpellChecker::linit (char *hashname)
*/ */
void ISpellChecker::initckch (char *wchars) void ISpellChecker::initckch (char *wchars)
{ {
register ichar_t c; ichar_t c;
char num[4]; char num[4];
for (c = 0; c < static_cast<ichar_t>(SET_SIZE+ m_hashheader.nstrchars); ++c) for (c = 0; c < static_cast<ichar_t>(SET_SIZE+ m_hashheader.nstrchars); ++c)
@ -656,7 +656,7 @@ void ISpellChecker::initckch (char *wchars)
*/ */
void ISpellChecker::clearindex (struct flagptr *indexp) void ISpellChecker::clearindex (struct flagptr *indexp)
{ {
register int i; int i;
for (i = 0; i < SET_SIZE + m_hashheader.nstrchars; i++, indexp++) for (i = 0; i < SET_SIZE + m_hashheader.nstrchars; i++, indexp++)
{ {
if (indexp->numents == 0 && indexp->pu.fp != NULL) if (indexp->numents == 0 && indexp->pu.fp != NULL)
@ -669,10 +669,10 @@ void ISpellChecker::clearindex (struct flagptr *indexp)
#ifdef INDEXDUMP #ifdef INDEXDUMP
static void dumpindex (indexp, depth) static void dumpindex (indexp, depth)
register struct flagptr * indexp; struct flagptr * indexp;
register int depth; int depth;
{ {
register int i; int i;
int j; int j;
int k; int k;
char stripbuf[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; char stripbuf[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
@ -733,8 +733,8 @@ static void dumpindex (indexp, depth)
*/ */
struct dent * ISpellChecker::ispell_lookup (ichar_t *s, int dotree) struct dent * ISpellChecker::ispell_lookup (ichar_t *s, int dotree)
{ {
register struct dent * dp; struct dent * dp;
register char * s1; char * s1;
char schar[INPUTWORDLEN + MAXAFFIXLEN]; char schar[INPUTWORDLEN + MAXAFFIXLEN];
dp = &m_hashtbl[hash (s, m_hashsize)]; dp = &m_hashtbl[hash (s, m_hashsize)];

26
tdespell2/plugins/ispell/makedent.cpp
Unescape View File

@ -259,7 +259,7 @@ other abi documents
long long
ISpellChecker::whatcap (ichar_t *word) ISpellChecker::whatcap (ichar_t *word)
{ {
register ichar_t * p; ichar_t * p;
for (p = word; *p; p++) for (p = word; *p; p++)
{ {
@ -311,7 +311,7 @@ ISpellChecker::whatcap (ichar_t *word)
*/ */
int ISpellChecker::addvheader ( struct dent *dp) int ISpellChecker::addvheader ( struct dent *dp)
{ {
register struct dent * tdent; /* Copy of entry */ struct dent * tdent; /* Copy of entry */
/* /*
** Add a second entry with the correct capitalization, and then make ** Add a second entry with the correct capitalization, and then make
@ -502,11 +502,11 @@ ISpellChecker::stringcharlen (char *bufp, int canonical)
static char * sp[MAXSTRINGCHARS]; static char * sp[MAXSTRINGCHARS];
static int inited = 0; static int inited = 0;
#endif /* SLOWMULTIPLY */ #endif /* SLOWMULTIPLY */
register char * bufcur; char * bufcur;
register char * stringcur; char * stringcur;
register int stringno; int stringno;
register int lowstringno; int lowstringno;
register int highstringno; int highstringno;
int dupwanted; int dupwanted;
#ifdef SLOWMULTIPLY #ifdef SLOWMULTIPLY
@ -641,7 +641,7 @@ int l1_isstringch(char *ptr, int len, int canon) {
int int
ISpellChecker::strtoichar (ichar_t *out, char *in, int outlen, int canonical) ISpellChecker::strtoichar (ichar_t *out, char *in, int outlen, int canonical)
{ {
register int len = 1; /* Length of next character */ int len = 1; /* Length of next character */
outlen /= sizeof (ichar_t); /* Convert to an ichar_t count */ outlen /= sizeof (ichar_t); /* Convert to an ichar_t count */
for ( ; --outlen > 0 && *in != '\0'; in += len) for ( ; --outlen > 0 && *in != '\0'; in += len)
@ -674,9 +674,9 @@ ISpellChecker::strtoichar (ichar_t *out, char *in, int outlen, int canonical)
int int
ISpellChecker::ichartostr ( char *out, ichar_t *in, int outlen, int canonical) ISpellChecker::ichartostr ( char *out, ichar_t *in, int outlen, int canonical)
{ {
register int ch; /* Next character to store */ int ch; /* Next character to store */
register int i; /* Index into duplicates list */ int i; /* Index into duplicates list */
register char * scharp; /* Pointer into a string char */ char * scharp; /* Pointer into a string char */
while (--outlen > 0 && (ch = *in++) != 0) while (--outlen > 0 && (ch = *in++) != 0)
{ {
@ -796,7 +796,7 @@ icharcpy (ichar_t *out, ichar_t *in)
int int
icharlen (ichar_t * in) icharlen (ichar_t * in)
{ {
register int len; /* Length so far */ int len; /* Length so far */
for (len = 0; *in++ != 0; len++) for (len = 0; *in++ != 0; len++)
; ;
@ -862,7 +862,7 @@ ISpellChecker::findfiletype (const char *name, int searchnames, int *deformatter
{ {
char * cp; /* Pointer into suffix list */ char * cp; /* Pointer into suffix list */
int cplen; /* Length of current suffix */ int cplen; /* Length of current suffix */
register int i; /* Index into type table */ int i; /* Index into type table */
int len; /* Length of the name */ int len; /* Length of the name */
/* /*

24
tdespell2/plugins/ispell/tgood.cpp
Unescape View File

@ -243,7 +243,7 @@
void ISpellChecker::chk_aff (ichar_t *word, ichar_t *ucword, void ISpellChecker::chk_aff (ichar_t *word, ichar_t *ucword,
int len, int ignoreflagbits, int allhits, int pfxopts, int sfxopts) int len, int ignoreflagbits, int allhits, int pfxopts, int sfxopts)
{ {
register ichar_t * cp; /* Pointer to char to index on */ ichar_t * cp; /* Pointer to char to index on */
struct flagptr * ind; /* Flag index table to test */ struct flagptr * ind; /* Flag index table to test */
pfx_list_chk (word, ucword, len, pfxopts, sfxopts, &m_pflagindex[0], pfx_list_chk (word, ucword, len, pfxopts, sfxopts, &m_pflagindex[0],
@ -293,13 +293,13 @@ void ISpellChecker::pfx_list_chk (ichar_t *word, ichar_t *ucword, int len, int o
int sfxopts, struct flagptr * ind, int ignoreflagbits, int allhits) int sfxopts, struct flagptr * ind, int ignoreflagbits, int allhits)
{ {
int cond; /* Condition number */ int cond; /* Condition number */
register ichar_t * cp; /* Pointer into end of ucword */ ichar_t * cp; /* Pointer into end of ucword */
struct dent * dent; /* Dictionary entry we found */ struct dent * dent; /* Dictionary entry we found */
int entcount; /* Number of entries to process */ int entcount; /* Number of entries to process */
register struct flagent * struct flagent *
flent; /* Current table entry */ flent; /* Current table entry */
int preadd; /* Length added to tword2 as prefix */ int preadd; /* Length added to tword2 as prefix */
register int tlen; /* Length of tword */ int tlen; /* Length of tword */
ichar_t tword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; /* Tmp cpy */ ichar_t tword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; /* Tmp cpy */
ichar_t tword2[sizeof tword]; /* 2nd copy for ins_root_cap */ ichar_t tword2[sizeof tword]; /* 2nd copy for ins_root_cap */
@ -414,7 +414,7 @@ ISpellChecker::chk_suf (ichar_t *word, ichar_t *ucword,
int len, int optflags, struct flagent *pfxent, int len, int optflags, struct flagent *pfxent,
int ignoreflagbits, int allhits) int ignoreflagbits, int allhits)
{ {
register ichar_t * cp; /* Pointer to char to index on */ ichar_t * cp; /* Pointer to char to index on */
struct flagptr * ind; /* Flag index table to test */ struct flagptr * ind; /* Flag index table to test */
suf_list_chk (word, ucword, len, &m_sflagindex[0], optflags, pfxent, suf_list_chk (word, ucword, len, &m_sflagindex[0], optflags, pfxent,
@ -458,14 +458,14 @@ void ISpellChecker::suf_list_chk (ichar_t *word, ichar_t *ucword,
int len, struct flagptr *ind, int optflags, int len, struct flagptr *ind, int optflags,
struct flagent *pfxent, int ignoreflagbits, int allhits) struct flagent *pfxent, int ignoreflagbits, int allhits)
{ {
register ichar_t * cp; /* Pointer into end of ucword */ ichar_t * cp; /* Pointer into end of ucword */
int cond; /* Condition number */ int cond; /* Condition number */
struct dent * dent; /* Dictionary entry we found */ struct dent * dent; /* Dictionary entry we found */
int entcount; /* Number of entries to process */ int entcount; /* Number of entries to process */
register struct flagent * struct flagent *
flent; /* Current table entry */ flent; /* Current table entry */
int preadd; /* Length added to tword2 as prefix */ int preadd; /* Length added to tword2 as prefix */
register int tlen; /* Length of tword */ int tlen; /* Length of tword */
ichar_t tword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; /* Tmp cpy */ ichar_t tword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4]; /* Tmp cpy */
ichar_t tword2[sizeof tword]; /* 2nd copy for ins_root_cap */ ichar_t tword2[sizeof tword]; /* 2nd copy for ins_root_cap */
@ -599,7 +599,7 @@ int ISpellChecker::expand_pre (char *croot, ichar_t *rootword, MASKTYPE mask[],
{ {
int entcount; /* No. of entries to process */ int entcount; /* No. of entries to process */
int explength; /* Length of expansions */ int explength; /* Length of expansions */
register struct flagent * struct flagent *
flent; /* Current table entry */ flent; /* Current table entry */
for (flent = m_pflaglist, entcount = m_numpflags, explength = 0; for (flent = m_pflaglist, entcount = m_numpflags, explength = 0;
@ -630,7 +630,7 @@ int ISpellChecker::pr_pre_expansion ( char *croot, ichar_t *rootword,
char *extra) char *extra)
{ {
int cond; /* Current condition number */ int cond; /* Current condition number */
register ichar_t * nextc; /* Next case choice */ ichar_t * nextc; /* Next case choice */
int tlen; /* Length of tword */ int tlen; /* Length of tword */
ichar_t tword[INPUTWORDLEN + MAXAFFIXLEN]; /* Temp */ ichar_t tword[INPUTWORDLEN + MAXAFFIXLEN]; /* Temp */
@ -728,7 +728,7 @@ int ISpellChecker::expand_suf (char *croot, ichar_t *rootword, MASKTYPE mask[],
{ {
int entcount; /* No. of entries to process */ int entcount; /* No. of entries to process */
int explength; /* Length of expansions */ int explength; /* Length of expansions */
register struct flagent * struct flagent *
flent; /* Current table entry */ flent; /* Current table entry */
for (flent = m_sflaglist, entcount = m_numsflags, explength = 0; for (flent = m_sflaglist, entcount = m_numsflags, explength = 0;
@ -761,7 +761,7 @@ int ISpellChecker::pr_suf_expansion (char *croot, ichar_t *rootword,
struct flagent *flent, int option, char *extra) struct flagent *flent, int option, char *extra)
{ {
int cond; /* Current condition number */ int cond; /* Current condition number */
register ichar_t * nextc; /* Next case choice */ ichar_t * nextc; /* Next case choice */
int tlen; /* Length of tword */ int tlen; /* Length of tword */
ichar_t tword[INPUTWORDLEN + MAXAFFIXLEN]; /* Temp */ ichar_t tword[INPUTWORDLEN + MAXAFFIXLEN]; /* Temp */

8
tdestyles/plastik/plastik.cpp
Unescape View File

@ -832,15 +832,15 @@ void PlastikStyle::renderGradient(TQPainter *painter,
int rDiff, gDiff, bDiff; int rDiff, gDiff, bDiff;
int rc, gc, bc; int rc, gc, bc;
register int x, y; int x, y;
rDiff = ( c2.red()) - (rc = c1.red()); rDiff = ( c2.red()) - (rc = c1.red());
gDiff = ( c2.green()) - (gc = c1.green()); gDiff = ( c2.green()) - (gc = c1.green());
bDiff = ( c2.blue()) - (bc = c1.blue()); bDiff = ( c2.blue()) - (bc = c1.blue());
register int rl = rc << 16; int rl = rc << 16;
register int gl = gc << 16; int gl = gc << 16;
register int bl = bc << 16; int bl = bc << 16;
int rdelta = ((1<<16) / (horizontal ? r_h : r_w)) * rDiff; int rdelta = ((1<<16) / (horizontal ? r_h : r_w)) * rDiff;
int gdelta = ((1<<16) / (horizontal ? r_h : r_w)) * gDiff; int gdelta = ((1<<16) / (horizontal ? r_h : r_w)) * gDiff;

2
tdeui/tests/kledtest.cpp
Unescape View File

@ -98,7 +98,7 @@ KLedTest::nextColor() {
void void
KLedTest::nextLook() { KLedTest::nextLook() {
register int tmp; int tmp;
if (kled_round) { if (kled_round) {
tmp = (static_cast<int>(ledlook) +1 ) % 3 ; tmp = (static_cast<int>(ledlook) +1 ) % 3 ;
} }

Write Preview
Loading…
Cancel
Save