LAB: Remove superfluous void function parameters

engines/lab/allocroom.cpp

@@ -59,7 +59,7 @@ static int32 MemLeftInBuffer = 0L;
 /*****************************************************************************/
 /* Allocates the memory for the room buffers.                                */
 /*****************************************************************************/
-bool initRoomBuffer(void) {
+bool initRoomBuffer() {
 	uint16 counter;
 
 	CurMarker = 0;
@@ -82,7 +82,7 @@ bool initRoomBuffer(void) {
 /*****************************************************************************/
 /* Frees the memory for the room buffers.                                    */
 /*****************************************************************************/
-void freeRoomBuffer(void) {
+void freeRoomBuffer() {
 	if (RoomBuffer)
 		free(RoomBuffer);
 }

engines/lab/audioi.cpp

@@ -51,7 +51,7 @@ static char *CurMusic, *startMusic;
 static uint32 StartMusicLen;
 static Audio::SoundHandle g_musicHandle;
 
-void freeAudio(void) {
+void freeAudio() {
 	if (!DoMusic)
 		return;
 
@@ -61,7 +61,7 @@ void freeAudio(void) {
 
 
 
-bool initAudio(void) {
+bool initAudio() {
 	if (!DoMusic)
 		return true;
 
@@ -110,7 +110,7 @@ void playMusicBlock(void *Ptr, uint32 Size, uint16 BufferNum, uint16 SampleSpeed
 }
 
 
-void updateSoundBuffers(void) {
+void updateSoundBuffers() {
 	if (!DoMusic)
 		return;
 
@@ -166,7 +166,7 @@ void updateSoundBuffers(void) {
 
 
 
-void flushAudio(void) {
+void flushAudio() {
 	if (!DoMusic)
 		return;
 

engines/lab/diff.h

@@ -75,19 +75,19 @@ void blackScreen();
 
 void blackAllScreen();
 
-void whiteScreen(void);
+void whiteScreen();
 
 bool readDiff(bool playonce);
 
-void diffNextFrame(void);
+void diffNextFrame();
 
-void readSound(void);
+void readSound();
 
-void stopDiff(void);
+void stopDiff();
 
-void stopDiffEnd(void);
+void stopDiffEnd();
 
-void stopSound(void);
+void stopSound();
 
 } // End of namespace Lab
 

engines/lab/engine.cpp

@@ -146,7 +146,7 @@ static char initcolors[] = { '\x00', '\x00', '\x00', '\x30',
 /******************************************************************************/
 /* Draws the control panel display.                                           */
 /******************************************************************************/
-void drawPanel(void) {
+void drawPanel() {
 	mouseHide();
 
 	setAPen(3);                 /* Clear Area */
@@ -241,7 +241,7 @@ static uint16 OldMode;
 /******************************************************************************/
 /* Sets up the Labyrinth screens, and opens up the initial windows.           */
 /******************************************************************************/
-bool setUpScreens(void) {
+bool setUpScreens() {
 	uint16 counter;
 	byte *bufferstorage, **buffer = &bufferstorage;
 	Gadget *curgad;
@@ -416,7 +416,7 @@ static void perFlipGadget(uint16 GadID) {
 /******************************************************************************/
 /* Eats all the available messages.                                           */
 /******************************************************************************/
-void eatMessages(void) {
+void eatMessages() {
 	IntuiMessage *Msg;
 
 	do {
@@ -440,7 +440,7 @@ static uint16 lastmusicroom = 1;
 /******************************************************************************/
 /* Checks the music that should be playing in a particular room.              */
 /******************************************************************************/
-static void checkRoomMusic(void) {
+static void checkRoomMusic() {
 	if ((lastmusicroom == RoomNum) || !g_music->_musicOn)
 		return;
 
@@ -546,7 +546,7 @@ static bool interfaceisoff = false;
 /******************************************************************************/
 /* Turns the interface off.                                                   */
 /******************************************************************************/
-static void interfaceOff(void) {
+static void interfaceOff() {
 	if (!interfaceisoff) {
 		attachGadgetList(NULL);
 		mouseHide();
@@ -560,7 +560,7 @@ static void interfaceOff(void) {
 /******************************************************************************/
 /* Turns the interface on.                                                    */
 /******************************************************************************/
-static void interfaceOn(void) {
+static void interfaceOn() {
 	if (interfaceisoff) {
 		interfaceisoff = false;
 
@@ -711,7 +711,7 @@ static bool novesa = false, noaudio = false;
 /******************************************************************************/
 /* Processes user input events.                                               */
 /******************************************************************************/
-static void process(void) {
+static void process() {
 	IntuiMessage *Msg;
 	uint32 Class;
 

engines/lab/graphics.cpp

@@ -495,7 +495,7 @@ void copyLong64(uint32 *Dest, uint32 *Source, uint32 Many64) {
 /*****************************************************************************/
 /* Scrolls the display to black.                                             */
 /*****************************************************************************/
-static void doScrollBlack(void) {
+static void doScrollBlack() {
 	byte *mem, *tempmem;
 	Image Im;
 	uint16 width, height, by, nheight, CurPage;
@@ -675,7 +675,7 @@ static void doScrollWipe(char *filename) {
 /*****************************************************************************/
 /* Does the scroll bounce.  Assumes bitmap already in memory.                */
 /*****************************************************************************/
-static void doScrollBounce(void) {
+static void doScrollBounce() {
 	const uint16 *newby, *newby1;
 
 	const uint16 newbyd[5] = {5, 4, 3, 2, 1}, newby1d[8] = {3, 3, 2, 2, 2, 1, 1, 1};

engines/lab/interface.cpp

@@ -165,7 +165,7 @@ static bool keyPress(uint16 *KeyCode) {
 IntuiMessage IMessage;
 extern Gadget *ScreenGadgetList;
 
-IntuiMessage *getMsg(void) {
+IntuiMessage *getMsg() {
 	Gadget *curgad;
 	int Qualifiers;
 

engines/lab/interface.h

@@ -124,7 +124,7 @@ void ghoastGadget(Gadget *curgad, uint16 pencolor);
 
 void unGhoastGadget(Gadget *curgad);
 
-IntuiMessage *getMsg(void);
+IntuiMessage *getMsg();
 
 void replyMsg(void *Msg);
 

engines/lab/intro.cpp

@@ -63,7 +63,7 @@ extern int32 longcharsdrawn;
 /* Goes thru, and responds to all the intuition messages currently in the     */
 /* the message port.                                                          */
 /******************************************************************************/
-void introEatMessages(void) {
+void introEatMessages() {
 	IntuiMessage *Msg;
 
 	while (1) {
@@ -229,7 +229,7 @@ static void doPictText(const char *Filename, bool isscreen) {
 /*****************************************************************************/
 /* Does a one second delay, but checks the music while doing it.             */
 /*****************************************************************************/
-void musicDelay(void) {
+void musicDelay() {
 	int16 counter;
 
 	g_music->newCheckMusic();
@@ -268,7 +268,7 @@ static void NReadPict(const char *Filename, bool PlayOnce) {
 /*****************************************************************************/
 /* Does the introduction sequence for Labyrinth.                             */
 /*****************************************************************************/
-void introSequence(void) {
+void introSequence() {
 	uint16 counter, counter1;
 
 	DoBlack = true;

engines/lab/labfile.cpp

@@ -278,7 +278,7 @@ void skip(byte **File, uint32 skip) {
 /*****************************************************************************/
 /* Resets the internal buffers to empty.                                     */
 /*****************************************************************************/
-void resetBuffer(void) {
+void resetBuffer() {
 	uint16 RMarker;
 
 	CurMarker = 0;
@@ -314,7 +314,7 @@ bool initBuffer(uint32 BufSize, bool IsGraphicsMem) {
 /*****************************************************************************/
 /* Frees the buffer.                                                         */
 /*****************************************************************************/
-void freeBuffer(void) {
+void freeBuffer() {
 	freeAllStolenMem();
 
 	if (buffer)
@@ -335,7 +335,7 @@ void freeBuffer(void) {
 /*****************************************************************************/
 /* Clears all the buffers.                                                   */
 /*****************************************************************************/
-static void flushBuffers(void) {
+static void flushBuffers() {
 	uint16 RMarker;
 
 	RMarker = 0;
@@ -385,7 +385,7 @@ Common::File *openPartial(const char *name) {
 /*****************************************************************************/
 /* Frees all the memory stolen from the buffer.                              */
 /*****************************************************************************/
-void freeAllStolenMem(void) {
+void freeAllStolenMem() {
 	flushBuffers();
 
 	buffer = realbufferstart;

engines/lab/labfun.h

@@ -61,17 +61,17 @@ struct SaveGameHeader {
 /*------ From Audioi.c -------*/
 /*----------------------------*/
 
-bool initAudio(void);
+bool initAudio();
 
-void freeAudio(void);
+void freeAudio();
 
 bool musicBufferEmpty(uint16 i);
 
 void playMusicBlock(void *Ptr, uint32 Size, uint16 BufferNum, uint16 SampleSpeed);
 
-void updateSoundBuffers(void);
+void updateSoundBuffers();
 
-void flushAudio(void);
+void flushAudio();
 
 void playMusic(uint16 SampleSpeed, uint16 Volume, uint32 Length, bool flush, void *Data);
 
@@ -146,7 +146,7 @@ void gadgetsOnOff(void *gptr, void *win, int32 num, bool on);
 /*---- From Intro.c ----*/
 /*----------------------*/
 
-void introSequence(void);
+void introSequence();
 
 
 
@@ -154,13 +154,13 @@ void introSequence(void);
 /*----- From Lab.c -----*/
 /*----------------------*/
 
-void eatMessages(void);
+void eatMessages();
 
-bool setUpScreens(void);
+bool setUpScreens();
 
-void drawPanel(void);
+void drawPanel();
 
-bool quitPlaying(void);
+bool quitPlaying();
 
 
 
@@ -182,11 +182,11 @@ char readChar(char **File);
 
 void skip(byte **File, uint32 skip);
 
-void resetBuffer(void);
+void resetBuffer();
 
 bool initBuffer(uint32 BufSize, bool IsGraphicsMem);
 
-void freeBuffer(void);
+void freeBuffer();
 
 
 /* Functions that borrow memory from the buffer */
@@ -195,7 +195,7 @@ bool allocFile(void **Ptr, uint32 Size, const char *fileName);
 
 void *stealBufMem(int32 Size);
 
-void freeAllStolenMem(void);
+void freeAllStolenMem();
 
 
 /* Read chunks of a file */
@@ -210,9 +210,9 @@ void closePartial(int32 File);
 /*------ From LabText.c -----*/
 /*---------------------------*/
 
-bool initLabText(void);
+bool initLabText();
 
-void freeLabText(void);
+void freeLabText();
 
 void decrypt(byte *text);
 
@@ -231,18 +231,18 @@ public:
 	Music();
 
 	byte **newOpen(const char *name);
-	bool initMusic(void);
+	bool initMusic();
-	void freeMusic(void);
+	void freeMusic();
 	void fillUpMusic(bool doit);
-	void updateMusic(void);
+	void updateMusic();
-	void checkMusic(void);
+	void checkMusic();
-	void newCheckMusic(void);
+	void newCheckMusic();
-	void closeMusic(void);
+	void closeMusic();
 	void setMusic(bool on);
-	void restartBackMusic(void);
+	void restartBackMusic();
-	void pauseBackMusic(void);
+	void pauseBackMusic();
 	void changeMusic(const char *newmusic);
-	void resetMusic(void);
+	void resetMusic();
 	void fileCheckMusic(uint32 filelength);
 
 	bool _winmusic, _doNotFileFlushAudio;
@@ -251,7 +251,7 @@ public:
 
 private:
 	void fillbuffer(uint16 unit);
-	uint16 getManyBuffersLeft(void);
+	uint16 getManyBuffersLeft();
 	void startMusic(bool startatbegin);
 
 	Common::File *_file;
@@ -340,13 +340,13 @@ void doMap(uint16 CurRoom);
 
 void doJournal();
 
-void doNotes(void);
+void doNotes();
 
-void doWestPaper(void);
+void doWestPaper();
 
 void doMonitor(char *background, char *textfile, bool isinteractive, uint16 x1, uint16 y1, uint16 x2, uint16 y2);
 
-bool saveRestoreGame(void);
+bool saveRestoreGame();
 
 
 

engines/lab/labmusic.cpp

@@ -71,7 +71,7 @@ Music::Music() {
 /* Figures out which buffer is currently playing based on messages sent to   */
 /* it from the Audio device.                                                 */
 /*****************************************************************************/
-void Music::updateMusic(void) {
+void Music::updateMusic() {
 	uint16 i;
 
 	WSDL_ProcessInput(0);
@@ -125,7 +125,7 @@ void Music::fillbuffer(uint16 unit) {
 /*****************************************************************************/
 /* Figures out how many *complete* buffers of music left to play.            */
 /*****************************************************************************/
-uint16 Music::getManyBuffersLeft(void) {
+uint16 Music::getManyBuffersLeft() {
 	uint16 mp = _musicOnBuffer;
 
 	if (mp == _musicFilledTo) /* Already filled */
@@ -240,7 +240,7 @@ void Music::startMusic(bool startatbegin) {
 /*****************************************************************************/
 /* Initializes the music buffers.                                            */
 /*****************************************************************************/
-bool Music::initMusic(void) {
+bool Music::initMusic() {
 	uint16 counter;
 
 	if (!_turnMusicOn)
@@ -278,7 +278,7 @@ bool Music::initMusic(void) {
 /*****************************************************************************/
 /* Frees up the music buffers and closes the file.                           */
 /*****************************************************************************/
-void Music::freeMusic(void) {
+void Music::freeMusic() {
 	_musicOn = false;
 
 	if (_file->isOpen())
@@ -291,7 +291,7 @@ void Music::freeMusic(void) {
 /*****************************************************************************/
 /* Pauses the background music.                                              */
 /*****************************************************************************/
-void Music::pauseBackMusic(void) {
+void Music::pauseBackMusic() {
 	if (!_musicPaused && _musicOn) {
 		updateMusic();
 		_musicOn = false;
@@ -311,7 +311,7 @@ void Music::pauseBackMusic(void) {
 /*****************************************************************************/
 /* Restarts the paused background music.                                     */
 /*****************************************************************************/
-void Music::restartBackMusic(void) {
+void Music::restartBackMusic() {
 	if (_musicPaused) {
 		flushAudio();
 		_musicOn = true;
@@ -327,7 +327,7 @@ void Music::restartBackMusic(void) {
 /*****************************************************************************/
 /* Checks to see if need to fill buffers fill of music.                      */
 /*****************************************************************************/
-void Music::checkMusic(void) {
+void Music::checkMusic() {
 	updateMusic();
 
 	if (!_musicOn)
@@ -341,7 +341,7 @@ void Music::checkMusic(void) {
 /*****************************************************************************/
 /* Checks to see if need to fill buffers fill of music.                      */
 /*****************************************************************************/
-void Music::newCheckMusic(void) {
+void Music::newCheckMusic() {
 	checkMusic();
 }
 
@@ -405,7 +405,7 @@ void Music::changeMusic(const char *newmusic) {
 /*****************************************************************************/
 /* Changes the background music to the original piece playing.               */
 /*****************************************************************************/
-void Music::resetMusic(void) {
+void Music::resetMusic() {
 	if (!_tFile)
 		return;
 

engines/lab/labtext.cpp

@@ -64,7 +64,7 @@ static void setString(char **string) {
 /*****************************************************************************/
 /* Initializes everything for the Labyrinth text stuff                       */
 /*****************************************************************************/
-bool initLabText(void) {
+bool initLabText() {
 	if ((SizeOfMemChunk = sizeOfFile(LABTEXTFILE)))
 		if ((BeginOfMemChunk = (char *)calloc(SizeOfMemChunk, 1))) {
 			Common::File *file = openPartial(LABTEXTFILE);
@@ -143,7 +143,7 @@ bool initLabText(void) {
 /*****************************************************************************/
 /* Frees the memory from the Labyrinth text stuff.                           */
 /*****************************************************************************/
-void freeLabText(void) {
+void freeLabText() {
 	if (SizeOfMemChunk && BeginOfMemChunk)
 		free(BeginOfMemChunk);
 }

engines/lab/map.cpp

@@ -217,7 +217,7 @@ static uint16 mapScaleY(uint16 y) {
 /*****************************************************************************/
 /* Loads in the map data.                                                    */
 /*****************************************************************************/
-static bool loadMapData(void) {
+static bool loadMapData() {
 	byte **buffer, Temp[5];
 	int32 Size;
 	Gadget *gptr;
@@ -892,7 +892,7 @@ void processMap(uint16 CurRoom) {
 /*****************************************************************************/
 /* Cleans up behind itself.                                                  */
 /*****************************************************************************/
-void mapCleanUp(void) {
+void mapCleanUp() {
 	freeAllStolenMem();
 }
 

engines/lab/mouse.cpp

@@ -39,7 +39,7 @@ namespace Lab {
 extern bool IsHiRes;
 extern uint32 VGAScreenWidth, VGAScreenHeight;
 
-void mouseHideXY(void);
+void mouseHideXY();
 
 static bool LeftClick = false;
 static bool RightClick = false;
@@ -166,7 +166,7 @@ void mouse_handler(int32 flag, int32 mouseX, int32 mouseY) {
 
 
 
-void updateMouse(void) {
+void updateMouse() {
 	uint16 counter;
 	bool doUpdateDisplay = false;
 
@@ -204,7 +204,7 @@ void updateMouse(void) {
 /*****************************************************************************/
 /* Initializes the mouse.                                                    */
 /*****************************************************************************/
-bool initMouse(void) {
+bool initMouse() {
 	g_system->setMouseCursor(MouseData, MOUSE_WIDTH, MOUSE_HEIGHT, 0, 0, 0);
 	g_system->showMouse(false);
 
@@ -219,7 +219,7 @@ bool initMouse(void) {
 /*****************************************************************************/
 /* Shows the mouse.                                                          */
 /*****************************************************************************/
-void mouseShow(void) {
+void mouseShow() {
 	mouseShowXY(CurMouseX, CurMouseY);
 
 	g_system->showMouse(true);
@@ -253,7 +253,7 @@ void mouseShowXY(uint16 MouseX, uint16 MouseY) {
 /*****************************************************************************/
 /* Hides the mouse.                                                          */
 /*****************************************************************************/
-void mouseHide(void) {
+void mouseHide() {
 	QuitMouseHandler = true;
 
 	NumHidden++;
@@ -273,7 +273,7 @@ void mouseHide(void) {
 /*****************************************************************************/
 /* Hides the mouse.                                                          */
 /*****************************************************************************/
-void mouseHideXY(void) {
+void mouseHideXY() {
 	QuitMouseHandler = true;
 
 	NumHidden++;
@@ -355,7 +355,7 @@ bool mouseButton(uint16 *x, uint16 *y, bool leftbutton) {
 
 
 
-Gadget *mouseGadget(void) {
+Gadget *mouseGadget() {
 	Gadget *Temp = LastGadgetHit;
 
 	LastGadgetHit = NULL;

engines/lab/mouse.h

@@ -37,13 +37,13 @@ namespace Lab {
 
 struct Gadget;
 
-bool initMouse(void);
+bool initMouse();
 
-void updateMouse(void);
+void updateMouse();
 
-void mouseShow(void);
+void mouseShow();
 
-void mouseHide(void);
+void mouseHide();
 
 void mouseXY(uint16 *x, uint16 *y);
 
@@ -51,7 +51,7 @@ void mouseMove(uint16 x, uint16 y);
 
 bool mouseButton(uint16 *x, uint16 *y, bool leftbutton);
 
-Gadget *mouseGadget(void);
+Gadget *mouseGadget();
 
 void attachGadgetList(Gadget *GadList);
 

engines/lab/parsefun.h

@@ -44,9 +44,9 @@ bool parse(const char *InputFile);
 
 /* From allocRoom.c */
 
-bool initRoomBuffer(void);
+bool initRoomBuffer();
 
-void freeRoomBuffer(void);
+void freeRoomBuffer();
 
 void allocRoom(void **Ptr, uint16 Size, uint16 RoomNum);
 

engines/lab/readdiff.cpp

@@ -125,7 +125,7 @@ void blackScreen() {
 /*****************************************************************************/
 /* Changes the front screen to white.                                        */
 /*****************************************************************************/
-void whiteScreen(void) {
+void whiteScreen() {
 	memset(blackbuffer, 255, 248 * 3);
 	writeColorRegs(blackbuffer, 8, 248);
 }
@@ -149,7 +149,7 @@ static byte *Buffer, temp[5];
 static bool FirstThru = true, donepal   = false;
 static byte *storagefordifffile, * *difffile = &storagefordifffile;
 
-void diffNextFrame(void) {
+void diffNextFrame() {
 	if (header == 65535)  /* Already done. */
 		return;
 
@@ -340,7 +340,7 @@ void diffNextFrame(void) {
 /*****************************************************************************/
 /* A separate task launched by readDiff.  Plays the DIFF.                    */
 /*****************************************************************************/
-void playDiff(void) {
+void playDiff() {
 	processed = 0L;
 	WaitSec   = 0L;
 	WaitMicros = 0L;
@@ -445,7 +445,7 @@ void playDiff(void) {
 /*****************************************************************************/
 /* Stops an animation from running.                                          */
 /*****************************************************************************/
-void stopDiff(void) {
+void stopDiff() {
 	if (IsPlaying) {
 		StopPlaying = true;
 
@@ -464,7 +464,7 @@ void stopDiff(void) {
 /*****************************************************************************/
 /* Stops an animation from running.                                          */
 /*****************************************************************************/
-void stopDiffEnd(void) {
+void stopDiffEnd() {
 	if (IsPlaying) {
 		StopPlayingEnd = true;
 
@@ -480,7 +480,7 @@ void stopDiffEnd(void) {
 /*****************************************************************************/
 /* Stops the continuous sound from playing.                                  */
 /*****************************************************************************/
-void stopSound(void) {
+void stopSound() {
 	stopsound = true;
 }
 
@@ -500,7 +500,7 @@ bool readDiff(bool playonce) {
 static byte *mstart;
 
 
-void readSound(void) {
+void readSound() {
 	uint32 header_ = 0, size_;
 	uint16 samplespeed_;
 //  uint16 numchunks = 1;

engines/lab/special.cpp

@@ -117,7 +117,7 @@ static uint16 combx[] = {45, 83, 129, 166, 211, 248};
 /*****************************************************************************/
 /* Draws the images of the combination lock to the display bitmap.           */
 /*****************************************************************************/
-static void doCombination(void) {
+static void doCombination() {
 	uint16 counter;
 
 	for (counter = 0; counter <= 5; counter++)
@@ -513,7 +513,7 @@ static TextFont bmfont;
 /*****************************************************************************/
 /* Does the things to properly set up the detective notes.                   */
 /*****************************************************************************/
-void doNotes(void) {
+void doNotes() {
 	char *ntext;
 
 	/* Load in the data */
@@ -546,7 +546,7 @@ void doNotes(void) {
 /* Does the things to properly set up the old west newspaper.  Assumes that  */
 /* OpenHiRes already called.                                                 */
 /*****************************************************************************/
-void doWestPaper(void) {
+void doWestPaper() {
 	char *ntext;
 	int32 FileLen, CharsPrinted;
 	uint16 y = 268;
@@ -727,7 +727,7 @@ static bool loadJournalData() {
 /*****************************************************************************/
 /* Draws the text to the back journal screen to the appropriate Page number  */
 /*****************************************************************************/
-static void drawJournalText(void) {
+static void drawJournalText() {
 	uint16 DrawingToPage = 1;
 	int32 CharsDrawn    = 0L;
 	char *CurText = journaltext;
@@ -935,7 +935,7 @@ void doJournal() {
 extern InventoryData *Inventory;
 extern uint16 RoomNum, Direction;
 
-bool saveRestoreGame(void) {
+bool saveRestoreGame() {
 	bool isOK = false;
 
 	// The original had one screen for saving/loading. We have two.
@@ -993,7 +993,7 @@ Image *MonButton, *AltMonButton, *MonQuit, *AltMonQuit, *MonBack, *AltMonBack,
 /*****************************************************************************/
 /* Makes sure that the buttons are in memory.                                */
 /*****************************************************************************/
-static void getMonImages(void) {
+static void getMonImages() {
 	byte **buffer;
 
 	resetBuffer();

engines/lab/vga.cpp

@@ -100,11 +100,11 @@ void setPage(uint16 PageNum) {
 	assert(PageNum == 0);
 }
 
-void VGAStorePage(void) {
+void VGAStorePage() {
 	// does nothing in SDL
 }
 
-void VGARestorePage(void) {
+void VGARestorePage() {
 	// does nothing in SDL
 }
 
@@ -321,7 +321,7 @@ void WSDL_UpdateScreen() {
 /*****************************************************************************/
 /* Returns the base address of the current VGA display.                      */
 /*****************************************************************************/
-byte *getVGABaseAddr(void) {
+byte *getVGABaseAddr() {
 	if (VGABASEADDRESS)
 		return VGABASEADDRESS;
 

engines/lab/vga.h

@@ -47,17 +47,17 @@ void getMode(uint16 *Mode);
 
 void setPage(uint16 PageNum);
 
-void VGAStorePage(void);
+void VGAStorePage();
 
-void VGARestorePage(void);
+void VGARestorePage();
 
 bool createScreen(bool HiRes);
 
-void waitTOF(void);
+void waitTOF();
 
-void quickWaitTOF(void);
+void quickWaitTOF();
 
-byte *getVGABaseAddr(void);
+byte *getVGABaseAddr();
 
 void ungetVGABaseAddr();