/*----------------------------------------------------------------------------*/
void XmlParser::cargarArista(Mapa* mapa,xmlpp::TextReader& reader,int arcoId,string orientacion)
{
int idVerticeOrig=0;
int idVerticeDest=0;
readElement(reader,VERTICE);
idVerticeOrig = getAtributoInt(reader,ATRIB_ID);
readElement(reader,VERTICE);
idVerticeDest = getAtributoInt(reader,ATRIB_ID);
cargarPasillo(mapa,arcoId,orientacion,idVerticeOrig,idVerticeDest);
}
int computeAverageStudyResults(char* FileName, double* Average)
/* pre :
* post : Calculates the average of all study results in a file
* returns: -1 if an error occurs, 0 if a valid average is computed
*/
{
FILE* fptr = fopen(FileName, "rb");
if (fptr == NULL || Average == NULL || FileName == NULL)
{
return -1;
}
int sum = 0;
int index = 0;
STUDENT student;
while (readElement(fptr, index++, &student))
{
sum += student.StudyCredits;
}
if (index == 1)
{
return -1;
}
*Average = (double)sum / (double)--index;
fclose(fptr);
return 0;
}
bool DeckList::loadFromXml(QXmlStreamReader *xml)
{
if (xml->error()) {
qDebug() << "Error loading deck from xml: " << xml->errorString();
return false;
}
cleanList();
while (!xml->atEnd()) {
xml->readNext();
if (xml->isStartElement()) {
if (xml->name() != "cockatrice_deck")
return false;
while (!xml->atEnd()) {
xml->readNext();
if (!readElement(xml))
break;
}
}
}
updateDeckHash();
if (xml->error()) {
qDebug() << "Error loading deck from xml: " << xml->errorString();
return false;
}
return true;
}
/**
* @brief Reads an object from `reader`. An object is a valid JSON structure.
* @param reader The JSONReader.
* @return The object.
*/
static Dictionary *readObject(JSONReader *reader) {
MutableDictionary *object = $(alloc(MutableDictionary), init);
while (true) {
String *key = readLabel(reader);
if (key == NULL) {
const int b = readByteUntil(reader, "}");
assert(b == '}');
break;
}
const int b = readByteUntil(reader, ":");
assert(b == ':');
ident obj = readElement(reader);
assert(obj);
$(object, setObjectForKey, obj, key);
release(key);
release(obj);
}
return (Dictionary *) object;
}
QDomElement XMLConfigDocument::readElement(const QDomElement &baseElem, const QString &name) const
{
QDomElement result;
QString curElemName;
int separator_count = name.count(SEPARATOR);
if( separator_count <= 0)
curElemName = name;
else
curElemName = name.section(SEPARATOR, 0, 0);
QDomNode n = baseElem.firstChildElement(curElemName);
if(!n.isNull())
{
result = n.toElement();
if( separator_count > 0 )
{
QString changedName = name.section(SEPARATOR, 1, name.count(SEPARATOR));
result = readElement(result, changedName);
}
}
return result;
}
/* post : Returns student information of student with student number Number
* returns: -1 if Number is not available or in case of an error, 0 if Number is available
*/
extern int linearSearchStudentsFile (char* FileName, int Number, STUDENT* StudentPtr)
{
if(access(FileName, R_OK ) != -1 && Number)
{
FILE *ptr_file = fopen(*FileName, "rb");
if(ptr_file)
{
fseek(ptr_file, 0, SEEK_END);
int numberOfStudentsInFile = ftell(ptr_file) / sizeof(STUDENT);
fseek(ptr_file, 0, SEEK_SET);
int i = 0;
for (; i < numberOfStudentsInFile; i++)
{
STUDENT student;
readElement(ptr_file, i, &student);
if(Number == student.StudentNumber)
{
*StudentPtr = student;
return 0;
}
}
}
}
return -1;
}
/* post : Adds information from StudentPtr to FileName in a sorted way,
* if FileName does not exist, a new file is created.
* returns: -1 in case of an error
* 0 if a student with the given student number already exists
* 1 if the student is added to the file
*/
extern int addStudentSortedToFile (char* FileName, STUDENT* StudentPtr)
{
if(StudentPtr)
{
FILE *ptr_file = fopen(*FileName, "r+b");
if(ptr_file)
{
fseek(ptr_file, 0, SEEK_END);
int numberOfStudentsInFile = ftell(ptr_file) / sizeof(STUDENT);
fseek(ptr_file, 0, SEEK_SET);
STUDENT tempStudent;
tempStudent.StudentNumber = -1;
int studentAdded = 0;
int i = 0;
for (; i < numberOfStudentsInFile; i++)
{
STUDENT foundStudent;
STUDENT studentPtr = *StudentPtr; //get student number of pointer student?
readElement(ptr_file, i, &foundStudent);
if(tempStudent.StudentNumber != -1)
{
writeElement(ptr_file, i, &tempStudent);
tempStudent = foundStudent;
}
else
{
if(studentPtr.StudentNumber == foundStudent.StudentNumber)
{
return 0;
}
else if(studentPtr.StudentNumber < foundStudent.StudentNumber)
{
readElement(ptr_file, i, &tempStudent);
writeElement(ptr_file, i, &StudentPtr);
numberOfStudentsInFile++;
studentAdded = 1;
}
}
}
if (studentAdded)
{
return 1;
}
}
}
return -1;
}
static void run() {
int lineN;
scanf("%d", &lineN);
for (int line = 0; line < lineN; ++line) {
int command;
int parentId, childId, elementId;
int height, width;
int hash, resultHash;
Element element;
scanf("%d", &command);
switch (command) {
case INIT:
scanf("%d", &expected);
init();
break;
case CREATE:
scanf("%d %d", &elementId, &(element.type));
readElement(&element);
id[elementId] = create(&element);
break;
case ADD:
scanf("%d %d", &parentId, &childId);
add(id[parentId], id[childId]);
break;
case SHOW:
scanf("%d %d %d %d", &elementId, &height, &width, &hash);
show(id[elementId], screen);
resultHash = calcHash(screen, height, width);
#if 0
printf ("Expected W %d H %d\n", width, height);
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
printf("%c", screen[y][x]);
printf("\n");
}
#endif
if (resultHash == hash)
{
point++;
// printf ("%d \n", point);
}
else
{
printf("FAILED %d %d\n", hash, resultHash);
exit (0);
return;
}
break;
}
}
}
int binarySearchStudentsFile(char* FileName, int Number, STUDENT* StudentPtr)
/* pre :
* post : Returns student information of student with student number Number
* returns: -1 if Number is not available or in case of an error, 0 if Number is available
*/
{
FILE* fptr = fopen(FileName, "rb");
if (fptr == NULL || FileName == NULL || StudentPtr == NULL)
{
return -1;
}
STUDENT student;
int first, last, middle, n, search;
n = customfsize(fptr) / sizeof(STUDENT);
first = 0;
last = n - 1;
middle = (first + last) / 2;
search = Number;
while (first <= last)
{
if (readElement(fptr, middle, &student))
{
if (student.StudentNumber < search)
{
first = middle + 1;
}
else if (student.StudentNumber == search)
{
//printf("%d found at location %d.\n", search, middle + 1);
memcpy(StudentPtr, &student, sizeof(student));
break;
}
else
{
last = middle - 1;
}
middle = (first + last) / 2;
}
else
{
break;
}
}
fclose(fptr);
if (first > last)
{
//printf("Not found! %d is not present in the list.\n", search);
return -1;
}
return 0;
}
/**
* @fn ident JSONSerialization::objectFromData(const Data *data, int options)
* @memberof JSONSerialization
*/
static ident objectFromData(const Data *data, int options) {
if (data && data->length) {
JSONReader reader = {
.data = data,
.options = options
};
return readElement(&reader);
}
bool ResourceContext_HRS::loadResV2(uint32 contextSize) {
ResourceData origin;
uint32 firstEntryOffset;
uint32 tableSize;
int i, count;
const uint32 resourceSize = 4 + 4 + 4; // id, size, offset
debug(3, "Context %s =====", _fileName);
_file.seek(0, SEEK_SET);
readElement(_file, origin);
// Check if the file is valid
if (origin.id != MKID_BE('HRES')) { // header
return false;
}
// Read offset of first entry
_file.seek(origin.offset - sizeof(uint32), SEEK_SET);
firstEntryOffset = _file.readUint32LE();
// Allocate buffers for table, categories and data
_categories.resize(origin.size / resourceSize);
tableSize = origin.offset - firstEntryOffset - sizeof(uint32);
_table.resize(tableSize / resourceSize);
// Read categories
count = origin.size / resourceSize;
debug(3, "Categories: %d =====", count);
for (i = 0; i < count; i++) {
readElement(_file, _categories[i]);
}
_file.seek(firstEntryOffset, SEEK_SET);
// Read table entries
count = tableSize / resourceSize;
debug(3, "Entries: %d =====", count);
for (i = 0; i < count; i++) {
readElement(_file, _table[i]);
}
return true;
}
const double& SubMatrixReadAccess::readElement(const unsigned int index)
{
if (index >= (getRows()*getColumns())) {
error("Matrix::element : Subscript out of range\n");
return getDataPointer()[0];
}
return readElement(index / getColumns(), index % getColumns());
}
/* post : Removes student with StudentNumber from file
* returns: 0 if StudentNumber was removed from file
* -1 if StudentNumber was not found or an error occurs
*/
extern int removeStudentFromFile (char* FileName, int StudentNumber)
{
if(access(FileName, W_OK ) != -1 && StudentNumber)
{
FILE *ptr_file = fopen(*FileName, "r+b");
if(ptr_file)
{
fseek(ptr_file, 0, SEEK_END);
int numberOfStudentsInFile = ftell(ptr_file) / sizeof(STUDENT);
fseek(ptr_file, 0, SEEK_SET);
STUDENT tempStudent;
tempStudent.StudentNumber = -1;
int studentRemoved = 0;
int i = 0;
for (; i < numberOfStudentsInFile; i++)
{
STUDENT foundStudent;
readElement(ptr_file, i, &foundStudent);
if(tempStudent.StudentNumber != -1)
{
readElement(ptr_file, i + 1, &tempStudent);
writeElement(ptr_file, i, &tempStudent);
}
else
{
if(StudentNumber == foundStudent.StudentNumber)
{
readElement(ptr_file, i + 1, &tempStudent);
writeElement(ptr_file, i, &tempStudent);
numberOfStudentsInFile--;
studentRemoved = 1;
}
}
}
if (studentRemoved)
{
return 0;
}
}
}
return -1;
}
hashmap* parseTextFormat(std::string text) {
hashmap* mapValue = new hashmap();
stringstream in(text);
while (in.good()) {
string element;
readElement(element, in);
if (element.length() > 0) {
string name = element.substr(0, element.find_first_of(":"));
string value = element.substr(element.find_first_of(":") + 1, element.length() - element.find_first_of(":"));
QString qValue = QString(value.c_str());
qValue = qValue.trimmed();
value = qValue.toStdString();
mapValue->insert(pair<string, string > (name, value));
}
}
return mapValue;
}
int findElementLinear(FILE* fptr, int Number, STUDENT* StudentPtr)
{
int index = 0;
STUDENT student;
while (readElement(fptr, index++, &student))
{
if (student.StudentNumber == Number)
{
if (StudentPtr != NULL)
{
memcpy(StudentPtr, &student, sizeof(STUDENT));
}
return 0;
}
}
return -1;
}
/* post : Returns student information of student with student number Number
* returns: -1 if Number is not available or in case of an error, 0 if Number is available
*/
extern int binarySearchStudentsFile (char* FileName, int Number, STUDENT* StudentPtr)
{
if(access(FileName, R_OK ) != -1 && Number)
{
FILE *ptr_file = fopen(*FileName, "rb");
if(ptr_file)
{
fseek(ptr_file, 0, SEEK_END);
int minIndex = 0;
int maxIndex = (ftell(ptr_file) / sizeof(STUDENT)) - 1;
fseek(ptr_file, 0, SEEK_SET);
int IndexesSearched = 0;
int maxSearchesNeeder = log2(maxIndex) + 1;
STUDENT student;
student.StudentNumber = -1;
int currentNumber = maxIndex/2;
while(true)
{
readElement(ptr_file, currentNumber, &student);
IndexesSearched++;
if(IndexesSearched > maxIndex)
{
return -1;
}
else if(student.StudentNumber == Number)
{
*StudentPtr = student;
return 0;
}
else if(student.StudentNumber > Number)
{
maxIndex = currentNumber;
currentNumber = minIndex + (maxIndex - minIndex / 2);
}
else if(student.StudentNumber < Number)
{
minIndex = currentNumber;
currentNumber = minIndex + (maxIndex - minIndex / 2);
}
}
}
}
return -1;
}
/**
* @brief Reads an array from `reader.
* @param reader The JSONReader.
* @return The array.
*/
static Array *readArray(JSONReader *reader) {
MutableArray *array = $(alloc(MutableArray), init);
while (true) {
Object *obj = readElement(reader);
if (obj == NULL) {
const int b = readByteUntil(reader, "]");
assert(b == ']');
break;
}
$(array, addObject, obj);
release(obj);
}
return (Array *) array;
}
/* post : Calculates the average of all study results in a file
* returns: -1 if an error occurs, 0 if a valid average is computed
*/
extern int computeAverageStudyResults (char* FileName, double* Average)
{
if(access(FileName, R_OK ) != -1 && Average)
{
FILE *ptr_file = fopen(*FileName, "rb");
if(ptr_file)
{
fseek(ptr_file, 0, SEEK_END);
int numberOfStudentsInFile = ftell(ptr_file) / sizeof(STUDENT);
*Average = 0; //* nodig anders veranderd de pointer toch?
int i = 0;
for (; i < numberOfStudentsInFile; i++)
{
STUDENT student;
readElement(ptr_file, i, &student);
*Average += student.StudyCredits; //* nodig anders veranderd de pointer toch?
}
*Average /= numberOfStudentsInFile; //* nodig anders kan je waar de pointer naar verwijst niet veranderen toch?
return 0;
}
}
return -1;
}
int IterateRead(const LLIterator iterator, void* data){
if(iterator->marker==NULL) return LLUNDERRUN;
return readElement(iterator->marker, data, iterator->list->elementSize);
}
int readFirstElement(const LinkedList list, void* data){
ListElement* toRead = list->begining;
if(readElement(toRead, data, list->elementSize)==LLFAIL) return LLUNDERRUN;
return LLSUCCESS;
}
int readLastElement(const LinkedList list, void* data){
ListElement* toRead = list->end;
if(readElement(toRead, data, list->elementSize)==LLFAIL) return LLOVERRUN;
return LLSUCCESS;
}
//readElementI() provides a copy of the data in ListElement i
//list : a pointer to the LinkedList to read the data from
//data : a pointer to memory allocated to accept the data from the list
// assumes that data is correctly sized based on list->elementSize
//i : the data will be read from the ith element of the list
//returns : a status code as defined in linklist.h
// if i>number of elements, data is not changed and returns LLUNDERRUN
int readElementI(const LinkedList list, void* data, int i){
ListElement* toRead = iterate(list,i);
if(readElement(toRead, data, list->elementSize)==LLFAIL) return LLOVERRUN;
return LLSUCCESS;
}
bool TestSerializationBuffer::testReadWrite()
{
bool pass = true;
std::queue< std::vector< char > > values;
hydrazine::SerializationBuffer buffer;
for( unsigned int i = 0; i < iterations; i++ )
{
unsigned int size = random() % maxSize;
std::vector< char > element( size );
for( std::vector< char >::iterator fi = element.begin();
fi != element.end(); fi++ )
{
*fi = random();
}
buffer.write( &element[0], size );
values.push( element );
while( ( ( random() & 0x1 ) > 0 ) && !values.empty() )
{
std::vector< char > readElement( values.front().size() );
buffer.read( &readElement[0], readElement.size() );
std::vector< char >::iterator vi = values.front().begin();
for( std::vector< char >::iterator fi = readElement.begin();
fi != readElement.end(); fi++ )
{
assert( vi != values.front().end() );
unsigned int val = *fi;
unsigned int ref = *vi;
if( val != ref )
{
status << "Read write test failed at iteration " << i
<< ", read value " << val
<< " did not match reference " << ref << ".\n";
pass = false;
}
++vi;
}
if( !pass )
{
break;
}
values.pop();
}
if( !pass )
{
break;
}
}
while( !values.empty() )
{
std::vector< char > readElement( values.front().size() );
buffer.read( &readElement[0], readElement.size() );
std::vector< char >::iterator vi = values.front().begin();
for( std::vector< char >::iterator fi = readElement.begin();
fi != readElement.end(); fi++ )
{
assert( vi != values.front().end() );
unsigned int val = *fi;
unsigned int ref = *vi;
if( val != ref )
{
status << "Read write test failed at end, read value "
<< val << " did not match reference " << ref << ".\n";
pass = false;
}
++vi;
}
if( !pass )
{
break;
}
values.pop();
}
return pass;
}
bool Account::readElements(QXmlStreamReader *xml, bool *valid) {
while(xml->readNextStartElement()) {
if(!readElement(xml, valid)) xml->skipCurrentElement();
}
return true;
}
bool PrologLoader :: LOAD (char * file_name) {
bool ret;
AREA command;
ri = NULL;
fi = NULL;
drop_instructions ();
if (root -> resource_loader != NULL) ri = root -> resource_loader -> load (file_name);
if (ri == NULL) {
fi = fopen (file_name, "rb");
PrologString * root_directory = root -> search_directories;
while (root_directory != NULL && fi == NULL) {
sprintf (command, "%s%s", root_directory -> text, file_name);
fi = fopen (command, "rb");
root_directory = root_directory -> next;
}
if (fi == NULL) {
ri = load_plugin_module (file_name);
if (ri == 0) {message_v ("File not found: ", file_name); return false;}
}
}
get_symbol ();
PrologDirectory * import;
clear_context ();
// if (root != NULL) search_context = root -> root;
PrologDirectory * user_directory = NULL;
if (root != NULL) user_directory = root -> root;
while (symbol_control == 11 && strcmp (root -> import_caption, symbol) == 0) {
get_symbol ();
switch (symbol_control) {
case 8: if (root -> searchDirectoryNotFound (symbol)) root -> addSearchDirectory (symbol); break;
case 11:
import = root -> searchDirectory (symbol);
if (import == NULL) {
PrologLoader * loader = new PrologLoader (root);
area_cat (command, 0, symbol);
area_cat (command, ".prc");
ret = loader -> load (command);
delete loader;
if (! ret) {message_v ("Module not loaded: ", command); close (); return false;}
import = root -> searchDirectory (symbol);
}
if (import != NULL) search_context = import -> duplicate (search_context);
break;
default: message ("Syntax error: import module or search path expected."); close (); return false;
}
get_symbol ();
}
while (symbol_control == 31) {
if (strcmp (symbol, "uap32") == 0) root -> set_uap32_captions ();
if (strcmp (symbol, "standard") == 0) root -> set_standard_captions ();
if (strcmp (symbol, "edinburg") == 0) root -> set_edinburg_captions ();
if (strcmp (symbol, "marseille") == 0) root -> set_marseille_captions ();
if (strcmp (symbol, "functional") == 0) root -> set_functional_captions ();
get_symbol ();
}
if (symbol_control != 11 || strcmp (root -> program_caption, symbol) != 0) {message ("Syntax error: program header expected."); close (); return false;}
get_symbol ();
if (symbol_control != 11) {message ("Syntax error: program name expected."); close (); return false;}
PROLOG_STRING program_name;
prolog_string_copy (program_name, symbol);
PrologServiceClass * service_class = NULL;
if (reload) root -> drop (program_name);
else if (root -> searchDirectory (program_name) != NULL) {close (); return true;}
get_symbol ();
PrologDirectory * directory;
if (symbol_control == 11 && strcmp (root -> machine_caption, symbol) == 0) {
get_symbol ();
if (symbol_control != 11 || strcmp (root -> if_atom_caption, symbol) != 0) {
message ("Syntax error: machine assignment expected in program header.");
close ();
return false;
}
get_symbol ();
if (symbol_control != 8) {message ("Syntax error: service class name expected."); close (); return false;}
service_class = root -> loadServiceClass (symbol);
if (service_class == NULL) {message_v ("Service class crashed or not found: ", symbol); close (); return false;}
get_symbol ();
directory = root -> createDirectory (program_name, service_class);
} else directory = root -> createDirectory (program_name);
root -> auto_atoms = false;
switch (symbol_control) {
case 11:
if (strcmp (root -> auto_atoms_caption, symbol) != 0) {
message ("Syntax error: auto expected.");
root -> drop ();
close ();
return false;
}
root -> auto_atoms = true;
get_symbol ();
break;
case 6: get_symbol (); break;
case 1:
get_symbol ();
while (symbol_control != 2) {
switch (symbol_control) {
case 11: root -> createAtom (symbol); break;
case 21: root -> createAtom (symbol); break;
default:
message ("Syntax error: atom expected.");
root -> drop ();
close ();
return false;
break;
}
get_symbol ();
if (strlen (root -> separator_caption) > 0) {
if (symbol_control != 23 && symbol_control != 2) {
message ("Syntax error: separator missing.");
root -> drop ();
close ();
return false;
}
if (symbol_control == 23) get_symbol ();
}
}
get_symbol ();
break;
default: message ("Syntax error: atome list expected."); root -> drop (); close (); return false;
}
//
if (service_class != 0) service_class -> init (root, directory);
if (directory != NULL) search_context = directory -> duplicate (search_context);
PrologDirectory * dt = search_context;
if (dt != NULL) {
while (dt -> next != NULL) dt = dt -> next;
dt -> next = user_directory;
}
// message (file_name);
// dt = search_context;
// while (dt != NULL) {message (dt -> directoryName); dt = dt -> next;}
// message ("===");
// dt = root -> root;
// while (dt != NULL) {message (dt -> directoryName); dt = dt -> next;}
// message ("");
//
PrologElement * clause = NULL;
PrologAtom * atom = NULL;
PrologNativeCode * native_code = NULL;
PrologResolution * resolution = NULL;
PrologAtom * preprocessor = NULL;
PrologDirectory * preprocessor_directory;
while (true) {
switch (symbol_control) {
case 11:
if (strcmp (root -> machine_caption, symbol) == 0) {
get_symbol ();
if (symbol_control != 11) {
message ("Syntax error: atom expected.");
root -> drop ();
close ();
return false;
}
atom = searchAtomC (symbol); //root -> search (symbol);
if (atom == NULL) {
message_v ("Unknown atom: ", symbol);
root -> drop ();
close ();
return false;
}
if (atom -> getMachine () != 0) {
message_v ("Atom has already machine code attached: ", symbol);
root -> drop ();
close ();
return false;
}
get_symbol ();
if (symbol_control != 11 || strcmp (root -> if_atom_caption, symbol) != 0) {
message ("Syntax error: machine assignment expected.");
root -> drop ();
close ();
return false;
}
get_symbol ();
if (symbol_control != 8) {
message ("Syntax error: machine name expected.");
root -> drop ();
close ();
return false;
}
if (service_class == NULL) {
message ("Service class missing.");
root -> drop ();
close ();
return false;
}
native_code = service_class -> getNativeCode (symbol);
if (native_code == NULL) {
message_v ("Unknown native class: ", symbol);
root -> drop ();
close ();
return false;
}
atom -> setMachine (native_code);
get_symbol ();
break;
}
// case 11:
if (strcmp (root -> end_caption, symbol) == 0) {
get_symbol ();
clause = NULL;
if (symbol_control == 11 && strcmp (root -> if_atom_caption, symbol) == 0) {
clause = readElement ();
if (clause == NULL) {
// suspiciouse drop 1
root -> drop ();
close ();
return false;
}
get_symbol ();
}
if (symbol_control == 21) {
if (echo) message ("");
root -> close ();
if (clause != 0) instructions = clause;
close ();
return true;
}
message ("Syntax error: dot expected.");
root -> drop ();
close ();
return false;
}
if (strcmp (root -> protect_caption, symbol) == 0) {
get_symbol ();
if (symbol_control == 6) {get_symbol (); break;}
if (symbol_control != 1) {
message ("Syntax error: atome list expected.");
root -> drop ();
close ();
return false;
}
get_symbol ();
while (symbol_control != 2) {
if (symbol_control != 11) {
message ("Syntax error: atom expected.");
root -> drop ();
close ();
return false;
}
if (! root -> Protect (symbol)) {
root -> message ("Can not protect unknown atom:", symbol);
root -> drop ();
close ();
return false;
}
get_symbol ();
if (strlen (root -> separator_caption) > 0) {
if (symbol_control != 23 && symbol_control != 2) {
message ("Syntax error: separator missing.");
root -> drop ();
close ();
return false;
}
if (symbol_control == 23) get_symbol ();
}
}
get_symbol ();
break;
}
if (strcmp (root -> private_caption, symbol) == 0) {
get_symbol ();
if (symbol_control == 6) {get_symbol (); break;}
if (symbol_control != 1) {
message ("Syntax error: atome list expected.");
root -> drop ();
close ();
return false;
}
get_symbol ();
while (symbol_control != 2) {
if (symbol_control != 11) {
message ("Syntax error: atom expected.");
root -> drop ();
close ();
return false;
}
if (! root -> Private (symbol)) {
root -> message ("Can not lock unknown atom as private:", symbol);
root -> drop ();
close ();
return false;
}
get_symbol ();
if (strlen (root -> separator_caption) > 0) {
if (symbol_control != 23 && symbol_control != 2) {
message ("Syntax error: separator missing.");
root -> drop ();
close ();
return false;
}
if (symbol_control == 23) get_symbol ();
}
}
get_symbol ();
break;
}
if (strcmp (root -> preprocessor_caption, symbol) == 0) {
get_symbol ();
if (symbol_control != 11 && strcmp (root -> if_atom_caption, symbol) != 0) {
message ("Syntax error: preprocessor assignment expected.");
root -> drop ();
close ();
return false;
}
get_symbol ();
if (symbol_control == 6) {
// directory -> setPreprocessor (NULL);
preprocessor = NULL;
get_symbol ();
break;
}
if (symbol_control != 11) {
if (symbol_control == 22) {
get_symbol ();
if (symbol_control != 11) {
message ("Syntax error: directory name expected in qualified preprocessor name.");
root -> drop ();
close ();
return false;
}
preprocessor_directory = root -> searchDirectory (symbol);
if (preprocessor_directory == NULL) {
message_v ("Directory not found in qualified preprocessor name:", symbol);
root -> drop ();
close ();
return false;
}
get_symbol ();
if (symbol_control != 21) {
message ("Syntax error: dot expected in qualified preprocessor name.");
root -> drop ();
close ();
return false;
}
get_symbol ();
if (symbol_control != 11) {
message ("Syntax error: qualified preprocessor name expected.");
root -> drop ();
close ();
return false;
}
atom = preprocessor_directory -> searchAtom (symbol);
} else {
message ("Syntax error: atom expected.");
root -> drop ();
close ();
return false;
}
} else {
atom = searchAtom (symbol); //root -> search (symbol);
}
if (atom == NULL) {
message_v ("Unknown atom: ", symbol);
root -> drop ();
close ();
return false;
}
// directory -> setPreprocessor (atom);
preprocessor = atom;
get_symbol ();
break;
}
if (strcmp (root -> auto_caption, symbol) == 0) {
get_symbol ();
if (symbol_control != 11 && strcmp (root -> if_atom_caption, symbol) != 0) {
message ("Syntax error: auto assignment expected.");
root -> drop ();
close ();
return false;
}
clause = readElement ();
// suspicious drop 2
if (clause == NULL) {root -> drop (); close (); return false;}
clause = root -> pair (root -> head (NULL), clause);
//root -> resolution (clause);
resolution = new PrologResolution (root);
resolution -> resolution (clause);
delete resolution;
delete clause;
get_symbol ();
break;
}
case 1:
// atom = root -> getPreprocessor ();
if (preprocessor != NULL) {
clause = readElement ();
if (clause == NULL) {root -> drop (); close (); return false;}
clause = readRightSide (clause, false);
if (clause == NULL) {root -> drop (); close (); return false;}
get_symbol ();
clause = root -> pair (root -> var (0), root -> pair (root -> pair (root -> atom (preprocessor), root -> pair (clause, root -> earth ())), root -> earth ()));
resolution = new PrologResolution (root);
resolution -> resolution (clause);
delete resolution;
delete clause;
break;
}
clause = readClause ();
get_symbol ();
// suspicious drop 3
if (clause == NULL) {root -> drop (); close (); return false;}
if (root -> attachClause (clause) == 0) break;
// suspicious drop 4
root -> drop ();
close ();
return false;
default: message ("Syntax error: at least clause expected."); root -> drop (); close (); return false;
}
}
}
void LLSDXMLParser::Impl::endElementHandler(const XML_Char* name)
{
#ifdef XML_PARSER_PERFORMANCE_TESTS
XML_Timer timer(&endElementTime);
#endif // XML_PARSER_PERFORMANCE_TESTS
--mDepth;
if (mSkipping)
{
if (mDepth < mSkipThrough)
{
mSkipping = false;
}
return;
}
Element element = readElement(name);
switch (element)
{
case ELEMENT_LLSD:
if (mInLLSDElement)
{
mInLLSDElement = false;
mGracefullStop = true;
XML_StopParser(mParser, false);
}
return;
case ELEMENT_KEY:
mCurrentKey = mCurrentContent;
return;
default:
// all rest are values, fall through
;
}
if (!mInLLSDElement) { return; }
LLSD& value = *mStack.back();
mStack.pop_back();
switch (element)
{
case ELEMENT_UNDEF:
value.clear();
break;
case ELEMENT_BOOL:
value = (mCurrentContent == "true" || mCurrentContent == "1");
break;
case ELEMENT_INTEGER:
{
S32 i;
if (sscanf(mCurrentContent.c_str(), "%d", &i) == 1)
{ // See if sscanf works - it's faster
value = i;
}
else
{
value = LLSD(mCurrentContent).asInteger();
}
break;
}
case ELEMENT_REAL:
{
// sscanf() is sensitive to the locale and will fail decoding
// the decimal point for locales where the decimal separator
// is a comma... So, better not using sscanf() for this purpose.
// See http://jira.secondlife.com/browse/EXP-700
#if 0
F64 r;
if (sscanf(mCurrentContent.c_str(), "%lf", &r) == 1)
{ // See if sscanf works - it's faster
value = r;
}
else
{
value = LLSD(mCurrentContent).asReal();
}
#else
value = LLSD(mCurrentContent).asReal();
#endif
break;
}
case ELEMENT_STRING:
value = mCurrentContent;
break;
case ELEMENT_UUID:
value = LLSD(mCurrentContent).asUUID();
break;
case ELEMENT_DATE:
value = LLSD(mCurrentContent).asDate();
break;
case ELEMENT_URI:
value = LLSD(mCurrentContent).asURI();
break;
case ELEMENT_BINARY:
{
// Regex is expensive, but only fix for whitespace in base64,
// created by python and other non-linden systems - DEV-39358
// Fortunately we have very little binary passing now,
// so performance impact shold be negligible. + poppy 2009-09-04
boost::regex r;
r.assign("\\s");
std::string stripped = boost::regex_replace(mCurrentContent, r, "");
S32 len = apr_base64_decode_len(stripped.c_str());
std::vector<U8> data;
data.resize(len);
len = apr_base64_decode_binary(&data[0], stripped.c_str());
data.resize(len);
value = data;
break;
}
case ELEMENT_UNKNOWN:
value.clear();
break;
default:
// other values, map and array, have already been set
break;
}
mCurrentContent.clear();
}
void LLSDXMLParser::Impl::endElementHandler(const XML_Char* name)
{
#ifdef XML_PARSER_PERFORMANCE_TESTS
XML_Timer timer( &endElementTime );
#endif // XML_PARSER_PERFORMANCE_TESTS
--mDepth;
if (mSkipping)
{
if (mDepth < mSkipThrough)
{
mSkipping = false;
}
return;
}
Element element = readElement(name);
switch (element)
{
case ELEMENT_LLSD:
if (mInLLSDElement)
{
mInLLSDElement = false;
mGracefullStop = true;
XML_StopParser(mParser, false);
}
return;
case ELEMENT_KEY:
mCurrentKey = mCurrentContent;
return;
default:
// all rest are values, fall through
;
}
if (!mInLLSDElement) { return; }
LLSD& value = *mStack.back();
mStack.pop_back();
switch (element)
{
case ELEMENT_UNDEF:
value.clear();
break;
case ELEMENT_BOOL:
value = (mCurrentContent == "true" || mCurrentContent == "1");
break;
case ELEMENT_INTEGER:
{
S32 i;
if ( sscanf(mCurrentContent.c_str(), "%d", &i ) == 1 )
{ // See if sscanf works - it's faster
value = i;
}
else
{
value = LLSD(mCurrentContent).asInteger();
}
}
break;
case ELEMENT_REAL:
{
F64 r;
if ( sscanf(mCurrentContent.c_str(), "%lf", &r ) == 1 )
{ // See if sscanf works - it's faster
value = r;
}
else
{
value = LLSD(mCurrentContent).asReal();
}
}
break;
case ELEMENT_STRING:
value = mCurrentContent;
break;
case ELEMENT_UUID:
value = LLSD(mCurrentContent).asUUID();
break;
case ELEMENT_DATE:
value = LLSD(mCurrentContent).asDate();
break;
case ELEMENT_URI:
value = LLSD(mCurrentContent).asURI();
break;
case ELEMENT_BINARY:
{
S32 len = apr_base64_decode_len(mCurrentContent.c_str());
std::vector<U8> data;
data.resize(len);
len = apr_base64_decode_binary(&data[0], mCurrentContent.c_str());
data.resize(len);
value = data;
break;
}
case ELEMENT_UNKNOWN:
value.clear();
break;
default:
// other values, map and array, have already been set
break;
}
mCurrentContent.clear();
}
void LLSDXMLParser::Impl::startElementHandler(const XML_Char* name, const XML_Char** attributes)
{
#ifdef XML_PARSER_PERFORMANCE_TESTS
XML_Timer timer( &startElementTime );
#endif // XML_PARSER_PERFORMANCE_TESTS
++mDepth;
if (mSkipping)
{
return;
}
Element element = readElement(name);
mCurrentContent.clear();
switch (element)
{
case ELEMENT_LLSD:
if (mInLLSDElement) { return startSkipping(); }
mInLLSDElement = true;
return;
case ELEMENT_KEY:
if (mStack.empty() || !(mStack.back()->isMap()))
{
return startSkipping();
}
return;
case ELEMENT_BINARY:
{
const XML_Char* encoding = findAttribute("encoding", attributes);
if(encoding && strcmp("base64", encoding) != 0) { return startSkipping(); }
break;
}
default:
// all rest are values, fall through
;
}
if (!mInLLSDElement) { return startSkipping(); }
if (mStack.empty())
{
mStack.push_back(&mResult);
}
else if (mStack.back()->isMap())
{
if (mCurrentKey.empty()) { return startSkipping(); }
LLSD& map = *mStack.back();
LLSD& newElement = map[mCurrentKey];
mStack.push_back(&newElement);
mCurrentKey.clear();
}
else if (mStack.back()->isArray())
{
LLSD& array = *mStack.back();
array.append(LLSD());
LLSD& newElement = array[array.size()-1];
mStack.push_back(&newElement);
}
else {
// improperly nested value in a non-structure
return startSkipping();
}
++mParseCount;
switch (element)
{
case ELEMENT_MAP:
*mStack.back() = LLSD::emptyMap();
break;
case ELEMENT_ARRAY:
*mStack.back() = LLSD::emptyArray();
break;
default:
// all the other values will be set in the end element handler
;
}
}
void LLSDXMLParser::Impl::endElementHandler(const XML_Char* name)
{
#ifdef XML_PARSER_PERFORMANCE_TESTS
XML_Timer timer( &endElementTime );
#endif // XML_PARSER_PERFORMANCE_TESTS
--mDepth;
if (mSkipping)
{
if (mDepth < mSkipThrough)
{
mSkipping = false;
}
return;
}
Element element = readElement(name);
switch (element)
{
case ELEMENT_LLSD:
if (mInLLSDElement)
{
mInLLSDElement = false;
mGracefullStop = true;
XML_StopParser(mParser, false);
}
return;
case ELEMENT_KEY:
mCurrentKey = mCurrentContent;
return;
default:
// all rest are values, fall through
;
}
if (!mInLLSDElement) { return; }
LLSD& value = *mStack.back();
mStack.pop_back();
switch (element)
{
case ELEMENT_UNDEF:
value.clear();
break;
case ELEMENT_BOOL:
value = (mCurrentContent == "true" || mCurrentContent == "1");
break;
case ELEMENT_INTEGER:
{
S32 i;
// sscanf okay here with different locales - ints don't change for different locale settings like floats do.
if ( sscanf(mCurrentContent.c_str(), "%d", &i ) == 1 )
{ // See if sscanf works - it's faster
value = i;
}
else
{
value = LLSD(mCurrentContent).asInteger();
}
}
break;
case ELEMENT_REAL:
{
value = LLSD(mCurrentContent).asReal();
// removed since this breaks when locale has decimal separator that isn't '.'
// investigated changing local to something compatible each time but deemed higher
// risk that just using LLSD.asReal() each time.
//F64 r;
//if ( sscanf(mCurrentContent.c_str(), "%lf", &r ) == 1 )
//{ // See if sscanf works - it's faster
// value = r;
//}
//else
//{
// value = LLSD(mCurrentContent).asReal();
//}
}
break;
case ELEMENT_STRING:
value = mCurrentContent;
break;
case ELEMENT_UUID:
value = LLSD(mCurrentContent).asUUID();
break;
case ELEMENT_DATE:
value = LLSD(mCurrentContent).asDate();
break;
case ELEMENT_URI:
value = LLSD(mCurrentContent).asURI();
break;
case ELEMENT_BINARY:
{
// Regex is expensive, but only fix for whitespace in base64,
// created by python and other non-linden systems - DEV-39358
// Fortunately we have very little binary passing now,
// so performance impact shold be negligible. + poppy 2009-09-04
boost::regex r;
r.assign("\\s");
std::string stripped = boost::regex_replace(mCurrentContent, r, "");
size_t len = LLBase64::requiredDecryptionSpace(stripped);
std::vector<U8> data;
data.resize(len);
len = LLBase64::decode(stripped, &data[0], len);
data.resize(len);
value = data;
break;
}
case ELEMENT_UNKNOWN:
value.clear();
break;
default:
// other values, map and array, have already been set
break;
}
mCurrentContent.clear();
}
int removeStudentFromFile(char* FileName, int StudentNumber)
/* pre :
* post : Removes student with StudentNumber from file
* returns: 0 if StudentNumber was removed from file
* -1 if StudentNumber was not found or an error occurs
*/
{
FILE* tmp = tmpfile();
if (tmp == NULL || FileName == NULL)
{
return -1;
}
FILE* fptr = fopen(FileName, "rb");
if (fptr == NULL)
{
fclose(tmp);
return -1;
}
int index = 0;
int written = 0;
STUDENT student;
bool found = false;
while (readElement(fptr, index++, &student))
{
if (student.StudentNumber != StudentNumber)
{
if (writeElement(tmp, written++, &student) != 0)
{
fclose(fptr);
fclose(tmp);
found = false;
return -1;
}
}
else
{
found = true;
}
}
if (found)
{
fclose(fptr);
remove(FileName);
fptr = fopen(FileName, "wb");
if (fptr == NULL)
{
fclose(tmp);
return -1;
}
fseek(tmp, 0, SEEK_SET);
//copy contents of tmp to FileName
int a;
bool comp;
do {
a = fgetc(tmp);
comp = a != EOF;
if (comp)
{
fputc(a, fptr);
}
} while (comp);
fclose(fptr);
fclose(tmp);
return 0;
}
return -1;
}
