void JInsets::readContent(JDictionary& dict) {
JObject::readContent(dict);
left = getInteger(dict, "left");
top = getInteger(dict, "top");
right = getInteger(dict, "right");
bottom = getInteger(dict, "bottom");
}
void duplicacionVariants() {
Variant variantEntero;
int miEntero = 572;
initialize( &variantEntero );
set( &variantEntero, &miEntero, sizeof(int) /* 4 bytes */, 1 );
Variant* nuevoVariant = duplicate( &variantEntero );
printf( "Valor del variant origen: %d\n",
getInteger(&variantEntero) );
printf( "Valor del nuevo variant (debe ser igual al origen): %d\n",
getInteger(nuevoVariant) );
double miDouble = 741.34;
set(nuevoVariant, &miDouble, sizeof(miDouble), 1 );
printf( "Valor del nuevo variant: %f\n",
getDouble(nuevoVariant) );
printf( "Luego de modificar el variant duplicado el origen no cambia: %d\n",
getInteger(&variantEntero) );
// EL NUEVO VARIANT TENGO QUE liberarlo
free( nuevoVariant );
}
/*
* This function translates an address without
* invoking execution on errors.
* returns page_no and word_no as -1 on failure
*/
struct address translate_debug (int virtual_addr)
{
struct address resultant_addr;
resultant_addr.page_no = -1;
resultant_addr.word_no = -1;
if(mode == USER_MODE)
{
int page_entry;
if(getType(reg[PTBR_REG]) == TYPE_STR || getType(reg[PTLR_REG]) == TYPE_STR || virtual_addr < 0
|| virtual_addr >= getInteger(reg[PTLR_REG]) * PAGE_SIZE)
return resultant_addr;
page_entry = getInteger(reg[PTBR_REG]) + (virtual_addr / PAGE_SIZE) * 2;
if(page[(page_entry+1) / PAGE_SIZE].word[(page_entry+1) % PAGE_SIZE][1] == VALID )
{
resultant_addr.page_no = getInteger(page[page_entry / PAGE_SIZE].word[page_entry % PAGE_SIZE] );
resultant_addr.word_no = virtual_addr % PAGE_SIZE;
page[(page_entry+1) / PAGE_SIZE].word[(page_entry+1) % PAGE_SIZE][0] = REFERENCED;
}
return resultant_addr;
}
else
{
if( virtual_addr < 0 || virtual_addr >= SIZE_OF_MEM )
return resultant_addr;
resultant_addr.page_no = virtual_addr / PAGE_SIZE;
resultant_addr.word_no = virtual_addr % PAGE_SIZE;
return resultant_addr;
}
}
void JBSubObj::readContent(JDictionary& dict) {
JBAddObj::readContent(dict);
JObject *obj = getObject(dict, "block");
if (obj) block = *(JBlock*)obj;
begin = getInteger(dict, "begin");
end = getInteger(dict, "end");
}
const ValVec<htmRange> &
htmInterface::domainCmd( char *str ) {
cmd_ = str;
if(t_)delete t_;
t_ = new VarStrToken(cmd_);
cmdCode code = getCode();
if(code != HTMDOMAIN)
throw SpatialInterfaceError("htmInterface:domainCmd: missing keyword HTMDOMAIN");
getDepth();
int32 nx,nc;
nx = getInteger();
SpatialDomain dom;
for(int32 i = 0 ; i < nx; i++ ) {
SpatialConvex convex;
nc = getInteger();
for(int32 j = 0; j < nc; j++ ) {
float64 x = getFloat();
float64 y = getFloat();
float64 z = getFloat();
float64 d = getFloat();
SpatialConstraint c(SpatialVector(x,y,z),d);
convex.add(c);
}
dom.add(convex);
}
return domain(dom);
}
struct address translate(int virtual_addr) {
if (mode == USER_MODE) {
struct address resultant_addr;
int page_entry;
resultant_addr.page_no = -1;
resultant_addr.word_no = -1;
if (getType(reg[PTBR_REG]) == TYPE_STR) {
raiseException(newException(EX_ILLMEM, "Illegal Register Value.\n", 0));
return resultant_addr;
}
page_entry = getInteger(reg[PTBR_REG]) + (virtual_addr / PAGE_SIZE) * 2;
if (page[(page_entry+ 1 ) / PAGE_SIZE].word[(page_entry + 1) % PAGE_SIZE][1] == VALID ) {
resultant_addr.page_no = getInteger(page[page_entry / PAGE_SIZE].word[page_entry % PAGE_SIZE] );
resultant_addr.word_no = virtual_addr % PAGE_SIZE;
page[(page_entry + 1) / PAGE_SIZE].word[(page_entry + 1) % PAGE_SIZE][0] = REFERENCED;
}
else raiseException(newException(EX_PAGEFAULT, "Page Fault.\n", virtual_addr / PAGE_SIZE));
return resultant_addr;
} else {
struct address resultant_addr;
resultant_addr.page_no = virtual_addr / PAGE_SIZE;
resultant_addr.word_no = virtual_addr % PAGE_SIZE;
return resultant_addr;
}
}
Exception isSafeState2() {
if (getType(reg[SP_REG]) == TYPE_STR || getType(reg[BP_REG]) == TYPE_STR || getType(reg[PTLR_REG]) == TYPE_STR
|| getType(reg[PTBR_REG]) == TYPE_STR) {
return newException(EX_ILLMEM, "Illegal Register value", 0);
}
if (getInteger(reg[PTBR_REG]) < 0 || getInteger(reg[PTBR_REG]) >= SIZE_OF_MEM) {
return newException(EX_ILLMEM, "Illegal address access.\n PTBR value is out of bounds.", 0);
}
if (getInteger(reg[PTLR_REG]) < 0 || getInteger(reg[PTLR_REG]) >= SIZE_OF_MEM) {
return newException(EX_ILLMEM, "Illegal address access.\n PTLR value is out of bounds.", 0);
}
if (getInteger(reg[SP_REG]) + 1 < 0) {
return newException(EX_ILLMEM, "Stack underflow\n", 0);
}
if (getInteger(reg[SP_REG]) >= SIZE_OF_MEM || (mode == USER_MODE && getInteger(reg[SP_REG]) >= getInteger(reg[PTLR_REG]) * PAGE_SIZE)) {
return newException(EX_ILLMEM, "Stack overflow\n", 0);
}
if (getInteger(reg[BP_REG]) < 0) {
return newException(EX_ILLMEM, "Negative Value for BP Register\n", 0);
}
if (getInteger(reg[BP_REG]) >= SIZE_OF_MEM || (mode == USER_MODE && getInteger(reg[BP_REG]) >= getInteger(reg[PTLR_REG]) * PAGE_SIZE)) {
return newException(EX_ILLMEM, "BP Register Value out of bounds\n", 0);
}
return newException(EX_NONE, "", 0);
}
int performPop(int X, int flagX) {
char * value;
Exception e;
Address T = translateAddress(getInteger(reg[SP_REG]));
if (T.page == -1 && T.word == -1) return 0;
switch (flagX) {
case REG:
e = isRegisterInaccessible(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
value = getWordFromAddress(T);
strcpy(reg[X], value);
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) - 1);
return 1;
break;
case IP:
raiseException(newException(EX_ILLOPERAND, "Illegal operand IP. Cannot alter readonly register", 0));
return 0;
break;
case EFR:
raiseException(newException(EX_ILLOPERAND, "Illegal operand EFR. Cannot alter readonly register", 0));
return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal Operand", 0));
return 0;
break;
}
}
int performPush(int X, int flagX) {
Address T = translateAddress(getInteger(reg[SP_REG]) + 1);
if (T.page == -1 && T.word == -1) return 0;
Exception e;
switch (flagX) {
case REG:
case SP:
case BP:
case IP:
case PTBR:
case PTLR:
case EFR:
e = isRegisterInaccessible(X);
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
if (storeWordToAddress(T, reg[X])) {
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) + 1);
return 1;
} else return 0;
break;
default:
raiseException(newException(EX_ILLOPERAND, "Illegal Operand", 0));
return 0;
break;
}
}
void mainloop(Screen &screen)
{
setcolor(EGERGB(255,255,255));
int temp1,temp2,temp3,temp4;
MyRectangle tempreg(0,0,0,0,&screen);
cleardevice();
int i,j;
j =getInteger("How many rectangle?");
MyRectangle *rectangle=new MyRectangle[j];
for(i=0;i<j;i++)
{
rectangle[i] =tempreg;
}
for(i=0;i<j;i++)
{
temp1 =getInteger("Set x1");
temp2 =getInteger("Set y1");
temp3 =getInteger("Set x2");
temp4 =getInteger("Set y2");
(rectangle+i)->setCoordinations(temp1,temp2,temp3,temp4);
}
for ( ; is_run(); delay_fps(60) )
{
cleardevice();
for(i=0;i<j;i++)
{
(rectangle+i)->Draw();
}
}
delete[] rectangle;
}
int performIRET() {
if (mode == USER_MODE) {
raiseException(newException(EX_ILLINSTR, "Call to Privileged Instruction IRET in USER mode", 0));
return 0;
}
Exception e = isSafeState2();
if (e.code != EX_NONE) {
raiseException(e);
return 0;
}
mode = USER_MODE;
Address T = translateAddress(getInteger(reg[SP_REG]));
if (T.page == -1 && T.word == -1) {
mode = KERNEL_MODE;
return 0;
}
char * value = getWordFromAddress(T);
if (getType(value) == TYPE_STR) {
mode = KERNEL_MODE;
raiseException(newException(EX_ILLMEM, "Illegal return address", 0));
return 0;
}
int result = getInteger(value);
if (result < 0 || result >= getInteger(reg[PTLR_REG]) * PAGE_SIZE) {
mode = KERNEL_MODE;
raiseException(newException(EX_ILLMEM, "Illegal return address", 0));
return 0;
}
storeInteger(reg[IP_REG], result);
storeInteger(reg[SP_REG], getInteger(reg[SP_REG]) - 1);
return 1;
}
void J1DMObj::readContent(JDictionary& dict) {
JNBitsObj::readContent(dict);
pv[0] = v[0] = getInteger(dict, "v0");
pv[1] = v[1] = getInteger(dict, "v1");
ov[0] = getInteger(dict, "ov0");
ov[1] = getInteger(dict, "ov1");
}
void JTNG4Obj::readContent(JDictionary& dict) {
JTNG3Obj::readContent(dict);
extraInputCount = getInteger(dict, "extraInputCount");
extraInputCount = max(0, min(32-IN_LAST, extraInputCount));
igm = IN_LAST+extraInputCount;
oseparators[0] = getInteger(dict, "oseparator0");
oseparators[1] = getInteger(dict, "oseparator1");
}
void JRealComplexObj::readContent(JDictionary& dict) {
JLabelObj::readContent(dict);
cval.r = getDouble(dict, "real");
cval.i = getDouble(dict, "imag");
w = getInteger(dict, "w");
f = getInteger(dict, "f");
label = JComplex::toJStringF(cval, w, f);
}
void exception(char str[50]) {
if(getInteger(reg[IP_REG])<0 || getInteger(reg[IP_REG]) > SIZE_OF_MEM)
printf("<ERROR:%s\nTried to access IP:%d\n", str, getInteger(reg[IP_REG]));
else
printf("<ERROR:%d:%s> %s\n",getInteger(reg[IP_REG]),instruction, str);
exit(0);
//storeInteger(reg[IP_REG], EXCEP_HANDLER * PAGE_SIZE);
}
bool TimeCommand::execute(SMPlayer *sender, std::string &commandLabel, std::vector<std::string> &args)
{
if((int)args.size() < 1)
{
sender->sendTranslation("§c%commands.generic.usage", {usageMessage});
return false;
}
if(!args[0].compare("start"))
{
ServerManager::getLevel()->getHandle()->setDayCycleActive(true);
Command::broadcastCommandMessage(sender, "Restarted the time");
}
else if(!args[0].compare("stop"))
{
ServerManager::getLevel()->getHandle()->setDayCycleActive(false);
Command::broadcastCommandMessage(sender, "Stopped the time");
}
else if(!args[0].compare("query"))
sender->sendTranslation("commands.time.query", {SMUtil::toString(ServerManager::getLevel()->getHandle()->getTime())});
else if(!args[0].compare("set"))
{
if((int)args.size() < 2)
{
sender->sendTranslation("§c%commands.generic.usage", {usageMessage});
return false;
}
int value;
if(!args[1].compare("day"))
value = 0;
else if(!args[1].compare("night"))
value = 14000;
else
value = getInteger(sender, args[1], 0);
ServerManager::getLevel()->getHandle()->setTime(value);
Command::broadcastCommandTranslation(sender, "commands.time.set", {SMUtil::toString(value)});
}
else if(!args[0].compare("add"))
{
if((int)args.size() < 2)
{
sender->sendTranslation("§c%commands.generic.usage", {usageMessage});
return false;
}
int value = getInteger(sender, args[1], 0);
ServerManager::getLevel()->getHandle()->setTime(ServerManager::getLevel()->getHandle()->getTime() + value);
Command::broadcastCommandTranslation(sender, "commands.time.added", {SMUtil::toString(value)});
}
else
sender->sendTranslation("§c%commands.generic.usage", {usageMessage});
return true;
}
void JTNGObj::readContent(JDictionary& dict) {
JANDObj::readContent(dict);
factor = getInteger(dict, "factor");
channelCount = getInteger(dict, "channelCount");
factor = max(1, min(256, factor));
channelCount = max(4, min(32, channelCount));
ogm = channelCount+offset;
for (int i=0; i<channelCount; i++)
inv[i] = getInteger(dict, JString("inv-")+
JInteger::toJString(i+1));
}
CELL * popString(CELL * str, CELL * params)
{
char * ptr;
char * newPtr;
ssize_t index = 0;
ssize_t len = 1;
ssize_t size;
CELL * result;
ptr = (char *)str->contents;
#ifdef SUPPORT_UTF8
size = utf8_wlen(ptr);
#else
size = str->aux - 1;
#endif
if(str->aux < 2)
return(stuffString(""));
if(params != nilCell)
{
params = getInteger(params, (UINT*)&index);
if(params != nilCell)
{
getInteger(params, (UINT*)&len);
if(len < 1) len = 0;
}
}
index = adjustNegativeIndex(index, size);
if((index + len) > size)
len = size - index;
#ifdef SUPPORT_UTF8
newPtr = ptr;
while(index--) /* recalculate index in bytes */
newPtr += utf8_1st_len(newPtr);
index = newPtr - ptr;
while(len--) /* recalculate len in bytes */
newPtr += utf8_1st_len(newPtr);
len = (newPtr - ptr) - index;
#endif
newPtr = callocMemory(str->aux - len);
memcpy(newPtr, ptr, index);
memcpy(newPtr + index, ptr + index + len, str->aux - len - index);
str->aux = str->aux - len;
str->contents = (UINT)newPtr;
result = stuffStringN(ptr + index, len);
free(ptr);
return(result);
}
int isSafeState() {
if (getType(reg[SP_REG]) == TYPE_STR || getType(reg[BP_REG]) == TYPE_STR || getType(reg[PTLR_REG]) == TYPE_STR) {
raiseException(newException(EX_ILLMEM, "Illegal Register Value.\n", 0));
return 0;
}
if (getInteger(reg[PTLR_REG]) < 0 || getInteger(reg[PTLR_REG]) >= SIZE_OF_MEM) {
raiseException(newException(EX_ILLMEM, "Illegal address access.\n PTLR value is out of bounds.\n", 0));
return 0;
}
if (getInteger(reg[SP_REG]) + 1 < 0) {
raiseException(newException(EX_ILLMEM, "Stack underflow.\n", 0));
return 0;
}
if (getInteger(reg[SP_REG]) >= SIZE_OF_MEM || (mode==USER_MODE && getInteger(reg[SP_REG]) >= getInteger(reg[PTLR_REG]) * PAGE_SIZE)) {
raiseException(newException(EX_ILLMEM, "Stack overflow.\n", 0));
return 0;
}
if (getInteger(reg[BP_REG]) < 0) {
raiseException(newException(EX_ILLMEM, "Negative value for BP.\n", 0));
return 0;
}
if (getInteger(reg[BP_REG]) >= SIZE_OF_MEM || (mode==USER_MODE && getInteger(reg[BP_REG]) >= getInteger(reg[PTLR_REG]) * PAGE_SIZE)) {
raiseException(newException(EX_ILLMEM, "BP Register Value out of bounds.\n", 0));
return 0;
}
return 1;
}
/*
* Gets the instruction pointed by IP, to the argument
* Return 0 on success
* Returns -1 on error after setting IP to exception handler
*/
int getInstruction(char *instruction) {
struct address translatedAddr;
int len;
bzero(instruction, WORD_SIZE * WORDS_PER_INSTR);
if (getType(reg[IP_REG]) == TYPE_STR) {
raiseException(newException(EX_ILLMEM, "Illegal IP value. Not an address.\n", 0));
return -1;
}
if (mode == USER_MODE && getType(reg[PTLR_REG]) == TYPE_STR) {
raiseException(newException(EX_ILLMEM, "Illegal PTLR value.\n", 0));
return -1;
}
if (getInteger(reg[IP_REG]) < 0 || getInteger(reg[IP_REG]) + 1 >= SIZE_OF_MEM) {
raiseException(newException(EX_ILLMEM, "IP Register value out of bounds.\n", 0));
return -1;
}
if (mode == USER_MODE) {
if (getInteger(reg[IP_REG]) < 0 || getInteger(reg[IP_REG]) + 1 >= getInteger(reg[PTLR_REG]) * PAGE_SIZE) {
printf("%d", getInteger(reg[IP_REG]));
raiseException(newException(EX_ILLOPERAND, "Illegal IP Access.\n", 0));
return -1;
}
}
translatedAddr = translate(getInteger(reg[IP_REG]));
if (translatedAddr.page_no == -1 && translatedAddr.word_no == -1) return -1;
strcpy(instruction, page[translatedAddr.page_no].word[translatedAddr.word_no]);
translatedAddr = translate(getInteger(reg[IP_REG]) + 1);
if (translatedAddr.page_no == -1 && translatedAddr.word_no == -1) return -1;
len = strlen(instruction);
instruction[len]=' ';
instruction[len + 1]='\0';
strcat(instruction, page[translatedAddr.page_no].word[translatedAddr.word_no]);
return 0;
}
void raiseException(Exception e) {
if (mode == KERNEL_MODE) {
printf("<ERROR:%d:%s> %s\n",getInteger(reg[IP_REG]), instruction, e.message);
if (isDebugModeOn()) debugInterface();
exit(0);
} else {
int ex_flag;
ex_flag = getInteger(reg[IP_REG]) * 1000;
ex_flag += e.fault_page * 10;
ex_flag += e.code;
mode = KERNEL_MODE;
storeInteger(reg[EFR_REG], ex_flag);
storeInteger(reg[IP_REG], EXCEPTION_HANDLER * PAGE_SIZE);
}
}
Person ioHandler::getStudent(string name, PersonList& p_list)
{
//string name;
int korean;
int english;
int math;
//name = getString(" 이름 : ");
korean = getInteger(" 국어성적 : ");
english = getInteger(" 영어성적 : ");
math = getInteger(" 수학성적 : ");
Person p(name, korean, english, math);
return p;
}
int get_int_choice(std::string display_string,const std::set<int> & valid_values)
{
if (valid_values.size()==0) {
std::cout << "trying to get int choice from empty set of valid values..." << std::endl;
return 0;
}
std::cout << display_string;
int userinput = *(valid_values.begin()) - 1;
while (1)
{
userinput = getInteger();
if (valid_values.find(userinput)==valid_values.end()){
std::cout << "value out of bounds." << std::endl;
}
else{
break;
}
}
return userinput;
}
void getConstant(const std::string & str, const unsigned stringStart, Token & token)
{
switch (str[stringStart])
{
case '\'':
if ((str.size() != stringStart + 3) || (str[stringStart + 2] != '\''))
throw(std::runtime_error("Lexer::getConstant: Invalid character constant given"));
token.type = Token::T_OPERAND_CONST_CHAR;
token.charData = str[stringStart + 1];
break;
case 'T':
case 'F':
if (str.size() != stringStart + 1)
throw(std::runtime_error("Lexer::getConstant: Invalid boolean constant given"));
token.type = Token::T_OPERAND_CONST_BOOL;
token.booleanData = (str[stringStart] == 'T');
break;
default:
if (!isdigit(str[stringStart]) && (str[stringStart] != '-'))
throw(std::runtime_error("Lexer::getConstant: Invalid constant given"));
if (str.find('.') != std::string::npos) getReal(str, stringStart, token);
else getInteger(str, stringStart, token);
}
}
int runAverageWithUpperLimit()
{
int a[ARRAY_SIZE];
double average = 0; // for storing the average
int limit = 0; // for storing the limit
printf("9. AVERAGE WITH UPPER LIMIT\n\n");
printf("Function that accepts an array of integers and an upper limit\n"
"as its parameters and returns the average of all the elements with\n"
"values less than or equal to the upper limit.\n\n");
// fill & print an array with random numbers
fillRandom(ARRAY_SIZE, a, -1000, 1000);
printArray(ARRAY_SIZE, a);
// get upper limit from the user
limit = getInteger("Enter upper limit: ");
// calculate the average with upper limit
average = averageUL(ARRAY_SIZE, a, limit);
// print the result
printf("The average of the numbers less than %d in the above array is %0.2lf.\n", limit, average);
return 0;
}
/**
* Function defineInputFile
* Shows a menu with possible input files.
* After the user selection, sets the name of the input file
* to the appropriate name and return a string representing the selection
* @param inputFile string were the input file name will be saved
* @return string representing the choice of the user
*/
string defineInputFile(string &inputFile) {
while (true) {
cout << "Escolha o arquivo de dados de CEP a ser processado: " << endl;
cout << "1 - DF" << endl;
cout << "2 - SC" << endl;
cout << "3 - SP" << endl;
cout << "4 - Todos concatenados" << endl;
int opt = getInteger();
if (opt == 1) {
inputFile = "df.cep";
return "DF_";
}
if (opt == 2) {
inputFile = "sc.cep";
return "SC_";
}
if (opt == 3) {
inputFile = "sp.cep";
return "SP_";
}
if (opt == 4) {
inputFile = "todos.cep";
return "todos_";
}
cout << "errou feio, errou rude." << endl;
}
}
int parseArgument(char * arg) {
if (strcmp(arg, "--debug") == 0 || strcmp(arg, "-d") == 0) {
enableDebugMode();
return 0;
} else {
char * flag_name = strtok(arg, "=");
char * flag_value = strtok(NULL, "=");
int flag_intValue;
if (strcmp(flag_name, "--timer") == 0 || strcmp(flag_name, "-t") == 0) {
if (flag_value != NULL) flag_intValue = getInteger(flag_value);
if (flag_intValue >= 1 && flag_intValue <= 1024) {
enableTimer();
setTimeSlice(flag_intValue);
return 0;
} else if (flag_intValue != 0) {
printf("Invalid arguement %d to timer flag. Timer value should be between 0 and 1024\n", flag_intValue);
return -1;
} else {
disableTimer();
return 0;
}
} else {
printf("Invalid arguement %s", arg);
return -1;
}
}
}
int main(void){
int numDays;
int i;
float sum = 0;
float dailyHigh;
float dailyLow;
char conditions;
float dailyAvg = 0;
printf("\nWeather Analyzer 2.0\n");
printf("=====================\n");
printf("\nHow many days of data? \n");
numDays = getInteger (1, 14);
for(i = 0; i < numDays; i++) {
getDailyData (&dailyHigh, &dailyLow, &conditions);
dailyAvg = average (dailyHigh, dailyLow);
printf("Today's average temperature is: %.2f\n", dailyAvg);
sum += dailyAvg;
draw(symbolToDraw(conditions, dailyAvg), 20);
}
displayResult (numDays, (sum/numDays));
return 0;
}
void JSampleObj::readContent(JDictionary& dict) {
JAddObj::readContent(dict);
N = getInteger(dict, "N");
N = max(1, min(512, N));
igm = N+IN_LAST;
ogm = N;
}
//--------------------------------------------------------------
// attribute set
void mgCursorDefnTag::tagAttr(
mgXMLParser* parser,
const char* attrName,
const char* attrValue)
{
mgCursorDefn* options = (mgCursorDefn*) parser;
if (_stricmp(attrName, "texture") == 0)
getFileName(parser, attrName, attrValue, options->m_texture);
else if (_stricmp(attrName, "hotX") == 0)
options->m_hotX = getInteger(parser, attrName, attrValue);
else if (_stricmp(attrName, "hotY") == 0)
options->m_hotY = getInteger(parser, attrName, attrValue);
}
