Removes the deprecated keyword "register"

This commit is contained in:
Markus Gans 2018-09-12 22:51:15 +02:00
parent fc45c3c1a5
commit 0a5d5aa59c
33 changed files with 213 additions and 197 deletions

View File

@ -1,3 +1,7 @@
2018-09-12 Markus Gans <guru.mail@muenster.de>
* Removes the deprecated keyword "register"
from the source code
2018-09-02 Markus Gans <guru.mail@muenster.de> 2018-09-02 Markus Gans <guru.mail@muenster.de>
* Fix mouse wheel behavior over horizontal scroll bars * Fix mouse wheel behavior over horizontal scroll bars
in FTextView in FTextView

View File

@ -44,8 +44,11 @@
class FColorPalette class FColorPalette
{ {
public: public:
// Constructor
explicit FColorPalette();
// Destructor // Destructor
virtual ~FColorPalette() = 0; virtual ~FColorPalette();
// Typedefs // Typedefs
typedef void (*funcp)(short, int, int, int); typedef void (*funcp)(short, int, int, int);

View File

@ -96,7 +96,7 @@ class FObject
// Timer methods // Timer methods
static void getCurrentTime (timeval*); static void getCurrentTime (timeval*);
static bool isTimeout (timeval*, register long); static bool isTimeout (timeval*, long);
int addTimer (int); int addTimer (int);
bool delTimer (int); bool delTimer (int);
bool delOwnTimer(); bool delOwnTimer();

View File

@ -213,7 +213,7 @@ class FOptiAttr
// Methods // Methods
void initialize(); void initialize();
static short vga2ansi (register short); static short vga2ansi (short);
char* changeAttribute (charData*&, charData*&); char* changeAttribute (charData*&, charData*&);
private: private:

View File

@ -4,7 +4,7 @@
* * * *
* This file is part of the Final Cut widget toolkit * * This file is part of the Final Cut widget toolkit *
* * * *
* Copyright 2017 Markus Gans * * Copyright 2017-2018 Markus Gans *
* * * *
* The Final Cut is free software; you can redistribute it and/or * * The Final Cut is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public License * * modify it under the terms of the GNU Lesser General Public License *
@ -99,8 +99,8 @@ class FScrollView : public FWidget
virtual void setHeight (int, bool = true); virtual void setHeight (int, bool = true);
virtual void setSize (int, int, bool = true); virtual void setSize (int, int, bool = true);
void setGeometry (int, int, int, int, bool = true); void setGeometry (int, int, int, int, bool = true);
void setCursorPos (register int, register int); void setCursorPos (int, int);
void setPrintPos (register int, register int); void setPrintPos (int, int);
bool setViewportPrint (bool); bool setViewportPrint (bool);
bool setViewportPrint(); bool setViewportPrint();
bool unsetViewportPrint(); bool unsetViewportPrint();

View File

@ -296,11 +296,11 @@ class FTerm
static void putstring (const char[], int = 1); static void putstring (const char[], int = 1);
#if defined(__sun) && defined(__SVR4) #if defined(__sun) && defined(__SVR4)
static int putchar_ASCII (register char); static int putchar_ASCII (char);
#endif #endif
static int putchar_ASCII (register int); static int putchar_ASCII (int);
static int putchar_UTF8 (register int); static int putchar_UTF8 (int);
#if DEBUG #if DEBUG
static int framebuffer_bpp; static int framebuffer_bpp;

View File

@ -180,6 +180,7 @@ class FTermDetection
static char* parseAnswerbackMsg (char[]); static char* parseAnswerbackMsg (char[]);
static const FString getAnswerbackMsg(); static const FString getAnswerbackMsg();
static char* parseSecDA (char[]); static char* parseSecDA (char[]);
static int str2int (const FString&);
static const FString getSecDA(); static const FString getSecDA();
static char* secDA_Analysis (char[]); static char* secDA_Analysis (char[]);
static char* secDA_Analysis_0 (char[]); static char* secDA_Analysis_0 (char[]);

View File

@ -128,76 +128,76 @@ class FVTerm : public FTerm
static charData getAttribute(); static charData getAttribute();
// Mutators // Mutators
static void setTermXY (register int, register int); static void setTermXY (int, int);
static void hideCursor (bool); static void hideCursor (bool);
static void hideCursor(); static void hideCursor();
static void showCursor(); static void showCursor();
void setPrintCursor (const FPoint&); void setPrintCursor (const FPoint&);
void setPrintCursor (register int, register int); void setPrintCursor (int, int);
void setColor (short, short); void setColor (short, short);
static void setNormal(); static void setNormal();
static bool setBold (register bool); static bool setBold (bool);
static bool setBold(); static bool setBold();
static bool unsetBold(); static bool unsetBold();
static bool setDim (register bool); static bool setDim (bool);
static bool setDim(); static bool setDim();
static bool unsetDim(); static bool unsetDim();
static bool setItalic (register bool); static bool setItalic (bool);
static bool setItalic(); static bool setItalic();
static bool unsetItalic(); static bool unsetItalic();
static bool setUnderline (register bool); static bool setUnderline (bool);
static bool setUnderline(); static bool setUnderline();
static bool unsetUnderline(); static bool unsetUnderline();
static bool setBlink (register bool); static bool setBlink (bool);
static bool setBlink(); static bool setBlink();
static bool unsetBlink(); static bool unsetBlink();
static bool setReverse (register bool); static bool setReverse (bool);
static bool setReverse(); static bool setReverse();
static bool unsetReverse(); static bool unsetReverse();
static bool setStandout (register bool); static bool setStandout (bool);
static bool setStandout(); static bool setStandout();
static bool unsetStandout(); static bool unsetStandout();
static bool setInvisible (register bool); static bool setInvisible (bool);
static bool setInvisible(); static bool setInvisible();
static bool unsetInvisible(); static bool unsetInvisible();
static bool setProtected (register bool); static bool setProtected (bool);
static bool setProtected(); static bool setProtected();
static bool unsetProtected(); static bool unsetProtected();
static bool setCrossedOut (register bool); static bool setCrossedOut (bool);
static bool setCrossedOut(); static bool setCrossedOut();
static bool unsetCrossedOut(); static bool unsetCrossedOut();
static bool setDoubleUnderline (register bool); static bool setDoubleUnderline (bool);
static bool setDoubleUnderline(); static bool setDoubleUnderline();
static bool unsetDoubleUnderline(); static bool unsetDoubleUnderline();
static bool setAltCharset (register bool); static bool setAltCharset (bool);
static bool setAltCharset(); static bool setAltCharset();
static bool unsetAltCharset(); static bool unsetAltCharset();
static bool setPCcharset (register bool); static bool setPCcharset (bool);
static bool setPCcharset(); static bool setPCcharset();
static bool unsetPCcharset(); static bool unsetPCcharset();
static bool setTransparent (register bool); static bool setTransparent (bool);
static bool setTransparent(); static bool setTransparent();
static bool unsetTransparent(); static bool unsetTransparent();
static bool setTransShadow (register bool); static bool setTransShadow (bool);
static bool setTransShadow(); static bool setTransShadow();
static bool unsetTransShadow(); static bool unsetTransShadow();
static bool setInheritBackground (register bool); static bool setInheritBackground (bool);
static bool setInheritBackground(); static bool setInheritBackground();
static bool unsetInheritBackground(); static bool unsetInheritBackground();
@ -564,7 +564,7 @@ inline void FVTerm::setPrintCursor (const FPoint& pos)
{ setPrintCursor (pos.getX(), pos.getY()); } { setPrintCursor (pos.getX(), pos.getY()); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline void FVTerm::setColor (register short fg, register short bg) inline void FVTerm::setColor (short fg, short bg)
{ {
// Changes colors // Changes colors
next_attribute.fg_color = fg; next_attribute.fg_color = fg;
@ -583,7 +583,7 @@ inline void FVTerm::setNormal()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setBold (register bool on) inline bool FVTerm::setBold (bool on)
{ return (next_attribute.attr.bit.bold = on); } { return (next_attribute.attr.bit.bold = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -595,7 +595,7 @@ inline bool FVTerm::unsetBold()
{ return setBold(false); } { return setBold(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setDim (register bool on) inline bool FVTerm::setDim (bool on)
{ return (next_attribute.attr.bit.dim = on); } { return (next_attribute.attr.bit.dim = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -607,7 +607,7 @@ inline bool FVTerm::unsetDim()
{ return setDim(false); } { return setDim(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setItalic (register bool on) inline bool FVTerm::setItalic (bool on)
{ return (next_attribute.attr.bit.italic = on); } { return (next_attribute.attr.bit.italic = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -619,7 +619,7 @@ inline bool FVTerm::unsetItalic()
{ return setItalic(false); } { return setItalic(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setUnderline (register bool on) inline bool FVTerm::setUnderline (bool on)
{ return (next_attribute.attr.bit.underline = on); } { return (next_attribute.attr.bit.underline = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -631,7 +631,7 @@ inline bool FVTerm::unsetUnderline()
{ return setUnderline(false); } { return setUnderline(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setBlink (register bool on) inline bool FVTerm::setBlink (bool on)
{ return (next_attribute.attr.bit.blink = on); } { return (next_attribute.attr.bit.blink = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -643,7 +643,7 @@ inline bool FVTerm::unsetBlink()
{ return setBlink(false); } { return setBlink(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setReverse (register bool on) inline bool FVTerm::setReverse (bool on)
{ return (next_attribute.attr.bit.reverse = on); } { return (next_attribute.attr.bit.reverse = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -655,7 +655,7 @@ inline bool FVTerm::unsetReverse()
{ return setReverse(false); } { return setReverse(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setStandout (register bool on) inline bool FVTerm::setStandout (bool on)
{ return (next_attribute.attr.bit.standout = on); } { return (next_attribute.attr.bit.standout = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -667,7 +667,7 @@ inline bool FVTerm::unsetStandout()
{ return setStandout(false); } { return setStandout(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setInvisible (register bool on) inline bool FVTerm::setInvisible (bool on)
{ return (next_attribute.attr.bit.invisible = on); } { return (next_attribute.attr.bit.invisible = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -679,7 +679,7 @@ inline bool FVTerm::unsetInvisible()
{ return setInvisible(false); } { return setInvisible(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setProtected (register bool on) inline bool FVTerm::setProtected (bool on)
{ return (next_attribute.attr.bit.protect = on); } { return (next_attribute.attr.bit.protect = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -691,7 +691,7 @@ inline bool FVTerm::unsetProtected()
{ return setProtected(false); } { return setProtected(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setCrossedOut (register bool on) inline bool FVTerm::setCrossedOut (bool on)
{ return (next_attribute.attr.bit.crossed_out = on); } { return (next_attribute.attr.bit.crossed_out = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -703,7 +703,7 @@ inline bool FVTerm::unsetCrossedOut()
{ return setCrossedOut(false); } { return setCrossedOut(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setDoubleUnderline (register bool on) inline bool FVTerm::setDoubleUnderline (bool on)
{ return (next_attribute.attr.bit.dbl_underline = on); } { return (next_attribute.attr.bit.dbl_underline = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -715,7 +715,7 @@ inline bool FVTerm::unsetDoubleUnderline()
{ return setDoubleUnderline(false); } { return setDoubleUnderline(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setAltCharset (register bool on) inline bool FVTerm::setAltCharset (bool on)
{ return (next_attribute.attr.bit.alt_charset = on); } { return (next_attribute.attr.bit.alt_charset = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -727,7 +727,7 @@ inline bool FVTerm::unsetAltCharset()
{ return setAltCharset(false); } { return setAltCharset(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setPCcharset (register bool on) inline bool FVTerm::setPCcharset (bool on)
{ return (next_attribute.attr.bit.pc_charset = on); } { return (next_attribute.attr.bit.pc_charset = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -739,7 +739,7 @@ inline bool FVTerm::unsetPCcharset()
{ return setPCcharset(false); } { return setPCcharset(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setTransparent (register bool on) inline bool FVTerm::setTransparent (bool on)
{ return (next_attribute.attr.bit.transparent = on); } { return (next_attribute.attr.bit.transparent = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -751,7 +751,7 @@ inline bool FVTerm::unsetTransparent()
{ return setTransparent(false); } { return setTransparent(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setTransShadow (register bool on) inline bool FVTerm::setTransShadow (bool on)
{ return (next_attribute.attr.bit.trans_shadow = on); } { return (next_attribute.attr.bit.trans_shadow = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -763,7 +763,7 @@ inline bool FVTerm::unsetTransShadow()
{ return setTransShadow(false); } { return setTransShadow(false); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::setInheritBackground (register bool on) inline bool FVTerm::setInheritBackground (bool on)
{ return (next_attribute.attr.bit.inherit_bg = on); } { return (next_attribute.attr.bit.inherit_bg = on); }
//---------------------------------------------------------------------- //----------------------------------------------------------------------

View File

@ -241,10 +241,10 @@ class FWidget : public FVTerm, public FObject
void setMaximumSize (int, int); void setMaximumSize (int, int);
void setFixedSize (int, int); void setFixedSize (int, int);
bool setCursorPos (const FPoint&); bool setCursorPos (const FPoint&);
bool setCursorPos (register int, register int); bool setCursorPos (int, int);
void unsetCursorPos(); void unsetCursorPos();
void setPrintPos (const FPoint&); void setPrintPos (const FPoint&);
void setPrintPos (register int, register int); void setPrintPos (int, int);
void setDoubleFlatLine (fc::sides, bool = true); void setDoubleFlatLine (fc::sides, bool = true);
void unsetDoubleFlatLine (fc::sides); void unsetDoubleFlatLine (fc::sides);
void setDoubleFlatLine (fc::sides, int, bool = true); void setDoubleFlatLine (fc::sides, int, bool = true);

View File

@ -288,13 +288,14 @@ void FButton::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
std::cerr << "not enough memory to alloc " << ex.what() << std::endl; std::cerr << "not enough memory to alloc " << ex.what() << std::endl;
return; return;
} }
std::memset(blank, ' ', uLong(size)); std::memset(blank, ' ', uLong(size));
blank[size] = '\0'; blank[size] = '\0';
@ -751,7 +752,7 @@ void FButton::draw()
try try
{ {
button_text = new wchar_t[txtlength + 1](); button_text = new wchar_t[uInt(txtlength) + 1]();
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -226,7 +226,7 @@ void FButtonGroup::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -27,6 +27,16 @@
// class FColorPalette // class FColorPalette
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// constructors and destructor
//----------------------------------------------------------------------
FColorPalette::FColorPalette()
{ }
//----------------------------------------------------------------------
FColorPalette::~FColorPalette() // destructor
{ }
// public methods of FColorPalette // public methods of FColorPalette
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FColorPalette::set8ColorPalette (funcp setPalette) void FColorPalette::set8ColorPalette (funcp setPalette)

View File

@ -132,7 +132,7 @@ bool& FKeyboard::unprocessedInput()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FKeyboard::isKeyPressed() bool FKeyboard::isKeyPressed()
{ {
register int result; int result;
fd_set ifds; fd_set ifds;
struct timeval tv; struct timeval tv;
int stdin_no = FTermios::getStdIn(); int stdin_no = FTermios::getStdIn();
@ -202,7 +202,7 @@ inline int FKeyboard::getMouseProtocolKey()
if ( ! mouse_support ) if ( ! mouse_support )
return -1; return -1;
register std::size_t buf_len = std::strlen(fifo_buf); std::size_t buf_len = std::strlen(fifo_buf);
// x11 mouse tracking // x11 mouse tracking
if ( buf_len >= 6 && fifo_buf[1] == '[' && fifo_buf[2] == 'M' ) if ( buf_len >= 6 && fifo_buf[1] == '[' && fifo_buf[2] == 'M' )
@ -236,11 +236,11 @@ inline int FKeyboard::getTermcapKey()
for (int i = 0; keymap[i].tname[0] != 0; i++) for (int i = 0; keymap[i].tname[0] != 0; i++)
{ {
char* k = keymap[i].string; char* k = keymap[i].string;
register int len = ( k ) ? int(std::strlen(k)) : 0; int len = ( k ) ? int(std::strlen(k)) : 0;
if ( k && std::strncmp(k, fifo_buf, uInt(len)) == 0 ) // found if ( k && std::strncmp(k, fifo_buf, uInt(len)) == 0 ) // found
{ {
register int n; int n;
for (n = len; n < fifo_buf_size; n++) // Remove founded entry for (n = len; n < fifo_buf_size; n++) // Remove founded entry
fifo_buf[n - len] = fifo_buf[n]; fifo_buf[n - len] = fifo_buf[n];
@ -266,11 +266,11 @@ inline int FKeyboard::getMetaKey()
for (int i = 0; fc::Fmetakey[i].string[0] != 0; i++) for (int i = 0; fc::Fmetakey[i].string[0] != 0; i++)
{ {
char* kmeta = fc::Fmetakey[i].string; // The string is never null char* kmeta = fc::Fmetakey[i].string; // The string is never null
register int len = int(std::strlen(kmeta)); int len = int(std::strlen(kmeta));
if ( std::strncmp(kmeta, fifo_buf, uInt(len)) == 0 ) // found if ( std::strncmp(kmeta, fifo_buf, uInt(len)) == 0 ) // found
{ {
register int n; int n;
if ( len == 2 && ( fifo_buf[1] == 'O' if ( len == 2 && ( fifo_buf[1] == 'O'
|| fifo_buf[1] == '[' || fifo_buf[1] == '['
@ -299,7 +299,7 @@ inline int FKeyboard::getSingleKey()
{ {
// Looking for single key code in the buffer // Looking for single key code in the buffer
register uChar firstchar = uChar(fifo_buf[0]); uChar firstchar = uChar(fifo_buf[0]);
int keycode, n, len; int keycode, n, len;
len = 1; len = 1;
@ -370,16 +370,16 @@ bool FKeyboard::isKeypressTimeout()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FKeyboard::UTF8decode (const char utf8[]) int FKeyboard::UTF8decode (const char utf8[])
{ {
register int ucs = 0; int ucs = 0;
const int max = 4; const int max = 4;
int len = int(std::strlen(utf8)); int len = int(std::strlen(utf8));
if ( len > max ) if ( len > max )
len = max; len = max;
for (register int i = 0; i < len; ++i) for (int i = 0; i < len; ++i)
{ {
register uChar ch = uChar(utf8[i]); uChar ch = uChar(utf8[i]);
if ( (ch & 0xc0) == 0x80 ) if ( (ch & 0xc0) == 0x80 )
{ {
@ -419,7 +419,7 @@ int FKeyboard::UTF8decode (const char utf8[])
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline ssize_t FKeyboard::readKey() inline ssize_t FKeyboard::readKey()
{ {
register ssize_t bytes; ssize_t bytes;
setNonBlockingInput(); setNonBlockingInput();
bytes = read(FTermios::getStdIn(), &k_buf, sizeof(k_buf) - 1); bytes = read(FTermios::getStdIn(), &k_buf, sizeof(k_buf) - 1);
unsetNonBlockingInput(); unsetNonBlockingInput();
@ -429,7 +429,7 @@ inline ssize_t FKeyboard::readKey()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FKeyboard::parseKeyBuffer() void FKeyboard::parseKeyBuffer()
{ {
register ssize_t bytesread; ssize_t bytesread;
FObject::getCurrentTime (&time_keypressed); FObject::getCurrentTime (&time_keypressed);
while ( (bytesread = readKey()) > 0 ) while ( (bytesread = readKey()) > 0 )

View File

@ -265,7 +265,7 @@ void FLabel::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -306,7 +306,7 @@ void FLineEdit::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -3,7 +3,7 @@
* * * *
* This file is part of the Final Cut widget toolkit * * This file is part of the Final Cut widget toolkit *
* * * *
* Copyright 2014-2017 Markus Gans * * Copyright 2014-2018 Markus Gans *
* * * *
* The Final Cut is free software; you can redistribute it and/or * * The Final Cut is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public License * * modify it under the terms of the GNU Lesser General Public License *
@ -265,7 +265,7 @@ void FListBox::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -400,7 +400,7 @@ void FListBox::clear()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -68,7 +68,7 @@ void FMenuBar::hide()
try try
{ {
blank = new char[screenWidth + 1]; blank = new char[uInt(screenWidth) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -424,8 +424,8 @@ void FMouseGPM::drawGpmPointer()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FMouseGPM::gpmEvent (bool clear) int FMouseGPM::gpmEvent (bool clear)
{ {
register int result; int result;
register int max = ( gpm_fd > stdin_no ) ? gpm_fd : stdin_no; int max = ( gpm_fd > stdin_no ) ? gpm_fd : stdin_no;
fd_set ifds; fd_set ifds;
struct timeval tv; struct timeval tv;
@ -722,7 +722,7 @@ void FMouseSGR::setRawData (char fifo_buf[], int fifo_buf_size)
void FMouseSGR::processEvent (struct timeval* time) void FMouseSGR::processEvent (struct timeval* time)
{ {
const FPoint& mouse_position = getPos(); const FPoint& mouse_position = getPos();
register char* p; char* p;
int btn; int btn;
short x, y; short x, y;
@ -977,9 +977,9 @@ void FMouseUrxvt::processEvent (struct timeval* time)
// Parse and interpret the X11 xterm mouse string (Urxvt-Mode) // Parse and interpret the X11 xterm mouse string (Urxvt-Mode)
const FPoint& mouse_position = getPos(); const FPoint& mouse_position = getPos();
register char* p; char* p;
register bool x_neg; bool x_neg;
register bool y_neg; bool y_neg;
int btn; int btn;
short x, y; short x, y;

View File

@ -205,11 +205,11 @@ void FObject::getCurrentTime (timeval* time)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FObject::isTimeout (timeval* time, register long timeout) bool FObject::isTimeout (timeval* time, long timeout)
{ {
// Checks whether the specified time span (timeout in µs) has elapse // Checks whether the specified time span (timeout in µs) has elapse
register long diff_usec; long diff_usec;
struct timeval now; struct timeval now;
struct timeval diff; struct timeval diff;

View File

@ -549,7 +549,7 @@ void FOptiAttr::initialize()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
short FOptiAttr::vga2ansi (register short color) short FOptiAttr::vga2ansi (short color)
{ {
// VGA | ANSI // VGA | ANSI
// i R G B | i B G R // i R G B | i B G R

View File

@ -666,9 +666,9 @@ int FOptiMove::repeatedAppend ( const capability& o
, volatile int count , volatile int count
, char* dst ) , char* dst )
{ {
register std::size_t src_len; std::size_t src_len;
register std::size_t dst_len; std::size_t dst_len;
register int total; int total;
src_len = std::strlen(o.cap); src_len = std::strlen(o.cap);
dst_len = ( dst != 0 ) ? std::strlen(dst) : 0; dst_len = ( dst != 0 ) ? std::strlen(dst) : 0;

View File

@ -3,7 +3,7 @@
* * * *
* This file is part of the Final Cut widget toolkit * * This file is part of the Final Cut widget toolkit *
* * * *
* Copyright 2014-2017 Markus Gans * * Copyright 2014-2018 Markus Gans *
* * * *
* The Final Cut is free software; you can redistribute it and/or * * The Final Cut is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public License * * modify it under the terms of the GNU Lesser General Public License *
@ -124,7 +124,7 @@ void FProgressbar::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -270,13 +270,13 @@ void FScrollView::setGeometry (int x, int y, int w, int h, bool adjust)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FScrollView::setCursorPos (register int x, register int y) void FScrollView::setCursorPos (int x, int y)
{ {
FWidget::setCursorPos (x + getLeftPadding(), y + getTopPadding()); FWidget::setCursorPos (x + getLeftPadding(), y + getTopPadding());
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FScrollView::setPrintPos (register int x, register int y) void FScrollView::setPrintPos (int x, int y)
{ {
FWidget::setPrintPos (x + getLeftPadding(), y + getTopPadding()); FWidget::setPrintPos (x + getLeftPadding(), y + getTopPadding());
} }

View File

@ -208,7 +208,7 @@ void FStatusBar::hide()
try try
{ {
blank = new char[screenWidth + 1]; blank = new char[uInt(screenWidth) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -85,8 +85,8 @@ FString::FString (uInt len, wchar_t c)
, bufsize(0) , bufsize(0)
, c_string(0) , c_string(0)
{ {
register wchar_t* ps; wchar_t* ps;
register wchar_t* pe; wchar_t* pe;
initLength(len); initLength(len);
ps = string; ps = string;
@ -121,8 +121,8 @@ FString::FString (uInt len, char c)
, bufsize(0) , bufsize(0)
, c_string(0) , c_string(0)
{ {
register wchar_t* ps; wchar_t* ps;
register wchar_t* pe; wchar_t* pe;
initLength(len); initLength(len);
ps = string; ps = string;
@ -798,9 +798,11 @@ FString& FString::sprintf (const char format[], ...)
if ( len >= int(sizeof(buf)) ) if ( len >= int(sizeof(buf)) )
{ {
uLong buf_size = uInt(len) + 1;
try try
{ {
buffer = new char[len + 1](); buffer = new char[buf_size]();
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -809,7 +811,7 @@ FString& FString::sprintf (const char format[], ...)
} }
va_start (args, format); va_start (args, format);
vsnprintf (buffer, uLong(len + 1), format, args); vsnprintf (buffer, buf_size, format, args);
va_end (args); va_end (args);
} }
@ -890,7 +892,7 @@ const std::string FString::toString() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::toLower() const FString FString::toLower() const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
p = s.string; p = s.string;
@ -909,7 +911,7 @@ FString FString::toLower() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::toUpper() const FString FString::toUpper() const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
p = s.string; p = s.string;
@ -928,7 +930,7 @@ FString FString::toUpper() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
sInt16 FString::toShort() const sInt16 FString::toShort() const
{ {
register long num; long num;
num = toLong(); num = toLong();
if ( num > SHRT_MAX ) if ( num > SHRT_MAX )
@ -943,7 +945,7 @@ sInt16 FString::toShort() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
uInt16 FString::toUShort() const uInt16 FString::toUShort() const
{ {
register uLong num; uLong num;
num = uLong(toULong()); num = uLong(toULong());
if ( num > USHRT_MAX ) if ( num > USHRT_MAX )
@ -955,7 +957,7 @@ uInt16 FString::toUShort() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FString::toInt() const int FString::toInt() const
{ {
register long num; long num;
num = toLong(); num = toLong();
if ( num > INT_MAX ) if ( num > INT_MAX )
@ -970,7 +972,7 @@ int FString::toInt() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
uInt FString::toUInt() const uInt FString::toUInt() const
{ {
register uLong num; uLong num;
num = uLong(toULong()); num = uLong(toULong());
if ( num > UINT_MAX ) if ( num > UINT_MAX )
@ -982,11 +984,11 @@ uInt FString::toUInt() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
long FString::toLong() const long FString::toLong() const
{ {
register bool neg; bool neg;
register long num; long num;
register long tenth_limit; long tenth_limit;
register long tenth_limit_digit; long tenth_limit_digit;
register wchar_t* p; wchar_t* p;
FString s; FString s;
neg = false; neg = false;
@ -1016,7 +1018,7 @@ long FString::toLong() const
while ( std::iswdigit(wint_t(*p)) ) while ( std::iswdigit(wint_t(*p)) )
{ {
register uChar d = uChar((*p) - L'0'); uChar d = uChar((*p) - L'0');
if ( num > tenth_limit if ( num > tenth_limit
|| (num == tenth_limit && d > tenth_limit_digit) ) || (num == tenth_limit && d > tenth_limit_digit) )
@ -1043,10 +1045,10 @@ long FString::toLong() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
uLong FString::toULong() const uLong FString::toULong() const
{ {
register uLong num; uLong num;
register uLong tenth_limit; uLong tenth_limit;
register uLong tenth_limit_digit; uLong tenth_limit_digit;
register wchar_t* p; wchar_t* p;
FString s; FString s;
num = 0; num = 0;
@ -1072,7 +1074,7 @@ uLong FString::toULong() const
while ( std::iswdigit(wint_t(*p)) ) while ( std::iswdigit(wint_t(*p)) )
{ {
register uChar d = uChar((*p) - L'0'); uChar d = uChar((*p) - L'0');
if ( num > tenth_limit if ( num > tenth_limit
|| (num == tenth_limit && d > tenth_limit_digit) ) || (num == tenth_limit && d > tenth_limit_digit) )
@ -1093,13 +1095,13 @@ uLong FString::toULong() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
float FString::toFloat() const float FString::toFloat() const
{ {
register double num; double num;
num = toDouble(); num = toDouble();
if ( num > double(FLT_MAX) || num < double(-FLT_MAX) ) if ( num > double(FLT_MAX) || num < double(-FLT_MAX) )
throw std::overflow_error ("overflow"); throw std::overflow_error ("overflow");
if ( std::fabs(num) < FLT_EPSILON ) // num == 0.0f if ( std::fabs(num) < double(FLT_EPSILON) ) // num == 0.0f
throw std::underflow_error ("underflow"); throw std::underflow_error ("underflow");
return float(num); return float(num);
@ -1109,7 +1111,7 @@ float FString::toFloat() const
double FString::toDouble() const double FString::toDouble() const
{ {
wchar_t* p; wchar_t* p;
register double ret; double ret;
if ( ! string ) if ( ! string )
throw std::invalid_argument ("null value"); throw std::invalid_argument ("null value");
@ -1137,7 +1139,7 @@ double FString::toDouble() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::ltrim() const FString FString::ltrim() const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
// handle NULL and empty string // handle NULL and empty string
@ -1155,8 +1157,8 @@ FString FString::ltrim() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::rtrim() const FString FString::rtrim() const
{ {
register wchar_t* p; wchar_t* p;
register wchar_t* last; wchar_t* last;
FString s(string); FString s(string);
// handle NULL and empty string // handle NULL and empty string
@ -1200,7 +1202,7 @@ FString FString::left (int len) const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::left (uInt len) const FString FString::left (uInt len) const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
// handle NULL and empty string // handle NULL and empty string
@ -1228,7 +1230,7 @@ FString FString::right (int len) const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::right (uInt len) const FString FString::right (uInt len) const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
// handle NULL and empty string // handle NULL and empty string
@ -1260,8 +1262,8 @@ FString FString::mid (int pos, int len) const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::mid (uInt pos, uInt len) const FString FString::mid (uInt pos, uInt len) const
{ {
register wchar_t* p; wchar_t* p;
register wchar_t* first; wchar_t* first;
FString s(string); FString s(string);
// handle NULL and empty string // handle NULL and empty string
@ -1326,8 +1328,8 @@ FString& FString::setString (const char s[])
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::setNumber (long num) FString& FString::setNumber (long num)
{ {
register wchar_t* s; wchar_t* s;
register bool neg; bool neg;
wchar_t buf[30]; wchar_t buf[30];
s = &buf[29]; s = &buf[29];
@ -1361,7 +1363,7 @@ FString& FString::setNumber (long num)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::setNumber (uLong num) FString& FString::setNumber (uLong num)
{ {
register wchar_t* s; wchar_t* s;
wchar_t buf[30]; wchar_t buf[30];
s = &buf[29]; s = &buf[29];
@ -1381,7 +1383,7 @@ FString& FString::setNumber (uLong num)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::setNumber (lDouble num, int precision) FString& FString::setNumber (lDouble num, int precision)
{ {
register wchar_t* s; wchar_t* s;
wchar_t format[20]; // = "%.<precision>Lg" wchar_t format[20]; // = "%.<precision>Lg"
s = &format[0]; s = &format[0];
@ -1414,9 +1416,9 @@ FString& FString::setNumber (lDouble num, int precision)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::setFormatedNumber (long num, char separator) FString& FString::setFormatedNumber (long num, char separator)
{ {
register int n; int n;
register wchar_t* s; wchar_t* s;
register bool neg; bool neg;
wchar_t buf[30]; wchar_t buf[30];
n = 0; n = 0;
@ -1457,8 +1459,8 @@ FString& FString::setFormatedNumber (long num, char separator)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString& FString::setFormatedNumber (uLong num, char separator) FString& FString::setFormatedNumber (uLong num, char separator)
{ {
register int n; int n;
register wchar_t* s; wchar_t* s;
wchar_t buf[30]; wchar_t buf[30];
n = 0; n = 0;
@ -1860,7 +1862,7 @@ const FString& FString::insert (const char c, uInt pos)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const FString& from, const FString& to) FString FString::replace (const FString& from, const FString& to)
{ {
register wchar_t* p; wchar_t* p;
uInt from_length, to_length, pos; uInt from_length, to_length, pos;
FString s(string); FString s(string);
@ -2165,7 +2167,7 @@ FString FString::replace (const char from[], const char to)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const wchar_t from, const FString& to) FString FString::replace (const wchar_t from, const FString& to)
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
// handle NULL and empty string // handle NULL and empty string
@ -2290,7 +2292,7 @@ FString FString::replace (const char from, const wchar_t to)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replace (const char from, const char to) FString FString::replace (const char from, const char to)
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
// handle NULL and empty string // handle NULL and empty string
@ -2313,7 +2315,7 @@ FString FString::replace (const char from, const char to)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::replaceControlCodes() const FString FString::replaceControlCodes() const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
p = s.string; p = s.string;
@ -2374,8 +2376,7 @@ FString FString::expandTabs (int tabstop) const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::removeDel() const FString FString::removeDel() const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
p = s.string; p = s.string;
@ -2414,8 +2415,7 @@ FString FString::removeDel() const
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FString FString::removeBackspaces() const FString FString::removeBackspaces() const
{ {
register wchar_t* p; wchar_t* p;
FString s(string); FString s(string);
p = s.string; p = s.string;
@ -2824,7 +2824,7 @@ inline char* FString::wc_to_c_str (const wchar_t s[]) const
try try
{ {
c_string = new char[dest_size](); c_string = new char[uInt(dest_size)]();
// pre-initialiaze the whole string with '\0' // pre-initialiaze the whole string with '\0'
std::memset (c_string, '\0', std::size_t(dest_size)); std::memset (c_string, '\0', std::size_t(dest_size));
@ -2881,7 +2881,7 @@ inline wchar_t* FString::c_to_wc_str (const char s[]) const
try try
{ {
dest = new wchar_t[size](); dest = new wchar_t[uInt(size)]();
// pre-initialiaze the whole string with '\0' // pre-initialiaze the whole string with '\0'
std::wmemset (dest, L'\0', std::size_t(size)); std::wmemset (dest, L'\0', std::size_t(size));
} }
@ -2921,7 +2921,7 @@ inline wchar_t* FString::extractToken ( wchar_t* rest[]
, const wchar_t s[] , const wchar_t s[]
, const wchar_t delim[] ) , const wchar_t delim[] )
{ {
register wchar_t* token; wchar_t* token;
token = ( s ) ? const_cast<wchar_t*>(s) : *rest; token = ( s ) ? const_cast<wchar_t*>(s) : *rest;
if ( ! token ) if ( ! token )

View File

@ -800,7 +800,7 @@ void FTerm::putstring (const char s[], int affcnt)
#if defined(__sun) && defined(__SVR4) #if defined(__sun) && defined(__SVR4)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTerm::putchar_ASCII (register char c) int FTerm::putchar_ASCII (char c)
{ {
if ( std::putchar(c) == EOF ) if ( std::putchar(c) == EOF )
return 0; return 0;
@ -810,7 +810,7 @@ int FTerm::putchar_ASCII (register char c)
#endif #endif
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTerm::putchar_ASCII (register int c) int FTerm::putchar_ASCII (int c)
{ {
if ( std::putchar(char(c)) == EOF ) if ( std::putchar(char(c)) == EOF )
return 0; return 0;
@ -819,7 +819,7 @@ int FTerm::putchar_ASCII (register int c)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTerm::putchar_UTF8 (register int c) int FTerm::putchar_UTF8 (int c)
{ {
if ( c < 0x80 ) if ( c < 0x80 )
{ {
@ -2196,9 +2196,9 @@ void FTerm::finish_encoding()
//---------------------------------------------------------------------- //----------------------------------------------------------------------
uInt FTerm::cp437_to_unicode (uChar c) uInt FTerm::cp437_to_unicode (uChar c)
{ {
register uInt ucs = uInt(c); uInt ucs = uInt(c);
for (register uInt i = 0; i <= fc::lastCP437Item; i++) for (uInt i = 0; i <= fc::lastCP437Item; i++)
{ {
if ( fc::cp437_to_ucs[i][0] == c ) // found if ( fc::cp437_to_ucs[i][0] == c ) // found
{ {

View File

@ -76,7 +76,7 @@ int FTermBuffer::writef (const char format[], ...)
{ {
try try
{ {
buffer = new char[len + 1](); buffer = new char[uInt(len) + 1]();
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -131,7 +131,7 @@ int FTermBuffer::write (const std::string& s)
int FTermBuffer::write (const FString& s) int FTermBuffer::write (const FString& s)
{ {
assert ( ! s.isNull() ); assert ( ! s.isNull() );
register int len = 0; int len = 0;
const wchar_t* p = s.wc_str(); const wchar_t* p = s.wc_str();
if ( p ) if ( p )
@ -155,7 +155,7 @@ int FTermBuffer::write (const FString& s)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FTermBuffer::write (register int c) int FTermBuffer::write (int c)
{ {
charData nc; // next character charData nc; // next character
nc = FVTerm::getAttribute(); nc = FVTerm::getAttribute();

View File

@ -615,40 +615,13 @@ char* FTermDetection::parseSecDA (char current_termtype[])
return current_termtype; return current_termtype;
// Read the terminal type // Read the terminal type
try secondary_da.terminal_id_type = str2int(sec_da_components[0]);
{
secondary_da.terminal_id_type = sec_da_components[0].toInt();
}
catch (const std::exception&)
{
secondary_da.terminal_id_type = -1;
}
// Read the terminal (firmware) version // Read the terminal (firmware) version
try secondary_da.terminal_id_version = str2int(sec_da_components[1]);
{
if ( sec_da_components[1] )
secondary_da.terminal_id_version = sec_da_components[1].toInt();
else
secondary_da.terminal_id_version = -1;
}
catch (const std::exception&)
{
secondary_da.terminal_id_version = -1;
}
// Read the terminal hardware option // Read the terminal hardware option
try secondary_da.terminal_id_hardware = str2int(sec_da_components[2]);
{
if ( sec_da_components[2] )
secondary_da.terminal_id_hardware = sec_da_components[2].toInt();
else
secondary_da.terminal_id_hardware = -1;
}
catch (const std::exception&)
{
secondary_da.terminal_id_hardware = -1;
}
char* new_termtype = secDA_Analysis(current_termtype); char* new_termtype = secDA_Analysis(current_termtype);
@ -663,6 +636,22 @@ char* FTermDetection::parseSecDA (char current_termtype[])
return new_termtype; return new_termtype;
} }
//----------------------------------------------------------------------
int FTermDetection::str2int (const FString& s)
{
if ( ! s )
return -1;
try
{
return s.toInt();
}
catch (const std::exception&)
{
return -1;
}
}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const FString FTermDetection::getSecDA() const FString FTermDetection::getSecDA()
{ {

View File

@ -581,9 +581,12 @@ bool FTermLinux::getUnicodeMap()
count = screen_unicode_map.entry_ct; count = screen_unicode_map.entry_ct;
if ( count <= 0 )
return false;
try try
{ {
screen_unicode_map.entries = new struct unipair[count](); screen_unicode_map.entries = new struct unipair[uInt(count)]();
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -218,7 +218,7 @@ void FTextView::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -353,7 +353,7 @@ void FTextView::clear()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -241,7 +241,7 @@ void FToggleButton::hide()
try try
{ {
blank = new char[size + 1]; blank = new char[uInt(size) + 1];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {

View File

@ -99,7 +99,7 @@ FPoint FVTerm::getPrintCursor()
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FVTerm::setTermXY (register int x, register int y) void FVTerm::setTermXY (int x, int y)
{ {
// Sets the hardware cursor to the given (x,y) position // Sets the hardware cursor to the given (x,y) position
int term_x, term_y, term_width, term_height; int term_x, term_y, term_width, term_height;
@ -149,7 +149,7 @@ void FVTerm::hideCursor (bool on)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FVTerm::setPrintCursor (register int x, register int y) void FVTerm::setPrintCursor (int x, int y)
{ {
term_area* win = getPrintArea(); term_area* win = getPrintArea();
@ -248,7 +248,7 @@ void FVTerm::updateTerminal()
// Update data on VTerm // Update data on VTerm
updateVTerm(); updateVTerm();
for (register uInt y = 0; y < uInt(vterm->height); y++) for (uInt y = 0; y < uInt(vterm->height); y++)
updateTerminalLine (y); updateTerminalLine (y);
// sets the new input cursor position // sets the new input cursor position
@ -325,7 +325,7 @@ int FVTerm::printf (const char format[], ...)
{ {
try try
{ {
buffer = new char[len + 1](); buffer = new char[uInt(len) + 1]();
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -481,7 +481,7 @@ int FVTerm::print (const std::vector<charData>& term_string)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::print (term_area* area, const std::vector<charData>& term_string) int FVTerm::print (term_area* area, const std::vector<charData>& term_string)
{ {
register int len = 0; int len = 0;
std::vector<charData>::const_iterator iter; std::vector<charData>::const_iterator iter;
iter = term_string.begin(); iter = term_string.begin();
uInt tabstop = uInt(getTabstop()); uInt tabstop = uInt(getTabstop());
@ -540,7 +540,7 @@ int FVTerm::print (term_area* area, const std::vector<charData>& term_string)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::print (register int c) int FVTerm::print (int c)
{ {
term_area* area = getPrintArea(); term_area* area = getPrintArea();
@ -556,7 +556,7 @@ int FVTerm::print (register int c)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
int FVTerm::print (term_area* area, register int c) int FVTerm::print (term_area* area, int c)
{ {
charData nc; // next character charData nc; // next character
@ -828,6 +828,9 @@ inline bool FVTerm::reallocateTextArea ( term_area* area
, int height , int height
, int size ) , int size )
{ {
assert ( height > 0 );
assert ( size > 0 );
if ( area->changes != 0 ) if ( area->changes != 0 )
delete[] area->changes; delete[] area->changes;
@ -836,8 +839,8 @@ inline bool FVTerm::reallocateTextArea ( term_area* area
try try
{ {
area->changes = new line_changes[height]; area->changes = new line_changes[uInt(height)];
area->text = new charData[size]; area->text = new charData[uInt(size)];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -851,12 +854,14 @@ inline bool FVTerm::reallocateTextArea ( term_area* area
//---------------------------------------------------------------------- //----------------------------------------------------------------------
inline bool FVTerm::reallocateTextArea (term_area* area, int size) inline bool FVTerm::reallocateTextArea (term_area* area, int size)
{ {
assert ( size > 0 );
if ( area->text != 0 ) if ( area->text != 0 )
delete[] area->text; delete[] area->text;
try try
{ {
area->text = new charData[size]; area->text = new charData[uInt(size)];
} }
catch (const std::bad_alloc& ex) catch (const std::bad_alloc& ex)
{ {
@ -1594,7 +1599,7 @@ void FVTerm::putArea (int ax, int ay, term_area* area)
if ( length < 1 ) if ( length < 1 )
return; return;
for (register int y = 0; y < y_end; y++) // line loop for (int y = 0; y < y_end; y++) // line loop
{ {
int line_len = aw + rsh; int line_len = aw + rsh;
@ -1608,7 +1613,7 @@ void FVTerm::putArea (int ax, int ay, term_area* area)
else else
{ {
// Line has one or more transparent characters // Line has one or more transparent characters
for (register int x = 0; x < length; x++) // column loop for (int x = 0; x < length; x++) // column loop
{ {
int cx = ax + x; int cx = ax + x;
int cy = ay + y; int cy = ay + y;

View File

@ -729,7 +729,7 @@ void FWidget::setGeometry (int x, int y, int w, int h, bool adjust)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool FWidget::setCursorPos (register int x, register int y) bool FWidget::setCursorPos (int x, int y)
{ {
// sets the input cursor position // sets the input cursor position
@ -765,7 +765,7 @@ bool FWidget::setCursorPos (register int x, register int y)
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void FWidget::setPrintPos (register int x, register int y) void FWidget::setPrintPos (int x, int y)
{ {
setPrintCursor ( offset.getX1() + getX() + x - 1, setPrintCursor ( offset.getX1() + getX() + x - 1,
offset.getY1() + getY() + y - 1 ); offset.getY1() + getY() + y - 1 );
@ -1493,7 +1493,7 @@ void FWidget::clearFlatBorder()
setColor (wc.dialog_fg, wc.dialog_bg); setColor (wc.dialog_fg, wc.dialog_bg);
// clear on left side // clear on left side
for (register int y = 0; y < getHeight(); y++) for (int y = 0; y < getHeight(); y++)
{ {
setPrintPos (x1 - 1, y1 + y + 1); setPrintPos (x1 - 1, y1 + y + 1);
@ -1504,7 +1504,7 @@ void FWidget::clearFlatBorder()
} }
// clear on right side // clear on right side
for (register int y = 0; y < getHeight(); y++) for (int y = 0; y < getHeight(); y++)
{ {
setPrintPos (x2, y1 + y + 1); setPrintPos (x2, y1 + y + 1);
@ -1517,7 +1517,7 @@ void FWidget::clearFlatBorder()
// clear at top // clear at top
setPrintPos (x1, y1); setPrintPos (x1, y1);
for (register int x = 0; x < getWidth(); x++) for (int x = 0; x < getWidth(); x++)
{ {
if ( double_flatline_mask.top[uLong(x)] ) if ( double_flatline_mask.top[uLong(x)] )
print (fc::NF_border_line_upper); print (fc::NF_border_line_upper);
@ -1528,7 +1528,7 @@ void FWidget::clearFlatBorder()
// clear at bottom // clear at bottom
setPrintPos (x1, y2); setPrintPos (x1, y2);
for (register int x = 0; x < getWidth(); x++) for (int x = 0; x < getWidth(); x++)
{ {
if ( double_flatline_mask.bottom[uLong(x)] ) if ( double_flatline_mask.bottom[uLong(x)] )
print (fc::NF_border_line_bottom); print (fc::NF_border_line_bottom);