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;
base = iov->iov_base;
while (len > 0) {
register int nbytes;
int nbytes;
nbytes = TRANS(Read) (ciptr, base, len);
if (nbytes < 0 && total == 0) return -1;
if (nbytes <= 0) return total;
@ -1293,7 +1293,7 @@ static int TRANS(WriteV) (XtransConnInfo ciptr, struct iovec *iov, int iovcnt)
len = iov->iov_len;
base = iov->iov_base;
while (len > 0) {
register int nbytes;
int nbytes;
nbytes = TRANS(Write) (ciptr, base, len);
if (nbytes < 0 && total == 0) return -1;
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
#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;
@ -264,7 +264,7 @@ char **errorStringRet;
* 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--)
if (*a++ != *b++)

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

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

38
dcop/dcopidl/scanner.cc
Unescape View File

@ -1209,9 +1209,9 @@ extern int yylex (void);
*/
YY_DECL
{
register yy_state_type yy_current_state;
register char *yy_cp, *yy_bp;
register int yy_act;
yy_state_type yy_current_state;
char *yy_cp, *yy_bp;
int yy_act;
#line 148 "scanner.ll"
@ -1270,7 +1270,7 @@ YY_DECL
yy_match:
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 )
{
yy_current_state = (int) yy_def[yy_current_state];
@ -1909,9 +1909,9 @@ ECHO;
*/
static int yy_get_next_buffer (void)
{
register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
register char *source = (yytext_ptr);
register int number_to_move, i;
char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
char *source = (yytext_ptr);
int number_to_move, i;
int ret_val;
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)
{
register yy_state_type yy_current_state;
register char *yy_cp;
yy_state_type yy_current_state;
char *yy_cp;
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 )
{
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 )
{
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 )
{
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 )
{
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;
}
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);
@ -2074,10 +2074,10 @@ static int yy_get_next_buffer (void)
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
register int number_to_move = (yy_n_chars) + 2;
register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
int number_to_move = (yy_n_chars) + 2;
char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
register char *source =
char *source =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
@ -2694,7 +2694,7 @@ int yylex_destroy (void)
#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
{
register int i;
int i;
for ( i = 0; i < n; ++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
static int yy_flex_strlen (yyconst char * s )
{
register int n;
int 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 IceWriteHandler _kde_IceWriteHandler;
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)
@ -237,7 +237,7 @@ static unsigned long writeIceData(IceConn iceConn, unsigned long nbytes, char *p
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 );
#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)
{
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),
state(NoFile)
{
register bool GUARD; GUARD=true;
bool GUARD; GUARD=true;
// ###########################################################################
TQString dir, filename;
bool createBackup=true;
@ -647,7 +647,7 @@ AddressBook::ErrorCode AddressBook::load(const TQString& filename)
AddressBook::ErrorCode
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";
StringKabKeyMap::iterator pos;
@ -702,7 +702,7 @@ AddressBook::literalName(const KabKey& key, TQString& text, bool rev, bool init)
AddressBook::ErrorCode
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";
TQString firstname, middlename, lastname, nameprefix;
@ -817,7 +817,7 @@ AddressBook::dataFileChanged()
void
AddressBook::configFileChanged()
{
register bool GUARD; GUARD=true;
bool GUARD; GUARD=true;
// ###########################################################################
if(!config->load())
{
@ -835,7 +835,7 @@ AddressBook::configFileChanged()
void
AddressBook::reloaded(QConfigDB* db)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
if(db==data)
{
@ -924,7 +924,7 @@ AddressBook::getEntry(const KabKey& key, Entry& entry)
AddressBook::ErrorCode
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 "
"with key " << key.getKey().data() << endl;
@ -1004,7 +1004,7 @@ AddressBook::getKey(int index, KabKey& key)
AddressBook::ErrorCode
AddressBook::getIndex(const KabKey& key, int& index)
{
register bool GUARD; GUARD=true;
bool GUARD; GUARD=true;
// ###########################################################################
StringKabKeyMap::iterator pos;
// -----
@ -1283,7 +1283,7 @@ AddressBook::nextAvailEntryKey()
AddressBook::ErrorCode
AddressBook::updateMirrorMap()
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA)
<< "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)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "tokenize: called." << endl;
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)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "ReadLineFromStream:: reading line." << endl;
TQCString line;
@ -174,7 +174,7 @@ KeyValueMap::size() const
void
KeyValueMap::clear()
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::clear: erasing map contents ... " << endl;
@ -191,7 +191,7 @@ KeyValueMap::clear()
bool
KeyValueMap::fill(const TQString& filename, bool force, bool relax)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
TQFile file(filename);
TQCString line;
@ -231,7 +231,7 @@ KeyValueMap::fill(const TQString& filename, bool force, bool relax)
bool
KeyValueMap::save(const TQString& filename, bool force)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::save: saving data to -->" <<
@ -271,7 +271,7 @@ KeyValueMap::save(const TQString& filename, bool force)
bool
KeyValueMap::save(TQTextStream& file, int count)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::save: saving data to given output stream." << endl;
@ -318,7 +318,7 @@ KeyValueMap::parseComplexString
int& noOfChars) // no of chars that represented the
const // complex string in the original
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
int first;
TQCString temp(2*orig.length());
@ -415,7 +415,7 @@ KeyValueMap::parseComplexString
TQCString
KeyValueMap::makeComplexString(const TQCString& orig)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::makeComplexString: coding the string\n -->"
@ -468,7 +468,7 @@ KeyValueMap::makeComplexString(const TQCString& orig)
bool
KeyValueMap::getRaw(const TQCString& key, TQCString& value) const
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::getRaw: trying to get raw value for key \"" << key << "\" ...\n";
@ -490,7 +490,7 @@ KeyValueMap::getRaw(const TQCString& key, TQCString& value) const
bool
KeyValueMap::insertRaw(const TQCString& key, const TQCString& value, bool force)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insertRaw: inserting uncoded value "
@ -535,7 +535,7 @@ KeyValueMap::insertRaw(const TQCString& key, const TQCString& value, bool force)
bool
KeyValueMap::insert(const TQCString& key, const TQCString& value, bool force)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insert: inserting value\n -->"
@ -556,7 +556,7 @@ KeyValueMap::insert(const TQCString& key, const TQCString& value, bool force)
bool
KeyValueMap::insertLine(TQCString line, bool force, bool relax, bool encode)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insertLine: inserting line -->"<<line<<"<--.\n";
@ -611,7 +611,7 @@ KeyValueMap::insertLine(TQCString line, bool force, bool relax, bool encode)
bool
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]: "
"trying to get value for key \"" << key << "\" ... " << endl;
@ -651,7 +651,7 @@ KeyValueMap::get(const TQCString& key, TQCString& value) const
bool
KeyValueMap::insert(const TQCString& key, const TQString& value, bool force)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
TQCString v;
// -----
@ -668,7 +668,7 @@ KeyValueMap::insert(const TQCString& key, const TQString& value, bool force)
bool
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 "
"a TQString value for key " << key << endl;
@ -694,7 +694,7 @@ KeyValueMap::get(const TQCString& key, TQString& value) const
bool
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 "
"insert \""
@ -709,7 +709,7 @@ KeyValueMap::insert(const TQCString& key, const bool& value, bool force)
bool
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 "
"BOOL value for key " << key << endl;
@ -750,7 +750,7 @@ KeyValueMap::get(const TQCString& key, bool& value) const
bool
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 "
"insert value \""<<value << "\" for key\n -->"<<key<<"<--.\n";
@ -764,7 +764,7 @@ KeyValueMap::insert(const TQCString& key, const long& value, bool force)
bool
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 "
"INTEGER value for key " << key << endl;
@ -796,7 +796,7 @@ KeyValueMap::get(const TQCString& key, long& value) const
bool
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]: "
"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
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 "
"to decode int list for key " << key << endl;
@ -871,7 +871,7 @@ KeyValueMap::get(const TQCString& key, list<long>& values) const
bool
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 "
"insert int list into map." << endl;
@ -898,7 +898,7 @@ KeyValueMap::insert(const TQCString& key, const list<int>& values, bool force)
bool
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 "
"decode int list for key " << key << endl;
@ -946,7 +946,7 @@ KeyValueMap::get(const TQCString& key, list<int>& values) const
bool
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 "
"insert value \"%f\" for key\n -->", value) << key << "<--.\n";
@ -960,7 +960,7 @@ KeyValueMap::insert(const TQCString& key, const double& value, bool force)
bool
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 "
"FLOAT value for key " << key << endl;
@ -993,7 +993,7 @@ KeyValueMap::get(const TQCString& key, double& value) const
bool
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]: "
"attention!\n \"values\" list reference is not "
"empty!" << endl;
@ -1070,7 +1070,7 @@ KeyValueMap::get(const TQCString& key, list<TQCString>& values) const
bool
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]: "
"coding string list." << endl;
@ -1102,7 +1102,7 @@ KeyValueMap::insert(const TQCString& key, const list<TQCString>& values, bool fo
bool
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]: "
"attention!\n \"values\" list reference is not "
"empty!" << endl;
@ -1178,7 +1178,7 @@ KeyValueMap::get(const TQCString& key, TQStrList& values) const
bool
KeyValueMap::insert(const TQCString& key, const TQStrList& values, bool force)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insert[QStrList]: coding string list." << endl;
@ -1209,7 +1209,7 @@ KeyValueMap::insert(const TQCString& key, const TQStrList& values, bool force)
bool
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"
"[QStringList]: attention!\n \"values\" list reference"
" is not empty!" << endl;
@ -1242,7 +1242,7 @@ KeyValueMap::get(const TQCString& key, TQStringList& values) const
bool
KeyValueMap::insert(const TQCString& key, const TQStringList& values, bool force)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"KeyValueMap::insert[QStringList]: coding TQStringList." << endl;
@ -1265,7 +1265,7 @@ KeyValueMap::insert(const TQCString& key, const TQStringList& values, bool force
bool
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 "
"to insert double list into map." << endl;
@ -1293,7 +1293,7 @@ KeyValueMap::insert(const TQCString& key, const list<double>& values, bool force
bool
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 "
"decode double list for key " << key << endl;
@ -1336,7 +1336,7 @@ KeyValueMap::get(const TQCString& key, list<double>& values) const
bool
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 "
"insert TQDate into map." << endl;
@ -1360,7 +1360,7 @@ KeyValueMap::insert(const TQCString& key, const TQDate& value, bool force)
bool
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"
" TQDate for key " << key << endl;
@ -1420,7 +1420,7 @@ Section::Section(const KeyValueMap& contents)
bool
Section::add(const TQCString& name)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::add: adding section \""
<<name<<"\" to "
@ -1455,7 +1455,7 @@ Section::add(const TQCString& name)
bool
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)
{
@ -1473,7 +1473,7 @@ Section::add(const TQCString& name, Section* section)
bool
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 "
"\""<<name<<"\" ... \n";
@ -1549,7 +1549,7 @@ Section::insertIndentSpace(TQTextStream& file, int level)
bool
Section::save(TQTextStream& stream, int level)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
StringSectionMap::iterator pos;
// -----
@ -1592,7 +1592,7 @@ Section::save(TQTextStream& stream, int level)
bool
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;
TQCString line;
@ -1661,7 +1661,7 @@ Section::readSection(TQTextStream& file, bool finish)
bool
Section::isBeginOfSection(TQCString line)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
line=line.simplifyWhiteSpace();
if(line.isEmpty() || line.length()<2)
@ -1687,7 +1687,7 @@ Section::isBeginOfSection(TQCString line)
bool
Section::isEndOfSection(TQCString line)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "Section::isEndOfSection: is "
<< line <<" the end of"
@ -1728,7 +1728,7 @@ Section::isEndOfSection(TQCString line)
TQCString
Section::nameOfSection(const TQCString& line)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ###########################################################################
int first=1, second;
TQCString temp;
@ -1849,7 +1849,7 @@ bool QConfigDB::invariant()
bool
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;
Section* section=&top;
@ -1960,7 +1960,7 @@ QConfigDB::get(const TQCString& key, KeyValueMap*& map)
list<TQCString>
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;
// ############################################################################
list<TQCString> key;
@ -2012,7 +2012,7 @@ QConfigDB::get(const TQCString& key, Section*& section)
bool
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;
Section* temp=&top;
@ -2044,7 +2044,7 @@ QConfigDB::isRO()
int
QConfigDB::IsLocked(const TQString& file)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
TQString lockfile=file+".lock";
int pid=-1;
@ -2087,7 +2087,7 @@ QConfigDB::IsLocked(const TQString& file)
bool
QConfigDB::lock()
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
if(locked)
{
@ -2108,7 +2108,7 @@ QConfigDB::lock()
bool
QConfigDB::lock(const TQString& file)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::lock: locking the file "
<< file << endl;
@ -2143,7 +2143,7 @@ QConfigDB::lock(const TQString& file)
bool
QConfigDB::unlock()
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::unlock: unlocking the file "
<< filename << endl;
@ -2190,7 +2190,7 @@ QConfigDB::unlock()
void
QConfigDB::CleanLockFiles(int)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
list<TQString>::iterator pos;
// -----
@ -2236,7 +2236,7 @@ QConfigDB::watch(bool state)
bool
QConfigDB::CheckLockFile(const TQString& file)
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::CheckLockFile: called." << endl;
int pid;
@ -2270,7 +2270,7 @@ QConfigDB::CheckLockFile(const TQString& file)
bool
QConfigDB::checkFileChanged()
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
// kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::checkFileChanged: called." << endl;
if(filename.isEmpty())
@ -2308,7 +2308,7 @@ QConfigDB::checkFileChanged()
bool
QConfigDB::storeFileAge()
{
register bool GUARD; GUARD=false;
bool GUARD; GUARD=false;
// ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) << "QConfigDB::storeFileAge: called." << endl;
TQFileInfo file(filename);
@ -2329,7 +2329,7 @@ QConfigDB::storeFileAge()
bool
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 "
"to \""
@ -2443,7 +2443,7 @@ QConfigDB::fileName()
bool
QConfigDB::save(const char* header, bool force)
{
register bool GUARD; GUARD=true;
bool GUARD; GUARD=true;
// ############################################################################
kdDebug(GUARD, KAB_KDEBUG_AREA) <<
"QConfigDB::save: saving database -->" << filename << "<--.\n";
@ -2522,7 +2522,7 @@ QConfigDB::save(const char* header, bool force)
bool
QConfigDB::load()
{
register bool GUARD; GUARD=false ;
bool GUARD; GUARD=false ;
// ############################################################################
TQFile file(filename);
// -----

10
kjs/dtoa.cpp
Unescape View File

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

12
tdeabc/vcard/Enum.cpp
Unescape View File

@ -433,12 +433,12 @@ static signed char b64dec[] = {
char *
VCARD::decodeBase64(const char * s, unsigned long srcl, unsigned long & len)
{
register unsigned char c;
register unsigned long e(0);
unsigned char c;
unsigned long e(0);
len = 0;
unsigned const char * src = (unsigned const char *)s;
char * ret = new char[srcl + (srcl / 4 + 1)];
register char *d = ret;
char *d = ret;
while (srcl--) { // Critical loop
c = *src++;
int dec = b64dec[c];
@ -468,12 +468,12 @@ VCARD::decodeBase64(const char * s, unsigned long srcl, unsigned long & len)
char *
VCARD::encodeBase64(const char * src, unsigned long srcl, unsigned long & destl)
{
register const unsigned char *s = (unsigned char *)src;
register unsigned long i = ((srcl + 2) / 3) * 4;
const unsigned char *s = (unsigned char *)src;
unsigned long i = ((srcl + 2) / 3) * 4;
destl = i += 2 * ((i / 60) + 1);
i = 0;
char * ret = new char[destl];
register unsigned char *d((unsigned char *)ret);
unsigned char *d((unsigned char *)ret);
while (srcl != 0) { // Critical loop
*d++ = B64[s[0] >> 2];
*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.
register char * rstart = new char[strlen(str) + 1];
register char * r = rstart;
char * rstart = new char[strlen(str) + 1];
char * r = rstart;
register const char * i = str; // Cursor.
const char * i = str; // Cursor.
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)
{
{
register unsigned u = readBufferSize();
unsigned u = readBufferSize();
if (nbytes > u)
nbytes = u; // we can't consume more than there is
}

12
tdecore/kentities.c
Unescape View File

@ -73,7 +73,7 @@ inline
#endif
#endif
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[] =
{
@ -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
};
register int hval = len;
int hval = len;
switch (hval)
{
@ -140,7 +140,7 @@ hash_Entity (register const char *str, register unsigned int len)
__inline
#endif
const struct entity *
kde_findEntity (register const char *str, register unsigned int len)
kde_findEntity (register const char *str, unsigned int len)
{
enum
{
@ -815,15 +815,15 @@ kde_findEntity (register const char *str, register unsigned int len)
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)
{
register int index = lookup[key];
int index = lookup[key];
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')
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
register unsigned wsize = writeBufferSize();
unsigned wsize = writeBufferSize();
if (d->outMaxSize == (int)wsize) // (int) to get rid of annoying warning
{
// 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.
static int rikFindChar(register const char * _s, const char c)
{
register const char * s = _s;
const char * s = _s;
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)
{
int i, n;
register unsigned char c;
unsigned char c;
bool gotone = false;
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){
TQCString result(str.length()*2); // Maximum 2x as long as source string
register char *r = const_cast<TQCString&>(result).data();
register char *s = const_cast<TQCString&>(str).data();
char *r = const_cast<TQCString&>(result).data();
char *s = const_cast<TQCString&>(str).data();
if (!s) return TQCString("");
@ -166,7 +166,7 @@ static TQCString stringToPrintable(const TQCString& str){
static TQCString decodeGroup(const char*s, int l)
{
TQCString result(l);
register char *r = result.data();
char *r = result.data();
l--; // Correct for trailing \0
while(l)
@ -198,8 +198,8 @@ static TQCString encodeGroup(const TQCString &str)
{
int l = str.length();
TQCString result(l*2+1);
register char *r = const_cast<TQCString&>(result).data();
register char *s = const_cast<TQCString&>(str).data();
char *r = const_cast<TQCString&>(result).data();
char *s = const_cast<TQCString&>(str).data();
while(l)
{
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"
// 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 & 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)
{
register TDELocale *instance = TDEGlobal::locale();
TDELocale *instance = TDEGlobal::locale();
if (instance)
return instance->translate(text);
return TQString::fromUtf8(text);
@ -1984,7 +1984,7 @@ TQString i18n(const char* text)
TQString i18n(const char* index, const char *text)
{
register TDELocale *instance = TDEGlobal::locale();
TDELocale *instance = TDEGlobal::locale();
if (instance)
return instance->translate(index, 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)
{
register TDELocale *instance = TDEGlobal::locale();
TDELocale *instance = TDEGlobal::locale();
if (instance)
return instance->translate(singular, plural, n);
if (n == 1)

12
tdecore/tdesycocadict.cpp
Unescape View File

@ -182,7 +182,7 @@ uint
KSycocaDict::hashKey( const TQString &key)
{
int l = key.length();
register uint h = 0;
uint h = 0;
for(uint i = 0; i < mHashList.count(); i++)
{
@ -217,10 +217,10 @@ calcDiversity(KSycocaDictStringList *d, int pos, int sz)
pos = -pos-1;
for(string_entry *entry=d->first(); entry; entry = d->next())
{
register int l = entry->length;
int l = entry->length;
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;
}
}
@ -232,7 +232,7 @@ calcDiversity(KSycocaDictStringList *d, int pos, int sz)
{
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;
}
}
@ -257,7 +257,7 @@ addDiversity(KSycocaDictStringList *d, int pos)
pos = -pos-1;
for(string_entry *entry=d->first(); entry; entry = d->next())
{
register int l = entry->length;
int l = entry->length;
if (pos < l)
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
// for the table size of big tables
// 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;
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;
}
register int x, y;
int x, y;
rDiff = (rcb = cb.red()) - (rca = ca.red());
gDiff = (gcb = cb.green()) - (gca = ca.green());
@ -147,9 +147,9 @@ TQImage KImageEffect::gradient(const TQSize &size, const TQColor &ca,
uint *p;
uint rgb;
register int rl = rca << 16;
register int gl = gca << 16;
register int bl = bca << 16;
int rl = rca << 16;
int gl = gca << 16;
int bl = bca << 16;
if( eff == VerticalGradient ) {
@ -424,7 +424,7 @@ TQImage KImageEffect::unbalancedGradient(const TQSize &size, const TQColor &ca,
return image;
}
register int x, y;
int x, y;
unsigned int *scanline;
rDiff = (rcb = cb.red()) - (rca = ca.red());
@ -949,7 +949,7 @@ TQImage& KImageEffect::modulate(TQImage &image, TQImage &modImage, bool reverse,
TQColor clr;
int mod=0;
unsigned int x1, x2, y1, y2;
register int x, y;
int x, y;
// for image, we handle only depth 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);
#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
register unsigned char *data = (unsigned char *)dst.bits();
unsigned char *data = (unsigned char *)dst.bits();
#endif
for (register int i=0; i<pixels; i++)
for (int i=0; i<pixels; i++)
{
#ifdef WORDS_BIGENDIAN
*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)
register unsigned char *data1 = (unsigned char *)dst.bits() + 1;
register unsigned char *data2 = (unsigned char *)src.bits() + 1;
unsigned char *data1 = (unsigned char *)dst.bits() + 1;
unsigned char *data2 = (unsigned char *)src.bits() + 1;
#else // BGRA
register unsigned char *data1 = (unsigned char *)dst.bits();
register unsigned char *data2 = (unsigned char *)src.bits();
unsigned char *data1 = (unsigned char *)dst.bits();
unsigned char *data2 = (unsigned char *)src.bits();
#endif
for (register int i=0; i<pixels; i++)
for (int i=0; i<pixels; i++)
{
#ifdef WORDS_BIGENDIAN
*data1 += (unsigned char)((*(data2++) - *data1) * opacity);
@ -1582,7 +1582,7 @@ TQImage& KImageEffect::blend(TQImage &image, float initial_intensity,
var = -var;
}
register int x, y;
int x, y;
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 a;
register int x, y;
int x, y;
// for image1 and image2, we only handle depth 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;
}
register int x, y;
int x, y;
unsigned int *data = (unsigned int *)image.bits();
unsigned int ind;
@ -2142,9 +2142,9 @@ TQImage& KImageEffect::toGray(TQImage &img, bool fast)
if(fast){
if (img.depth() == 32) {
register uchar * r(img.bits());
register uchar * g(img.bits() + 1);
register uchar * b(img.bits() + 2);
uchar * r(img.bits());
uchar * g(img.bits() + 1);
uchar * b(img.bits() + 2);
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++)
{
register uint r = tqRed(img.color(i));
register uint g = tqGreen(img.color(i));
register uint b = tqBlue(img.color(i));
uint r = tqRed(img.color(i));
uint g = tqGreen(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))));
}
}
@ -2408,10 +2408,10 @@ bool KImageEffect::blend(
output = lower.copy();
register uchar *i, *o;
register int a;
register int col;
register int w = upper.width();
uchar *i, *o;
int a;
int col;
int w = upper.width();
int row(upper.height() - 1);
do {
@ -2490,10 +2490,10 @@ bool KImageEffect::blend(
// output.setAlphaBuffer(true); // I should do some benchmarks to see if
// this is worth the effort
register TQRgb *i, *o, *b;
TQRgb *i, *o, *b;
register int a;
register int j,k;
int a;
int j,k;
for (j=0; j<ch; j++)
{
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;
}
register uchar *i, *b;
register int a;
register int k;
uchar *i, *b;
int a;
int k;
for (int j=0; j<ch; j++)
{
@ -3102,7 +3102,7 @@ unsigned int KImageEffect::generateNoise(unsigned int pixel,
}
case PoissonNoise:
{
register int
int
i;
for (i=0; alpha > exp(-SigmaPoisson*pixel); i++)
@ -3709,7 +3709,7 @@ void KImageEffect::normalize(TQImage &image)
TQ_INT64 number_pixels;
int x, y;
unsigned int *p, *q;
register long i;
long i;
unsigned long threshold_intensity;
unsigned char r, g, b, a;
@ -4016,7 +4016,7 @@ TQImage KImageEffect::edge(TQImage &image, double radius)
{
double *kernel;
int width;
register long i;
long i;
TQImage dest;
if(radius == 50.0){
@ -4054,7 +4054,7 @@ TQImage KImageEffect::emboss(TQImage &image, double radius, double sigma)
{
double alpha, *kernel;
int j, width;
register long i, u, v;
long i, u, v;
TQImage dest;
if(sigma == 0.0){
@ -4099,10 +4099,10 @@ void KImageEffect::blurScanLine(double *kernel, int width,
unsigned int *src, unsigned int *dest,
int columns)
{
register double *p;
double *p;
unsigned int *q;
register int x;
register long i;
int x;
long i;
double red, green, blue, alpha;
double scale = 0.0;
@ -4239,7 +4239,7 @@ int KImageEffect::getBlurKernel(int width, double sigma, double **kernel)
{
#define KernelRank 3
double alpha, normalize;
register long i;
long i;
int bias;
assert(sigma != 0.0);
@ -4352,8 +4352,8 @@ bool KImageEffect::convolveImage(TQImage *image, TQImage *dest,
long width;
double red, green, blue, alpha;
double normalize, *normal_kernel;
register const double *k;
register unsigned int *q;
const double *k;
unsigned int *q;
int x, y, mx, my, sx, sy;
long i;
int mcx, mcy;
@ -4425,7 +4425,7 @@ int KImageEffect::getOptimalKernelWidth(double radius, double sigma)
{
double normalize, value;
long width;
register long u;
long u;
assert(sigma != 0.0);
if(radius > 0.0)
@ -4453,7 +4453,7 @@ TQImage KImageEffect::sharpen(TQImage &image, double radius, double sigma)
{
double alpha, normalize, *kernel;
int width;
register long i, u, v;
long i, u, v;
TQImage dest;
if(sigma == 0.0){
@ -4957,12 +4957,12 @@ TQImage KImageEffect::convertToPremultipliedAlpha(TQImage input) {
int w = alphaImage.width();
int h = alphaImage.height();
register int r;
register int g;
register int b;
register int a;
register float alpha_adjust;
register TQRgb l;
int r;
int g;
int b;
int a;
float alpha_adjust;
TQRgb l;
TQRgb *ls;
for (int y = 0; y < h; ++y) {
ls = (TQRgb *)alphaImage.scanLine( y );

2
tdefx/kpixmap.cpp
Unescape View File

@ -34,7 +34,7 @@
// Based on Qt's image conversion functions
static bool kdither_32_to_8( const TQImage *src, TQImage *dst )
{
// register QRgb *p;
// TQRgb *p;
uchar *b;
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 rca, gca, bca /*, rcb, gcb, bcb*/;
register int x, y;
int x, y;
rDiff = (/*rcb = */ cb.red()) - (rca = ca.red());
gDiff = (/*gcb = */ cb.green()) - (gca = ca.green());
bDiff = (/*bcb = */ cb.blue()) - (bca = ca.blue());
register int rl = rca << 16;
register int gl = gca << 16;
register int bl = bca << 16;
int rl = rca << 16;
int gl = gca << 16;
int bl = bca << 16;
int rcdelta = ((1<<16) / (eff == VerticalGradient ? pixmap.height() : pixmap.width())) * rDiff;
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.
int pixels = dst.width() * dst.height();
#ifdef WORDS_BIGENDIAN
register unsigned char* data = dst.bits() + 1; // Skip alpha
unsigned char* data = dst.bits() + 1; // Skip alpha
#else
register unsigned char* data = dst.bits(); // Skip alpha
unsigned char* data = dst.bits(); // Skip alpha
#endif
for(register int i = 0; i < 16; i++) {
for(int i = 0; i < 16; i++) {
if (have_composite) {
data++;
data++;
@ -2051,8 +2051,8 @@ void TransparencyHandler::rightShadow(TQImage& dst)
}
pixels -= 32; // tint right strip without rounded edges.
register int c = 0;
for(register int i = 0; i < pixels; i++) {
int c = 0;
for(int i = 0; i < pixels; i++) {
if (have_composite) {
data++;
data++;
@ -2070,7 +2070,7 @@ void TransparencyHandler::rightShadow(TQImage& dst)
}
// tint bottom edge
for(register int i = 0; i < 16; i++) {
for(int i = 0; i < 16; i++) {
if (have_composite) {
data++;
data++;
@ -2099,15 +2099,15 @@ void TransparencyHandler::bottomShadow(TQImage& dst)
double* corner = const_cast<double*>(bottom_left_corner);
#ifdef WORDS_BIGENDIAN
register unsigned char* data = dst.bits() + 1; // Skip alpha
unsigned char* data = dst.bits() + 1; // Skip alpha
#else
register unsigned char* data = dst.bits(); // Skip alpha
unsigned char* data = dst.bits(); // Skip alpha
#endif
for(int y = 0; y < 4; y++)
{
// Bottom-left Corner
for(register int x = 0; x < 4; x++) {
for(int x = 0; x < 4; x++) {
if (have_composite) {
data++;
data++;
@ -2124,7 +2124,7 @@ void TransparencyHandler::bottomShadow(TQImage& dst)
}
// Scanline
for(register int x = 0; x < width; x++) {
for(int x = 0; x < width; x++) {
if (have_composite) {
data++;
data++;

14
tdehtml/css/cssproperties.c
Unescape View File

@ -39,7 +39,7 @@ struct props {
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 */
#ifdef __GNUC__
@ -50,7 +50,7 @@ inline
#endif
#endif
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[] =
{
@ -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
};
register int hval = len;
int hval = len;
switch (hval)
{
@ -189,7 +189,7 @@ hash_prop (register const char *str, register unsigned int len)
__inline
#endif
const struct props *
findProp (register const char *str, register unsigned int len)
findProp (register const char *str, unsigned int len)
{
enum
{
@ -516,15 +516,15 @@ findProp (register const char *str, register unsigned int len)
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)
{
register int index = lookup[key];
int index = lookup[key];
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')
return &wordlist_prop[index];

14
tdehtml/css/cssvalues.c
Unescape View File

@ -39,7 +39,7 @@ struct css_value {
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 */
#ifdef __GNUC__
@ -50,7 +50,7 @@ inline
#endif
#endif
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[] =
{
@ -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
};
register int hval = 0;
int hval = 0;
switch (len)
{
@ -177,7 +177,7 @@ hash_val (register const char *str, register unsigned int len)
__inline
#endif
const struct css_value *
findValue (register const char *str, register unsigned int len)
findValue (register const char *str, unsigned int len)
{
enum
{
@ -1036,15 +1036,15 @@ findValue (register const char *str, register unsigned int len)
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)
{
register int index = lookup[key];
int index = lookup[key];
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')
return &wordlist_value[index];

2
tdehtml/css/makeprop
Unescape View File

@ -23,7 +23,7 @@
#
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
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

2
tdehtml/css/makevalues
Unescape View File

@ -24,7 +24,7 @@
#
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
echo '%%' >> cssvalues.gperf
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) \
do \
{ \
register YYSIZE_T yyi; \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
@ -1122,7 +1122,7 @@ yystrlen (yystr)
const char *yystr;
# endif
{
register const char *yys = yystr;
const char *yys = yystr;
while (*yys++ != '\0')
continue;
@ -1147,8 +1147,8 @@ yystpcpy (yydest, yysrc)
const char *yysrc;
# endif
{
register char *yyd = yydest;
register const char *yys = yysrc;
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
@ -1338,8 +1338,8 @@ YYSTYPE yylval;
/* Number of syntax errors so far. */
int yynerrs;
register int yystate;
register int yyn;
int yystate;
int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
@ -1357,12 +1357,12 @@ int yynerrs;
/* The state stack. */
short int yyssa[YYINITDEPTH];
short int *yyss = yyssa;
register short int *yyssp;
short int *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
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
{
register yy_state_type yy_current_state;
register unsigned short *yy_cp, *yy_bp;
register int yy_act;
yy_state_type yy_current_state;
unsigned short *yy_cp, *yy_bp;
int yy_act;
#line 25 "tokenizer.flex"
@ -617,7 +617,7 @@ YY_DECL
yy_match:
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] )
{
yy_last_accepting_state = yy_current_state;

10
tdehtml/html/doctypes.cpp
Unescape View File

@ -51,7 +51,7 @@ inline
#endif
#endif
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[] =
{
@ -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
};
register int hval = len;
int hval = len;
switch (hval)
{
@ -334,7 +334,7 @@ hash (register const char *str, register unsigned int len)
__inline
#endif
const struct PubIDInfo *
findDoctypeEntry (register const char *str, register unsigned int len)
findDoctypeEntry (register const char *str, unsigned int len)
{
enum
{
@ -1160,11 +1160,11 @@ findDoctypeEntry (register const char *str, register unsigned int len)
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)
{
register const char *s = wordlist[key].name;
const char *s = wordlist[key].name;
if (*str == *s && !strcmp (str + 1, s + 1))
return &wordlist[key];

12
tdehtml/misc/htmlattrs.c
Unescape View File

@ -57,7 +57,7 @@ inline
#endif
#endif
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[] =
{
@ -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
};
register int hval = len;
int hval = len;
switch (hval)
{
@ -831,19 +831,19 @@ inline
#endif
#endif
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)
{
register int key = hash_attr (str, len);
int key = hash_attr (str, len);
if (key <= MAX_HASH_VALUE && key >= 0)
{
register int index = lookup[key];
int index = lookup[key];
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')
return &wordlist_attr[index];

12
tdehtml/misc/htmltags.c
Unescape View File

@ -48,7 +48,7 @@ inline
#endif
#endif
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[] =
{
@ -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
};
register int hval = len;
int hval = len;
switch (hval)
{
@ -338,7 +338,7 @@ static const struct spool_Tag_t spool_Tag_contents =
__inline
#endif
const struct tags *
findTag (register const char *str, register unsigned int len)
findTag (register const char *str, unsigned int len)
{
enum
{
@ -615,17 +615,17 @@ findTag (register const char *str, register unsigned int len)
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)
{
register int index = lookup[key];
int index = lookup[key];
if (index >= 0)
{
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))
return &wordlist_tag[index];

6
tdeinit/setproctitle.cpp
Unescape View File

@ -136,7 +136,7 @@ char *LastArgv = NULL; /* end of argv */
void
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)
extern char **environ;
#endif
@ -199,8 +199,8 @@ static void
setproctitle(const char *fmt, ...)
{
# if SPT_TYPE != SPT_NONE
register char *p;
register int i;
char *p;
int i;
SETPROC_STATIC char buf[SPT_BUFSIZE];
va_list ap;
# if SPT_TYPE == SPT_PSTAT

42
tdeio/tdeio/lex.c
Unescape View File

@ -590,9 +590,9 @@ YY_MALLOC_DECL
YY_DECL
{
register yy_state_type yy_current_state;
register char *yy_cp, *yy_bp;
register int yy_act;
yy_state_type yy_current_state;
char *yy_cp, *yy_bp;
int yy_act;
#line 21 "lex.l"
@ -639,7 +639,7 @@ YY_DECL
yy_match:
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] )
{
yy_last_accepting_state = yy_current_state;
@ -949,9 +949,9 @@ case YY_STATE_EOF(INITIAL):
static int yy_get_next_buffer()
{
register char *dest = yy_current_buffer->yy_ch_buf;
register char *source = yytext_ptr;
register int number_to_move, i;
char *dest = yy_current_buffer->yy_ch_buf;
char *source = yytext_ptr;
int number_to_move, i;
int ret_val;
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()
{
register yy_state_type yy_current_state;
register char *yy_cp;
yy_state_type yy_current_state;
char *yy_cp;
yy_current_state = yy_start;
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] )
{
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;
#endif
{
register int yy_is_jam;
register char *yy_cp = yy_c_buf_p;
int yy_is_jam;
char *yy_cp = yy_c_buf_p;
register YY_CHAR yy_c = 1;
YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
yy_last_accepting_state = yy_current_state;
@ -1144,14 +1144,14 @@ yy_state_type yy_current_state;
#ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS
static void yyunput( int c, register char *yy_bp )
static void yyunput( int c, char *yy_bp )
#else
static void yyunput( c, yy_bp )
int c;
register char *yy_bp;
char *yy_bp;
#endif
{
register char *yy_cp = yy_c_buf_p;
char *yy_cp = yy_c_buf_p;
/* undo effects of setting up yytext */
*yy_cp = yy_hold_char;
@ -1159,10 +1159,10 @@ register char *yy_bp;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
register int number_to_move = yy_n_chars + 2;
register char *dest = &yy_current_buffer->yy_ch_buf[
int number_to_move = yy_n_chars + 2;
char *dest = &yy_current_buffer->yy_ch_buf[
yy_current_buffer->yy_buf_size + 2];
register char *source =
char *source =
&yy_current_buffer->yy_ch_buf[number_to_move];
while ( source > yy_current_buffer->yy_ch_buf )
@ -1618,7 +1618,7 @@ yyconst char *s2;
int n;
#endif
{
register int i;
int i;
for ( i = 0; i < n; ++i )
s1[i] = s2[i];
}
@ -1632,7 +1632,7 @@ static int yy_flex_strlen( s )
yyconst char *s;
#endif
{
register int n;
int 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) \
do \
{ \
register YYSIZE_T yyi; \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
@ -694,7 +694,7 @@ yystrlen (yystr)
const char *yystr;
# endif
{
register const char *yys = yystr;
const char *yys = yystr;
while (*yys++ != '\0')
continue;
@ -719,8 +719,8 @@ yystpcpy (yydest, yysrc)
const char *yysrc;
# endif
{
register char *yyd = yydest;
register const char *yys = yysrc;
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
@ -855,8 +855,8 @@ yyparse ()
#endif
{
register int yystate;
register int yyn;
int yystate;
int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
@ -874,12 +874,12 @@ yyparse ()
/* The state stack. */
short int yyssa[YYINITDEPTH];
short int *yyss = yyssa;
register short int *yyssp;
short int *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
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)
{
register union { __extension__ unsigned long long int __ll;
union { __extension__ unsigned long long int __ll;
unsigned int __l[2]; } __x;
asm("xchgl %0,%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;
unsigned short sum;
boot_entry *defcur=NULL,*deflast=NULL;
register struct validation_entry *ventry=NULL;
struct validation_entry *ventry=NULL;
head->sections=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 ret=0;
register struct iso_supplementary_descriptor *isd;
struct iso_supplementary_descriptor *isd;
isd = (struct iso_supplementary_descriptor *) ivd;

20
tdeprint/fooparser.cpp
Unescape View File

@ -369,9 +369,9 @@ __yy_memcpy (to, from, count)
char *from;
unsigned int count;
{
register char *f = from;
register char *t = to;
register int i = count;
char *f = from;
char *t = to;
int i = count;
while (i-- > 0)
*t++ = *f++;
@ -384,9 +384,9 @@ __yy_memcpy (to, from, count)
static void
__yy_memcpy (char *to, char *from, unsigned int count)
{
register char *t = to;
register char *f = from;
register int i = count;
char *t = to;
char *f = from;
int i = count;
while (i-- > 0)
*t++ = *f++;
@ -429,10 +429,10 @@ int
yyparse(YYPARSE_PARAM_ARG)
YYPARSE_PARAM_DECL
{
register int yystate;
register int yyn;
register short *yyssp;
register YYSTYPE *yyvsp;
int yystate;
int yyn;
short *yyssp;
YYSTYPE *yyvsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */
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
{
register yy_state_type yy_current_state;
register char *yy_cp, *yy_bp;
register int yy_act;
yy_state_type yy_current_state;
char *yy_cp, *yy_bp;
int yy_act;
#line 47 "./fooscanner.l"
@ -664,7 +664,7 @@ YY_DECL
yy_match:
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] )
{
yy_last_accepting_state = yy_current_state;
@ -954,9 +954,9 @@ case YY_STATE_EOF(INITIAL):
static int yy_get_next_buffer()
{
register char *dest = yy_current_buffer->yy_ch_buf;
register char *source = yytext_ptr;
register int number_to_move, i;
char *dest = yy_current_buffer->yy_ch_buf;
char *source = yytext_ptr;
int number_to_move, i;
int ret_val;
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()
{
register yy_state_type yy_current_state;
register char *yy_cp;
yy_state_type yy_current_state;
char *yy_cp;
yy_current_state = yy_start;
yy_current_state += YY_AT_BOL();
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] )
{
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;
#endif
{
register int yy_is_jam;
register char *yy_cp = yy_c_buf_p;
int yy_is_jam;
char *yy_cp = yy_c_buf_p;
register YY_CHAR yy_c = 1;
YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
yy_last_accepting_state = yy_current_state;
@ -1150,14 +1150,14 @@ yy_state_type yy_current_state;
#ifndef YY_NO_UNPUT
#ifdef YY_USE_PROTOS
static void yyunput( int c, register char *yy_bp )
static void yyunput( int c, char *yy_bp )
#else
static void yyunput( c, yy_bp )
int c;
register char *yy_bp;
char *yy_bp;
#endif
{
register char *yy_cp = yy_c_buf_p;
char *yy_cp = yy_c_buf_p;
/* undo effects of setting up yytext */
*yy_cp = yy_hold_char;
@ -1165,10 +1165,10 @@ register char *yy_bp;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
register int number_to_move = yy_n_chars + 2;
register char *dest = &yy_current_buffer->yy_ch_buf[
int number_to_move = yy_n_chars + 2;
char *dest = &yy_current_buffer->yy_ch_buf[
yy_current_buffer->yy_buf_size + 2];
register char *source =
char *source =
&yy_current_buffer->yy_ch_buf[number_to_move];
while ( source > yy_current_buffer->yy_ch_buf )
@ -1625,7 +1625,7 @@ yyconst char *s2;
int n;
#endif
{
register int i;
int i;
for ( i = 0; i < n; ++i )
s1[i] = s2[i];
}
@ -1639,7 +1639,7 @@ static int yy_flex_strlen( s )
yyconst char *s;
#endif
{
register int n;
int 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) \
do \
{ \
register YYSIZE_T yyi; \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
@ -704,7 +704,7 @@ yystrlen (yystr)
const char *yystr;
# endif
{
register const char *yys = yystr;
const char *yys = yystr;
while (*yys++ != '\0')
continue;
@ -729,8 +729,8 @@ yystpcpy (yydest, yysrc)
const char *yysrc;
# endif
{
register char *yyd = yydest;
register const char *yys = yysrc;
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
@ -860,8 +860,8 @@ yyparse ()
#endif
{
register int yystate;
register int yyn;
int yystate;
int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
@ -879,12 +879,12 @@ yyparse ()
/* The state stack. */
short yyssa[YYINITDEPTH];
short *yyss = yyssa;
register short *yyssp;
short *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp;
YYSTYPE *yyvsp;

42
tdeprint/ppdscanner.cpp
Unescape View File

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

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

@ -244,8 +244,8 @@ int compoundflag = COMPOUND_CONTROLLED;
int
ISpellChecker::casecmp (char *a, char *b, int canonical)
{
register ichar_t * ap;
register ichar_t * bp;
ichar_t * ap;
ichar_t * bp;
ichar_t inta[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
ichar_t intb[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
@ -290,7 +290,7 @@ ISpellChecker::casecmp (char *a, char *b, int canonical)
void
ISpellChecker::makepossibilities (ichar_t *word)
{
register int i;
int i;
for (i = 0; i < MAXPOSSIBLE; i++)
m_possibilities[i][0] = 0;
@ -332,8 +332,8 @@ ISpellChecker::makepossibilities (ichar_t *word)
int
ISpellChecker::insert (ichar_t *word)
{
register int i;
register char * realword;
int i;
char * realword;
realword = ichartosstr (word, 0);
for (i = 0; i < m_pcount; i++)
@ -381,9 +381,9 @@ ISpellChecker::wrongcapital (ichar_t *word)
void
ISpellChecker::wrongletter (ichar_t *word)
{
register int i;
register int j;
register int n;
int i;
int j;
int n;
ichar_t savechar;
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
@ -420,8 +420,8 @@ void
ISpellChecker::extraletter (ichar_t *word)
{
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p;
register ichar_t * r;
ichar_t * p;
ichar_t * r;
if (icharlen (word) < 2)
return;
@ -445,9 +445,9 @@ void
ISpellChecker::missingletter (ichar_t *word)
{
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN + 1];
register ichar_t * p;
register ichar_t * r;
register int i;
ichar_t * p;
ichar_t * r;
int i;
icharcpy (newword + 1, word);
for (p = word, r = newword; *p != 0; )
@ -489,7 +489,7 @@ void ISpellChecker::missingspace (ichar_t *word)
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN + 1];
int nfirsthalf; /* No. words saved in 1st half */
int nsecondhalf; /* No. words saved in 2nd half */
register ichar_t * p;
ichar_t * p;
ichar_t secondhalf[MAX_CAPS][INPUTWORDLEN + MAXAFFIXLEN];
int secondno; /* Index into second */
@ -547,8 +547,8 @@ int
ISpellChecker::compoundgood (ichar_t *word, int pfxopts)
{
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p;
register ichar_t savech;
ichar_t * p;
ichar_t savech;
long secondcap; /* Capitalization of 2nd half */
/*
@ -606,8 +606,8 @@ void
ISpellChecker::transposedletter (ichar_t *word)
{
ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p;
register ichar_t temp;
ichar_t * p;
ichar_t temp;
icharcpy (newword, word);
for (p = newword; p[1] != 0; p++)
@ -752,12 +752,12 @@ ISpellChecker::save_root_cap (ichar_t *word, ichar_t *pattern,
int * nsaved)
{
#ifndef NO_CAPITALIZATION_SUPPORT
register struct dent * dent;
struct dent * dent;
#endif /* NO_CAPITALIZATION_SUPPORT */
int firstisupper;
ichar_t newword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
#ifndef NO_CAPITALIZATION_SUPPORT
register ichar_t * p;
ichar_t * p;
int len;
int i;
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)
{
register ichar_t * dword;
register ichar_t * w;
register struct dent * dent;
ichar_t * dword;
ichar_t * w;
struct dent * dent;
ichar_t dentword[INPUTWORDLEN + MAXAFFIXLEN];
int preadd;
int prestrip;
@ -388,10 +388,10 @@ int ISpellChecker::good (ichar_t *w, int ignoreflagbits, int dummy, int pfxopts,
#endif
{
ichar_t nword[INPUTWORDLEN + MAXAFFIXLEN];
register ichar_t * p;
register ichar_t * q;
register int n;
register struct dent * dp;
ichar_t * p;
ichar_t * q;
int n;
struct dent * dp;
/*
** 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)
{
register long h = 0;
register int i;
long h = 0;
int i;
#ifdef ICHAR_IS_CHAR
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;
register int i;
register struct dent * dp;
int i;
struct dent * dp;
struct flagent * entry;
struct flagptr * ind;
int nextchar, x;
int viazero;
register ichar_t * cp;
ichar_t * cp;
if ((fpHash = fopen (hashname, "rb")) == NULL)
{
@ -571,7 +571,7 @@ int ISpellChecker::linit (char *hashname)
*/
void ISpellChecker::initckch (char *wchars)
{
register ichar_t c;
ichar_t c;
char num[4];
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)
{
register int i;
int i;
for (i = 0; i < SET_SIZE + m_hashheader.nstrchars; i++, indexp++)
{
if (indexp->numents == 0 && indexp->pu.fp != NULL)
@ -669,10 +669,10 @@ void ISpellChecker::clearindex (struct flagptr *indexp)
#ifdef INDEXDUMP
static void dumpindex (indexp, depth)
register struct flagptr * indexp;
register int depth;
struct flagptr * indexp;
int depth;
{
register int i;
int i;
int j;
int k;
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)
{
register struct dent * dp;
register char * s1;
struct dent * dp;
char * s1;
char schar[INPUTWORDLEN + MAXAFFIXLEN];
dp = &m_hashtbl[hash (s, m_hashsize)];

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

@ -259,7 +259,7 @@ other abi documents
long
ISpellChecker::whatcap (ichar_t *word)
{
register ichar_t * p;
ichar_t * p;
for (p = word; *p; p++)
{
@ -311,7 +311,7 @@ ISpellChecker::whatcap (ichar_t *word)
*/
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
@ -502,11 +502,11 @@ ISpellChecker::stringcharlen (char *bufp, int canonical)
static char * sp[MAXSTRINGCHARS];
static int inited = 0;
#endif /* SLOWMULTIPLY */
register char * bufcur;
register char * stringcur;
register int stringno;
register int lowstringno;
register int highstringno;
char * bufcur;
char * stringcur;
int stringno;
int lowstringno;
int highstringno;
int dupwanted;
#ifdef SLOWMULTIPLY
@ -641,7 +641,7 @@ int l1_isstringch(char *ptr, int len, int canon) {
int
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 */
for ( ; --outlen > 0 && *in != '\0'; in += len)
@ -674,9 +674,9 @@ ISpellChecker::strtoichar (ichar_t *out, char *in, int outlen, int canonical)
int
ISpellChecker::ichartostr ( char *out, ichar_t *in, int outlen, int canonical)
{
register int ch; /* Next character to store */
register int i; /* Index into duplicates list */
register char * scharp; /* Pointer into a string char */
int ch; /* Next character to store */
int i; /* Index into duplicates list */
char * scharp; /* Pointer into a string char */
while (--outlen > 0 && (ch = *in++) != 0)
{
@ -796,7 +796,7 @@ icharcpy (ichar_t *out, ichar_t *in)
int
icharlen (ichar_t * in)
{
register int len; /* Length so far */
int len; /* Length so far */
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 */
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 */
/*

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

@ -243,7 +243,7 @@
void ISpellChecker::chk_aff (ichar_t *word, ichar_t *ucword,
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 */
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 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 */
int entcount; /* Number of entries to process */
register struct flagent *
struct flagent *
flent; /* Current table entry */
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 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 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 */
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,
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 */
struct dent * dent; /* Dictionary entry we found */
int entcount; /* Number of entries to process */
register struct flagent *
struct flagent *
flent; /* Current table entry */
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 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 explength; /* Length of expansions */
register struct flagent *
struct flagent *
flent; /* Current table entry */
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)
{
int cond; /* Current condition number */
register ichar_t * nextc; /* Next case choice */
ichar_t * nextc; /* Next case choice */
int tlen; /* Length of tword */
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 explength; /* Length of expansions */
register struct flagent *
struct flagent *
flent; /* Current table entry */
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)
{
int cond; /* Current condition number */
register ichar_t * nextc; /* Next case choice */
ichar_t * nextc; /* Next case choice */
int tlen; /* Length of tword */
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 rc, gc, bc;
register int x, y;
int x, y;
rDiff = ( c2.red()) - (rc = c1.red());
gDiff = ( c2.green()) - (gc = c1.green());
bDiff = ( c2.blue()) - (bc = c1.blue());
register int rl = rc << 16;
register int gl = gc << 16;
register int bl = bc << 16;
int rl = rc << 16;
int gl = gc << 16;
int bl = bc << 16;
int rdelta = ((1<<16) / (horizontal ? r_h : r_w)) * rDiff;
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
KLedTest::nextLook() {
register int tmp;
int tmp;
if (kled_round) {
tmp = (static_cast<int>(ledlook) +1 ) % 3 ;
}

Write Preview
Loading…
Cancel
Save