This is the documentation for the RLSystems Swing library V1 (LSW1) by Dlanor Blytkerchan.
Hopefully, this will guide you through the library and it's functions. Should you have any question after reading this, please don't hestitate to contact Dlanor at dlanor@dds.nl
The Engine Model is an article written by Dlanor Blytkerchan and is available in PDF format for free, if you mail him. It is accompanied by a Software Development Kit which includes this library, and is meant to make it easier to implement the model in your own software.
The Engine Model was written primarily for beginning programmers with no set programming style of their own, and for programmers in general who would like to organize their source files a bit better. it is platform- and langauge-independant and contains a lot of examples in C, to elucidate the implementation of the model.
The Engine Model itself took about a decade to develop, having been in development from the very first time I ever wrote a program, and is a collection of ideas and notions that have matured throughout that decade to a full-fledged system in which any program can be implemented in any language, no matter whether it is functional, imperitive or object-oriented, and no matter what platform the programs are compiled to.
See The Author.
Installing this library is very simple: just unzip the library into your DJGPP directory, and all the files will be put into place. That includes this info file, which is included as of version 1.1.1 release 1 for the library.
If you're installing the library for the very first time, you should type the following from your DJGPP/INFO directory:
install-info -d dir -i libSwing
This will install this documentation, in INFO format, into the
directory of your info files (the one you see if you only type info
on the command-line).
The Swing Library was designed to aid in the application of the model, and contains a collection of housekeeping methods and methods I found lacking from the language C. It consists of a number of modules, all written in C.
No knowledge of the Engine Model is required to use this library, and this library is not required to use the Engine Model. The only link between the two is that the Swing library was designed to aid in the implementation of the Engine Model, for which purpose the Housekeeping methods were created.
As you read this documentation, you will probably find there's nothing in this library you could not have written yourself. The only reason this library might come in handy, is that these methods, though simple and straightforward by nature, are really very flexible, and have already been written so you don't have to do it yourself. Though I try re-inventing the wheel every chance I get, I don't think it's really necessary for you to have to do the same..
If you find anything lacking from this library, or have something you would like to add, please contact me (See The Author.).
The Swing Library is set up in such a way that you can use a single header file, <swing.h>, to use all the features of the library. You can simply add #include <swing.h> to your source code to access the features. The <swing.h> header doesn't contain much - just definitions of some variable types common to other languages, but not to C, and the initSwing() (See initSwing.) method, to initialize the library. The rest of the features if accessible from the other modules in the Swing library, which are included using the LSW1_* defines before including the <swing.h> file. All can be included simultaniously using LSW1_All like this:
#define LSW1_All #include <swing.h>
For more info, read the next node, about the modules of the library.
The Swing Library consists of the following modules:
These modules can be used seporatly, with only their own headers being included, using the LSW1_* defines. The easiest way to use them, is by including them all, using this code to begin your source code:
#define LSW1_All #include <swing.h>
This will include all the modules.
The Swing module consists of only one method you should call: initSwing() (See initSwing.).
#include <swing.h> bool initSwing(void);
initSwing() initializes the library. You MUST call this method before you do anything else with the library.
true if successful, false if not.
This module contains the methods used to implement the Engine Model. All that is needed to trap and identify errors is located here. The actual trapping will still be your job, as will the actual identifying, but this module should point the way on how to do it, and help you handle errors using the generic error handler (Note: generic, not general.)
Use the module with #define LSW1_houseKeeping
. The <houseKeeping.h>
header file defines a lot of errors that may occur in this library
(predominantly when used wrong or your computer fails), and some significant
for the VPL3 library (which you probably won't need unless you're
programming for VGA Planets).
#define LSW1_houseKeeping #include <swing.h> bool initHousekeeping(void);
This initializes the housekeeping module of the Swing library. As it is called by initSwing(), you will not need to call it yourself - ever - so don't.
true if successful, false if not
#define LSW1_houseKeeping #include <swing.h> void doneHousekeeping(void);
This shuts down the housekeeping module of the Swing library. As it is called by doneSwing(), you will not need to call it yourself - ever - so don't.
none
#define LSW1_houseKeeping #include <swing.h> bool addError(errorType *e);
Adds an error to the error list. The error list is a list of error descriptors of type errorType
, which is defined as:
typedef struct _errorType { bool isDefined; // always true (except in empty error) int code; // number of the error char *errorMessage; // message displayed for the error bool (*handler)(void); // handler for the error bool isFatal; // is this error always fatal? } errorType;The
isDefined
field is used only by the housekeeping module
itself - you should not try to alter it, and for new errors, it should
always be true. The code
field holds a unique identifyer of the error,
which can best be represented by a define somewhere in your own source code.
The errorMessage
field holds an error message, which is displayed when
the error has occured, was trapped and identified, and the generic handler
was called. The handler
field is a pointer to the handler of the error
or NULL if none is available. The error handler should handle the error and
be able to do so at any time. It is part of your own program, and you should
write it yourself. The isFatal
field signifies whether the error is
fatal or not, even if handled correctly. If no handler is specified and the
error is not fatal, the generic handler only displays a warning message. If
the error is not fatal but a handler has been specified, the handler is
invoked and, if successful, a warning message is displayed. If the handler is
not successful, the error is considered to be fatal anyway. If the error is
fatal and a handler has been specified, the handler is invoked and an error
message is displayed, after which the program is shut down, regardless of
whether or not the handler was successful.
#define LSW1_houseKeeping #include <swing.h> /* ... */ bool handleMyError(void) { bool rv = true; /* ... do what ever it takes ... */ return(rv); } // handleMyError() bool initErrorList(void) { bool rv = true; errorType eList[] = { {true, EMYERROR, "My error has occured!", handleMyError, false}, {false, 0, NULL, NULL, true}, } // eList[] int i; for (i = 0; rv && eList[i].isDefined; i++) { if (rv) rv = addError(&(eList[i])); } // for return(rv); } // initErrorList()
true if successful, false if not
#define LSW1_houseKeeping #include <swing.h> bool removeError(int e);
Removes an error from the error list (For more information about the error list, addError.) by it's unique ID number. This method is almost never used, and I frankly don't see how it could come in handy, as it is rather easy to maintain a list of different error numbers without having them overlap, but what you can add, you should be able to remove..
true if successful, false if not.
#define LSW1_houseKeeping #include <swing.h> void beep(void);
Makes the computer beep, through normal speakers.
#define LSW1_houseKeeping #include <swing.h> /* ... */ int myBleepingMethod(/* ... */) { /* ... */ beep(); /* ... */ } // myBleepingMethod() /* ... */
none.
#define LSW1_houseKeeping #include <swing.h> bool isFatal(int e);
Checks the error list for a certain error, and returns whether it is fatal (true) or not (false). If the error is undefined, it is fatal by default.
true if the error is fatal or undefined, false if it isn't fatal.
#define LSW1_houseKeeping #include <swing.h> void done(int e);
Shuts down the program with an error message beginning with: Error:
.
The actual error message is defined by the type of error that has occured,
which is passed to the method.
#define LSW1_houseKeeping #include <swing.h> /* ... */ bool rv = true; // global RunControl variable /* ... */ int main(int argc, char **argv) { /* ... */ if (rc) { return(0); } else done(errCode); } // main()
Note that errCode is a standard variable from the Engine Model, as
is the RunControl variable. The model defines that, if an error has occured,
errCode is set to the error, if trapped and identified, and the RunControl
variable (usually called rc
) is cleared. As long as rc is set, the
program can continue with whatever it is doing. If it's cleared, handle()
should be called if it's possible that the error is non-fatal. Otherwise,
the program should shut down. Unidentified errors leave errCode at 0 (EUNKN)
which would have done() display a message: Error: an unknown error has occured (EUNKN)
;
Doesn't return.
#define LSW1_houseKeeping #include <swing.h> void cancel(int e);
Very much like done() (See done.) it shuts down the program. In stead of
a message starting with Error:
it starts the message with
Abort:
, but aside from that, it does exactly the same.
It is most often used when the user aborts the program for some reason, while done() is most often used to shut down the program when an error has occured.
Doesn't return.
#define LSW1_houseKeeping #include <swing.h> void warning(int e);
Displays a warning message starting with Warning:
. The actual message
is defined by the error number passed to the method, which should appear in
the error list. It is most often used if some non-fatal error has occured.
none
#define LSW1_houseKeeping #include <swing.h> bool handle(int e);
Generic error handler. If an error has occured that might be non-fatal (or might have a handler), pass the error code to this handler. It will look the error up in the error list and invoke the handler (if any).
#define LSW1_houseKeeping #include <swing.h> /* ... */ bool myDispatcher(void) { bool rv = true; /* ... */ if (rv) rv = someFunction(); if (!rv) rv = handle(errCode); /* ... */ return(rv); } // myDispatcher() /* ... */
true if the error was handled successfully, and non-fatal, false if the error was not handled successfully, or it was fatal.
The User I/O Module contains a number of methods designed to take some of the hassle involved in user I/O away. It contains two types of methods: user input methods, and user output methods.
The user input methods allow you to get any type of input from the user, in a way that doesn't require the user to adhere to any specific formats, as the standard C methods do. As you cannot actually control the type of input the user will give you, formatted input doesn't always cut it, and unformatted input is often more of a hassle that you'd like. The user input methods of this module are designed to only take the input allowed by you, and beep on anything else. If you want a number between two boundaries, and only between those two, (like a percentage, a time, a valid date, etc.) these will allow the user to only input those allowable values, and nothing else.
The user output methods allow you to easily handle LOG files: just open a LOG file and use duelprint() in stead of printf() and fprintf(). Regardless of whether you have or have not opened a LOF file, duelprint will always produce output on the screen. If a LOG file is open, it will also put the output in the LOG file. The only restriction is that you use the logFile file pointer for your LOG file. the openLogFile() and closeLogFile() methods make this natural.
Use this module with LSW1_userIO
when include <swing.h>
#define LSW1_userIO #include <swing.h> bool openLogFile(char *fN, bool doCreate);
Opens a LOG file, creates it if wanted (if doCreate is set to true)
true if successful, false if not. If the LOG file does not exist and doCreate was not set, it will always fail, so handling that error would consist of another call to openLogFile() with doCreate set.
#define LSW1_userIO #include <swing.h> bool closeLogFile(void);
Closes the LOG file and clears the logFile pointer.
true if successful, false if not. Regardless whether the actual closing of the file succeeded, logFile will be cleared on return from this method.
#define LSW1_userIO #include <swing.h> bool duelprint(char *fmt, ...);
Outputs a formatted string (formatted just like the printf() family) to the screen and (if open) the LOG file. It checks the global logFile pointer to see if the LOG file is opened. logFile should be NULL if the LOG file is closed.
#define LSW1_userIO #include <swing.h> /* ... */ /* ... */ myMethod(/* ... */) { bool rv = true; /* ... */ if (rv) rv = duelprint("Hello, world!\nIt\'s %d degrees outside, and I'm %s happy about it!", temp, ((temp < 25) ? ("not") : ("very"))); /* ... */ } // myMethod()
true if successful, false if not. If logFile is not open, it is always successful.
#define LSW1_userIO #include <swing.h> bool duelprinterror(char *fmt, ...);
Outputs a formatted string (formatted just like the printf() family) to stderr and (if open) the LOG file. It checks the global logFile pointer to see if the LOG file is opened. logFile should be NULL if the LOG file is closed.
Available from version 1, revision 1, edition 1, release 1 of this library.
#define LSW1_userIO #include <swing.h> bool scan(char*, int);
Let's the user input a number of characters through the keyboard - unformatted - and puts them in the character array..
#define LSW1_userIO #include <swing.h> /* ... */ /* ... */ myMethod(/* ... */) { bool rv = true; char theInput[21]; /* ... */ if (rv) printf("Now input up to 20 characters"); if (rv) rv = scan(theInput, 20); /* ... */ } // myMethod()
true if successful, false if not. Pressing ESC or control-C will abort the input. Pressing enter will finish the input regardless of the length.
#define LSW1_userIO #include <swing.h> char scanKey(char *keys);
Let's the user input a single character and will only accept characters from a pre-defined set.
From UUE:
#define LSW1_userIO #include <swing.h> /* ... */ bool ask(char *fmt, ...) { bool rv = true; short count; va_list arg; char c; va_start(arg, fmt); count = vprintf(fmt, arg); if (rc && logFile) rv = (vfprintf(logFile, fmt, arg) == count); if (rc) rc = (fflush(stdout) == 0); if (rc && logFile) rc = (fflush(logFile) == 0); va_end(arg); if (rc && assumeYes) { duelprint(" YES\n"); } else if (rc && assumeNo) { duelprint(" NO\n"); } else if (rc) { c = scanKey("yYnN"); if ((c == 'y') || (c == 'Y')) { rv = true; duelprint(" YES\n"); } else { rv = false; duelprint(" NO\n"); } // if } // if return(rv); } // ask() /* ... */
The character entered.
#define LSW1_userIO #include <swing.h> bool scanDate(long *date);
Allows the user to input a valid date and puts it's value in the DATE parameter. Using the Date and Time module in this library (See The Date and Time Module.), you can change the value to a readable date. The value is the number of days since 01-01-0001.
true if successful, false if not (user aborted with ESC or ctrl-C).
#define LSW1_userIO #include <swing.h> bool scanTime(long *time);
Allows the user to input a valid time and puts it's value in the TIME parameter. Using the Date and Time module in this library (See The Date and Time Module.), you can change the value to a readable time. The value is the amount of seconds since midnight.
true if succesful, false if not (user aborted with ESC or ctrl-C).
#define LSW1_userIO #include <swing.h> bool scanPercentage(byte *P);
Allows the user to input a valid percentage (0 - 100%), and returns it in P.
true if succesful, false if not (user aborted with ESC or ctrl-C).
#define LSW1_userIO #include <swing.h> int scanNumber(int lo, int hi);
Allows the user to input an integer between LO and HI and returns the value.
the value entered, or (LO - 1) on failure (user aborted with ESC or ctrl-C).
This module contains just one method at the moment, which I found lacking from the C language. ANSI-C doesn't give you any "nice" way to hget the length of a file, and filelength() isn't ANSI or POSIX, so I made flength, which uses an ANSI-compliant way to get the file length.
Use this module with LSW1_fileIO
when including <swing.h>
#define LSW1_fileIO #include <swing.h> long flength(FILE *F);
Gets the length of an open file F.
The length of the file, or -1 on error.
The Date and Time Module allows for intuitive date and time handling, without having to think about Y2K, computer ticks, milliseconds, etc. etc.
I've always found the "standard" ways of handling dates and times a bit too complicated to explain to the computing dummies, so I decided to make it a bit more intuitive: this module regards any time of day as the number of seconds since midnight, and the date as the number of days since the start of our calendar. This makes it very easy to handle times and dates and to calculate what day it is, what date it is (keeping leapyears in mind) etc. It is completely Y2K compliant/compatible, so you never have to think about any of this again.
On request, the chistian and muslim holidays can be implemented. I know the christian ones, but not the muslim ones, so if someone wants them implemented, I'll need a list of them..
I'll also be happy to implement other calendars (the lunar calendar, jewish calendar, etc.) on request, if someone can provide me with the specs..
Use this module with LSW1_dateAndTime
when including <swing.h>
#define LSW1_dateAndTime #include <swing.h> bool isLeap(unsigned int Y); // actually: it's a macro
Determines whether or not the input year Y is a leapyear (has an extra day
in February). It is actually a macro, but you should consider it as the
method bool isLeap(unsigned int Y)
.
true (actually: 1) if the year is a leapyear, false if not.
#define LSW1_dateAndTime #include <swing.h> int daysInYear(unsigned int Y); // actually: it's a macro
Determines the number of days in a given year. Though it is actually a
macro, you should handle it as if it's defined as
int daysInYear(unsigned int Y);
.
The number of days in the given year.
#define LSW1_dateAndTime #include <swing.h> int daysInMonth(unsigned int M, unsigned int Y); // actually a macro
Determines the number of days (28, 29, 30 or 31) in a given month.
The number of days in the given month. Note that if the month is invalid, the macro still returns 30 by default!
#define LSW1_dateAndTime #include <swing.h> bool isValidYear(int Y); // actually a macro
Determines whether a given year is in the calendar (is higher than 0).
true if Y > 0, else false.
#define LSW1_dateAndTime #include <swing.h> bool isValidMonth(int M); // actually a macro
Determines whether a given month is valid (greater than or equal to 1; smaller than or equal to 12).
true if the given month is valid, false if not.
#define LSW1_dateAndTime #include <swing.h> bool isValidDay(int D, int M, int Y); // actually a macro
Determines whether the given day is possible in the given month, in the given year, but does not check the month and year for validity.
true if valid, false if not.
#define LSW1_dateAndTime #include <swing.h> bool isValidDate(int D, int M, int Y); // actually a macro
Determines whether a given date is valid. Checks whether the year is valid,
whether the month is valid, whether the day is valid, and wether the month
had enough days for the given day: while isValidDate(29, 2, 1996)
will
return true, isValidDate(29, 2, 1997)
will not, because the 29th of
February never existed in 1997, while it did in 1996.
true if the date is valid, false if not.
#define LSW1_dateAndTime #include <swing.h> void numToDate(int N, int *D, int *M, int *Y);
Converts a date number to a date. The date number is the amount of days passed since 01-01-0001, and is the standard way the Swing library uses to calculate dates. numToDate() takes leap years etc. into account, and is Y2K compliant.
none
#define LSW1_dateAndTime #include <swing.h> int dateToNum(int D, int M, int Y);
Converts a date to a date number. The date number is the amount of days passed since 01-01-0001, taking leap years etc. into account. This is the standard way the Swing library handles dates, and is Y2K compliant.
The date number corresponding to the given date.
#define LSW1_dateAndTime #include <swing.h> dayType numToDay(int n);
Converts a given date number to the corresponding day. dayType is defined as:
typedef enum { _sunday_, _monday_, _tuesday_, _wednesday_, _thursday_, _friday_, _saturday_ } dayType;
The day corresponding to the given date number.
#define LSW1_dateAndTime #include <swing.h> dayType dateToDay(int D, int M, int Y);
Converts a given date to the corresponding day. dayType is defined as:
typedef enum { _sunday_, _monday_, _tuesday_, _wednesday_, _thursday_, _friday_, _saturday_ } dayType;This is Y2K compliant.
The day corresponding to the given date,
#define LSW1_dateAndTime #include <swing.h> long timeToNum(int H, int M, int S);
Converts a given time to a time number, which is the number of seconds passed since midnight.
The time number corresponding to the given time.
#define LSW1_dateAndTime #include <swing.h> bool isValidTime(int H, int M, int S);
Determines whether a given time is valid.
true if the time is valid, false if not.
#define LSW1_dateAndTime #include <swing.h> void numToTime(int N, int *H, int *M, int *S);
Converts a given time number to a valid time. If the time number is greater than the amount of seconds in a day, the time on the next day is returned.
none
#define LSW1_dateAndTime #include <swing.h> long currentTimeNum(void);
Gets the time number of the current time.
The number of seconds passed since midnight, now.
#define LSW1_dateAndTime #include <swing.h> void currentTime(int *H, int *M, int *S);
Gets the current time.
none
This module contains a couple of methods I found lacking frm the C language. These primarily include methods found in the BASIC language. Some of them actually do have C counterparts, but not all of them.
You should probably know that BASIC was the first language I started programming in. I've made most of these methods in every other language I programmed in ever since.
Use this module with LSW1_strings
when including <swing.h>
#define LSW1_strings #include <swing.h> void copyPath(char s1[], char s2[]);
Copies the path-part from S2 to S1 and converts backslashes (\) to forward slashes as it does so.
none
#define LSW1_strings #include <swing.h> char *invert(char s[]);
Inverts a string.
The inverted string (pointer to S).
#define LSW1_strings #include <swing.h> char *left(char s[], short length);
Strips anything off S that doesn't fit within the first LENGTH characters.
A pointer to S
#define LSW1_strings #include <swing.h> char *right(char s[], short length);
Takes the first characters out of S, as far as required to leave the last
LENGTH characters. It does not to so by simply increasing the pointer to S,
so you can still use free()
on it.
A pointer to S.
#define LSW1_strings #include <swing.h> char *uCase(char *s);
Converts S to upper case. This does not handle high-bit characters, because they vary in different charsets.
A pointer to S.
#define LSW1_strings #include <swing.h> char *lCase(char *s);
Converts S to lower-case characters. This does not handle high-bit characters because they vary in different charsets.
A pointer to S.
#define LSW1_strings #include <swing.h> int val(char s[]);
Gets the value of the string S.
The value of S, or 0 if it contains non-digit characters.
#define LSW1_strings #include <swing.h> char *str(int i, char s[]);
Makes a string with an integer value.
#define LSW1_strings #include <swing.h> /* ... */ char s[6] printf("%s", str(65536, s)); /* ... */
This would put 65536
on the screen, and leave it in s.
A pointer to S.
#define LSW1_strings #include <swing.h> char *hex(int n, char s[]);
Puts the hexadecimal representation of N in S.
A pointer to S.
#define LSW1_strings #include <swing.h> unsigned int hex2Int(char *s);
Calculates the integer value represented by the hex string S.
The integer value represented by S or 0xFFFFFFFFL if S is not a valid hex number.
This module contains a number of methods I found lacking from C. Most of them are available in C for NULL-terminated strings, but not for any-length memory buffers. They are named after their string-counterparts and behave mostly the same.
Use this module with LSW1_memIO
when including <swing.h>
#define LSW1_memIO #include <swing.h> void *memstr(const void *buffer, const char *sFind, const int length);
Finds a string sFind
in a memory block buffer
of length
length
.
A pointer to the first character of sFind
in buffer
or NULL
if it wasn't found.
#define LSW1_memIO #include <swing.h> void *memspn(const void *buffer, const char *sFind, const int length);
Finds the first character that matches any of the characters from
sFind
in memory block buffer
of length length
.
A pointer to the first character from sFind
found in buffer
or NULL if it wasn't there.
#define LSW1_memIO #include <swing.h> void *memrchr(const void *buffer, const char cFind, const int length);
Finds the character cFind
in memory block buffer
of length
length
.
A pointer to cFind
in buffer
or NULL if it wasn't found.
#define LSW1_memIO #include <swing.h> int memind(const void *buffer, const char cFind, const int length);
Finds the character cFind
in memory block buffer
of length
length
.
The index of cFind
in buffer
or -1 if it isn't there.
#define LSW1_memIO #include <swing.h> int strind(const void *buffer, const char cFind);
Finds a character cFind
in NULL-terminated string buffer
.
The index of cFind
in buffer
or -1 if it isn't there.
Contrary to most libraries available for DJGPP today, this library was not published under GNU Public License or GNU Library Public License. I'm still thinking about doing that, but for the time being, I won't. Still, I do believe in the concept of sharing source code, and I am willing to do so. Should you want to have parts of the source code of this library, you can mail me about it, and tell me why you want the source code - what you want to use it for. I will the consider your request and possibly send you the source code and/or the algorithm it was based on.
You can register your copy of the RLSystems Swing Library V1 FOR FREE by mailing me at dlanor@dds.nl
There are two very simple reasons why you should register this library:
First, there are four things you can register, which all include this library and any of which you can register (for free at this time):
You can contribute to this library in one of four ways:
Currently, the contributers to this library (including myself) are:
The author of this library and of The Engine Model is known to the internet community as Dlanor Blytkerchan. You can reach him by sending an E-mail to dlanor@dds.nl.
Dlanor Blytkerchan has been alive as such since the end of the '80s - before
that he was only known by his name IRL. All the significant software Dlanor
ever produced was produced under the name Dlanor Blytkerchan and/or
RLSystems. The very first of the RLSystems software was published in a local
BBS, which no longer exists. At later times, the software was primarily put
on the web, at a page that is still in use to a certain extent. It's URL is
<http://huizen.dds.nl/~dlanor
>.
Other useful things from this author are:
addError
: addError
beep
: beep
cancel
: cancel
closeLogFile
: closeLogFile
copyPath
: copyPath
currentTime
: currentTime
currentTimeNum
: currentTimeNum
dateToDay
: dateToDay
dateToNum
: dateToNum
daysInMonth
: daysInMonth
daysInYear
: daysInYear
done
: done
doneHousekeeping
: doneHousekeeping
duelprint
: duelprint
duelprinterror
: duelprinterror
flength
: flength
handle
: handle
hex
: hex
hex2Int
: hex2Int
initHousekeeping
: initHousekeeping
initSwing
: initSwing
invert
: invert
isFatal
: isFatal
isLeap
: isLeap
isValidDate
: isValidDate
isValidDay
: isValidDay
isValidMonth
: isValidMonth
isValidTime
: isValidTime
isValidYear
: isValidYear
lCase
: lCase
left
: left
memind
: memind
memrchr
: memrchr
memspn
: memspn
memstr
: memstr
numToDate
: numToDate
numToDay
: numToDay
numToTime
: numToTime
openLogFile
: openLogFile
removeError
: removeError
right
: right
scan
: scan
scanDate
: scanDate
scanKey
: scanKey
scanNumber
: scanNumber
scanPercentage
: scanPercentage
scanTime
: scanTime
str
: str
strind
: strind
timeToNum
: timeToNum
uCase
: uCase
val
: val
warning
: warning