std::list<std::string> tokenizeStringByOperators(const std::string &originalString) {
std::list<std::string> tokens;
std::string delimiter = "*/+-)(^";
size_t prev = 0;
size_t next = 0;
while ((next = originalString.find_first_of(delimiter, prev)) != std::string::npos) {
if (next - prev != 0) {
// trim and push back number
std::string number = originalString.substr(prev, next - prev);
leftTrim(number);
rightTrim(number);
if (number != " ") {
tokens.push_back(number);
}
// trim and push back operator
std::string oper = originalString.substr(next, 1);
leftTrim(oper);
rightTrim(oper);
if (oper != " ") {
tokens.push_back(oper);
}
// increment by operator length
prev = next + 1;
} else {
// leading operator
if (originalString.substr(next, 1) == "-") {
// if leading op is "-" we need to check if we need to parse a negative number
// check if this is the first token in stream, or the previous token is not a number
if (tokens.size() == 0 || !isANumber(tokens.back())) {
next = originalString.find_first_of(delimiter, prev + 1);
std::string negativeNumber = originalString.substr(prev, next - prev);
// trim and push back negative number
leftTrim(negativeNumber);
rightTrim(negativeNumber);
if (negativeNumber != " ") {
tokens.push_back(negativeNumber);
}
// increment by operator length
prev = next;
}
} else {
// parse the operator
tokens.push_back(originalString.substr(next, 1));
// increment by operator length
prev = next + 1;
}
}
}
if (prev < originalString.size()) {
// trim and push back last token
std::string last = originalString.substr(prev);
leftTrim(last);
rightTrim(last);
tokens.push_back(last);
}
return tokens;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::string> RifEclipseUserDataParserTools::headerReader(std::stringstream& streamData, std::string& line)
{
std::vector<std::string> header;
while (!isANumber(line) && !streamData.eof())
{
header.push_back(line);
std::getline(streamData, line);
}
return header;
}
bool isPositionFormatCorrect(const vector<string>& tokens) {
//verify correct format for <PIECE_CHAR> <X> <Y>
if (tokens.size() == 3) {
if (tokens[0].size() == 1) {
if (tokens[0].at(0) == 'R' || tokens[0].at(0) == 'P' || tokens[0].at(0) == 'S' || tokens[0].at(0) == 'B' || tokens[0].at(0) == 'F') {
if (isANumber(tokens[1])) {
if (stoi(tokens[1]) > 0 && stoi(tokens[1]) < NUM_OF_ROWS + 1) {
if (isANumber(tokens[2])) {
if (stoi(tokens[2]) > 0 && stoi(tokens[2]) < NUM_OF_COLS + 1)
return true;
}
}
}
}
}
}
//verify correct format for J <X> <Y> <PIECE_CHAR>
if (tokens.size() == 4) {
if (tokens[0].size() == 1) {
if (tokens[0].at(0) == 'J') {
if (tokens[3].size() == 1) {
if (tokens[3].at(0) == 'R' || tokens[3].at(0) == 'P' || tokens[3].at(0) == 'S' || tokens[3].at(0) == 'B') {
if (isANumber(tokens[1])) {
if (stoi(tokens[1]) > 0 && stoi(tokens[1]) < NUM_OF_ROWS + 1) {
if (isANumber(tokens[2])) {
if (stoi(tokens[2]) > 0 && stoi(tokens[2]) < NUM_OF_COLS + 1)
return true;
}
}
}
}
}
}
}
}
return false;
}
bool isMoveFormatCorrect(const vector<string>& tokens) {
//verify correct format for <FROM_X> <FROM_Y> <TO_X> <TO_Y> J: <Joker_X> <Joker_Y> <NEW_REP>
if (tokens.size() == 4 || tokens.size() == 8) {
for (vector<string>::size_type i = 0; i < tokens.size(); ++i) {
if (i == 4) {
if (tokens[i].size() != 2)
return false;
if (tokens[i].at(0) != 'J' || tokens[i].at(1) != ':')
return false;
}
else if (i == 0 || i == 2 || i == 5) {//verify rows within range
if (!isANumber(tokens[i]))
return false;
if (stoi(tokens[i]) < 1 || stoi(tokens[i]) > NUM_OF_ROWS) {
return false;
}
}
else if (i == 1 || i == 3 || i == 6) {
if (!isANumber(tokens[i]))
return false;
if (stoi(tokens[i]) < 1 || stoi(tokens[i]) > NUM_OF_COLS) {
return false;
}
}
else {//i = 7
if (tokens[i].size() != 1)
return false;
if (tokens[i].at(0) != 'R' && tokens[i].at(0) != 'P' && tokens[i].at(0) != 'S' && tokens[i].at(0) != 'B') {
return false;
}
}
}
}
return true;
}
int executeNice(Cmd c){
int priority;
int i =0;
int execReturn=0;
if(strcmp(c->args[0],"nice")==0 && c->nargs > 1 && isANumber(c->args[1])){
if( c->nargs == 2){
//nice #num
setpriority(PRIO_PROCESS,getpid(),atoi(c->args[1]));
return 0;
}
//printf("%s to int\n",c->args[1]);
priority= atoi(c->args[1]);
shiftArrayByN(2, c);
//printf("setting priority %d\n",priority);
// prCmd(c);
nice(priority);
errno=0;
if(executeIfBuildInSameShellCommand(c) == 0){
//printf("same shell\n");
closeIO(c);
return 0;
}
execReturn = execvp(c->args[0],c->args);
handleError();
}else if(strcmp(c->args[0],"nice")==0 && c->nargs > 1){
//printf("%s to int\n",c->args[1]);
priority= 4;
shiftArrayByN(1, c);
//printf("setting priority %d\n",priority);
//prCmd(c);
//nice(priority);
setpriority(PRIO_PROCESS,getpid(),priority);
errno=0;
if(executeIfBuildInSameShellCommand(c) == 0){
//printf("same shell\n");
closeIO(c);
return 0;
}
execReturn = execvp(c->args[0],c->args);
handleError();
}
if(strcmp(c->args[0],"nice")==0 && c->nargs == 1){
//nice(4);
setpriority(PRIO_PROCESS,getpid(),4);
return 0;
}
}
void spellCheckDocument(Documents* docs, int fNum)
{
char* filename = docs->files[fNum];
Tree* dico = docs->dico;
FILE* doc = fopen(filename,"r");
char word[1024];
char** words = NULL;
int count = 0;
while (!feof(doc)) {
fscanf(doc,"%s ",word);
cleanupWord(word);
if (*word==0 || isANumber(word)) continue;
pthread_rwlock_rdlock(&docs->rwlock);
bool found = lookupInTree(dico,word);
pthread_rwlock_unlock(&docs->rwlock);
if (!found) {
printf("Word [%s] spelled incorrectly.\n",word);
}
if (!found && !(fNum % docs->j)) {
words = realloc(words, sizeof(char*) * (count+1));
words[count++] = strdup(word);
}
}
int i;
pthread_rwlock_wrlock(&docs->rwlock);
for(i = 0; i < count; i++){
bool found = lookupInTree(docs->dico, words[i]);
if(!found){
addStringToTree(docs->dico, words[i]);
printf("%s is misspelled in %s\n", words[i], filename);
}
free(words[i]);
}
pthread_rwlock_unlock(&docs->rwlock);
free(words);
fclose(doc);
}
// shunting yard algorithm
double evaluate(std::list<std::string> &tokens) {
std::stack<double> operands;
std::stack<std::string> operators;
while (!tokens.empty()) {
if (!isANumber(tokens.front())) {
// token is an operator
std::string poppedOperator = tokens.front();
tokens.pop_front();
if (operators.empty()) {
// empty operator stack, just push it on
operators.push(poppedOperator);
} else if (poppedOperator == "(") {
// left paren, just push it on
operators.push(poppedOperator);
} else if (poppedOperator == ")") {
// right paren, pop off and apply all operators until we find the left paren
while (operators.top() != "(") {
double operandTwo = operands.top();
operands.pop();
double operandOne = operands.top();
operands.pop();
std::string operatorToApply = operators.top();
operators.pop();
double newOperand = applyOperatorToOperands(operandOne, operandTwo, operatorToApply);
operands.push(newOperand);
}
// found the left paren, pop it off
if (!operators.empty()) {
operators.pop();
}
// check for unary operator -
if (!operators.empty()) {
if (operators.top() == "-" && operands.size() == 1) {
// apply unary operator -
double operand = operands.top();
operands.pop();
operators.pop();
operands.push(operand * -1);
}
}
} else if (tokens.front() == "(") {
// corner case, singly parened number
operators.push(poppedOperator);
} else {
// check for operator precedence
while (topOfStackHasHigherOrEqualPrecedenceThanOperator(poppedOperator, operators)) {
double operandTwo = operands.top();
operands.pop();
double operandOne = operands.top();
operands.pop();
std::string operatorToApply = operators.top();
operators.pop();
double newOperand = applyOperatorToOperands(operandOne, operandTwo, operatorToApply);
operands.push(newOperand);
}
// precedence cleared, push operator
operators.push(poppedOperator);
}
} else {
// token is a number, push to operand stack
operands.push(toDouble(tokens.front()));
tokens.pop_front();
}
}
// end of token list, apply all remaining operators
while (!operators.empty()) {
double operandTwo = operands.top();
operands.pop();
double operandOne = operands.top();
operands.pop();
std::cout << operandOne << " " << operandTwo << " " << operators.top() << std::endl;
std::string operatorToApply = operators.top();
operators.pop();
double newOperand = applyOperatorToOperands(operandOne, operandTwo, operatorToApply);
operands.push(newOperand);
}
return operands.top();
}
/*
* Bekommt ein Kommando als String und bearbeitet diesen
* Der String 'antwort' wird returned.
*/
char* doThis(char* cmd) {
/* Erkennung der gewuenschten Methode */
/* Ausgabe des besten Studenten (entweder allgemein oder einer Fachrichtung */
if (!strcasecmp(cmd, "ping")) { //Testmethode, um Kommunikation Client<->Server zu testen
return "pong";
}
/*
* ********************* Funktion Best ********************************
* Rechte: 0, Antwrotet mit besten Studenten
*/
if (!strncasecmp(cmd, "best", 4)) {
if (!strcasecmp(cmd, "best()")) { //der beste alle Studenten
if (bestGlobal(&stud) != -1) { //speichert den besten Studenten auf stud und prueft gleichzeitig den Fehlerfall
char cache[] =
"Bester Student ist %s %s mit Notendurchschnitt: %.2lf";
sprintf(antwort, cache, stud.fname, stud.lname, stud.avg);
printf("%s", antwort);
return antwort;
} else {
return "Lesefehler";
}
}
if (!strcasecmp(cmd, "best(itti)")) { //der beste itti Student
if (bestPartial("itti", &stud) != -1) {
char cache[] =
"Bester ITTI.-Student ist %s %s mit Notendurchschnitt: %.2lf";
sprintf(antwort, cache, stud.fname, stud.lname, stud.avg);
printf("%s", antwort);
return antwort;
} else {
return "Lesefehler";
}
}
if (!strcasecmp(cmd, "best(info)")) { //der beste info Student
if (bestPartial("info", &stud) != -1) {
char cache[] =
"Bester INF.-Student ist %s %s mit Notendurchschnitt: %.2lf";
sprintf(antwort, cache, stud.fname, stud.lname, stud.avg);
printf("%s", antwort);
return antwort;
} else {
return "Lesefehler";
}
}
if (!strcasecmp(cmd, "best(mathe)")) { //der beste mathe Student
if (bestPartial("mathe", &stud) != -1) {
char cache[] =
"Bester Math.-Student ist %s %s mit Notendurchschnitt: %.2lf";
sprintf(antwort, cache, stud.fname, stud.lname, stud.avg);
printf("%s", antwort);
return antwort;
} else {
return "Lesefehler";
}
}
return "Dieser Studiengang ist nicht bekannt.";
}
/*
* *********************** Funktion CREATE ************************
* Nur Admin : 111, Fuegt einen Eintrag der DB hinzu
*/
if (!strncasecmp(cmd, "create(", 7)) {
if (getStatus() != 111) { //prueft, ob Admin eingeloggt ist
return "create() ist nur Admins erlaubt.";
}
char vorname[64];
char nachname[64];
char matrikel_string[10];
long matrikel;
char bday[9];
double noten[MAXLVs] = { 0 };
char fach[32];
int i = 6;
// Vorname parsen
int versatz = ++i;
while (cmd[i] != ',') {
if (!isALetter(cmd[i])) {
return "Namen bestehen nur aus Buchstaben.";
}
vorname[i - versatz] = cmd[i];
i++;
if (i > 50) {
return "1. Parameter zu lang!";
}
}
vorname[i - versatz] = '\0';
// Nachname parsen
versatz = ++i;
while (cmd[i] != ',') {
if (!isALetter(cmd[i])) {
return "Namen bestehen nur aus Buchstaben.";
}
nachname[i - versatz] = cmd[i];
i++;
if (i > 100) {
return "2. Parameter zu lang!";
}
}
nachname[i - versatz] = '\0';
// Matrikel parsen
versatz = ++i;
while (cmd[i] != ',') {
matrikel_string[i - versatz] = cmd[i];
if ((i - versatz > 8) && (cmd[i + 1] != ',')) {
return "Matrikel hat 9 Stellen (1)";
}
if ((i - versatz < 8) && (cmd[i + 1] == ',')) {
return "Matrikel hat 9 Stellen (2)";
}
if (!isANumber(cmd[i])) {
return "Matrikelnummer besteht nur aus Zahlen.";
}
i++;
}
//matrikel_string[i - versatz] = '\0';
matrikel = atoi(matrikel_string);
if (matrikel < 100000000)
return "Matrikel darf keine fuehrenden Nullen haben.";
// Geburtstag parsen
versatz = ++i;
while (cmd[i] != ',') {
bday[i - versatz] = cmd[i];
i++;
}
if (i - versatz != 8) {
return "Geburtstagsangaben haben insgesamt 8 Stellen.";
}
int j;
for (j = 0; j < 8; j++) { //ueberprueft richtigen Aufbau des Geburtsdatums
if (j == 2 || j == 5) {
if (bday[j] != '.') {
return "Geburtsdaten haben das Format DD.MM.YY\n";
}
} else {
if (!isANumber(bday[j])) {
return "Geburtsdaten haben das Format DD.MM.YY\n";
}
}
}
char* p;
int day, month;
day = strtol(bday, &p, 10);
month = strtol((p + 1), NULL, 10);
if (day > 31 || month > 12) {
return "Kein g�ltiges Geburtsdatum";
}
bday[i - versatz] = '\0';
//long geburtstag = atoi(btag);//Geburtstag ist immer ohne f�hrende Nullen!
versatz = ++i;
if (cmd[i] != '[') {
return "Noten nur in Form von [1.3,2.7,3.0,4.0] angeben (max. 10)";
}
// Noten parsen
versatz = ++i;
char tempnote[4]; // Noten haben immer 3 zeichen
int x = 0; // Anzahl der Noten
while (cmd[i] != ']') { // Bis zum Ende der Noten also ] - Noten
if ((!isANumber(cmd[i])) || (!isANumber(cmd[i + 2]))) {
return "Noten sind immer mit Vorkomma.Nachkomma anzugeben zB \"1.0\".";
}
if (i > 200)
return "Notenliste nicht korrekt!";
char cache[] = "%c.%c";
sprintf(tempnote, cache, cmd[i], cmd[i + 2]);
double checknote = atof(tempnote);
if ((checknote < 1.0) || (checknote > 5.0))
return "Noten muessen zwischen 1.0 und 5.0 liegen.";
noten[x] = checknote;
x++;
i = i + 4; //Sprung zu n�chsten Note
if (cmd[i - 1] == ']') { // Notenliste is zuende
break;
}
}
//Studienfach parsen
versatz = ++i;
while (cmd[i] != ')' && cmd[i] != ' ') {
fach[i - versatz] = cmd[i];
i++;
}
fach[i - versatz] = '\0';
if ((strcmp(fach, "itti")) && (strcmp(fach, "info"))
&& (strcmp(fach, "mathe"))) {
return "Nur \"itti\",\"info\" oder \"mathe\" als Studiengaeng maeglich.";
}
// Doppelte Eintraege verhindern.
if ((getStudent(matrikel, &stud))) {
return "Dieser Eintrag existiert schon in der Datenbank";
}
/*
* printf("Datensatz: Vorname: %s, Nachname: %s, Matrikel: %li mit %i Noten in Datenbank %s\n",
* vorname, nachname, matrikel, x, fach);
*/
// DB Operation aufrufen
if (create(vorname, nachname, matrikel, bday, noten, fach) < 0) {
return "Fehler beim eintragen in die Datenbank.";
}
return "Datensatz wurde erfolgreich in die Datenbank eingetragen.";
}
/*
* *********************** Funktion DELETE ************************
* Rechte: 111, entfernt einen Eintrag aus der DB
*/
if (!strncmp(cmd, "delete(", 7)) {
if (getStatus() != 111) {
return "delete() ist nur Admins erlaubt.";
}
// Matrikel parsen
int i = 0;
char matrikel_string[9];
while (cmd[i + 7] != ')') {
if (!isANumber(cmd[i + 7])) {
return "Matrikelnummer besteht nur aus Zahlen.";
}
matrikel_string[i] = cmd[i + 7];
if ((i > 8) && (cmd[i + 7 + 1] != ')')) {
return "Matrikel hat 9 Stellen (zu kurz)";
}
if ((i < 8) && (cmd[i + 7 + 1] == ')')) {
return "Matrikel hat 9 Stellen (zu lang)";
}
i++;
}
long matrikel = atol(matrikel_string);
// DB Operation aufrufen
if (delete(matrikel) > 0) {
return "Eintrag wurde erfolgreich aus der DB entfernt.";
}
return "Eintrag konnte nicht aus der DB entfernt werden.";
}
/*
* **************************** Funktion READ ***********************
* Funktioniert wie delete!
*/
if (!strncmp(cmd, "read(", 5)) {
/*
* Studenten duerfen nur sich selbst lesen, Admins durfen alles lesen
* Aktueller Student : getUser(), vor der Rueckgabe vergleich.
*/
char user_matrikel[32];
if (getStatus() != 111) {
getIdentity(user_matrikel);
if (!strcmp(user_matrikel, "000000000")) {
return "read() ist nur Admins und Studenten erlaubt";
}
}
int i = 0;
char matrikel_string[9];
while (cmd[i + 5] != ')') {
if (!isANumber(cmd[i + 5])) {
return "Matrikelnummer besteht nur aus Zahlen.";
}
matrikel_string[i] = cmd[i + 5];
if ((i > 8) && (cmd[i + 5 + 1] != ')')) {
return "Matrikel hat max. 9 Stellen";
}
if ((i < 8) && (cmd[i + 5 + 1] == ')')) {
return "Matrikel besteht aus 9 Stellen";
}
i++;
}
long matrikel = atol(matrikel_string);
/*
Wenn nicht Admin:
Usermatrikel und Studentenmatrikel pruefen
*/
if (getStatus() != 111) {
getIdentity(user_matrikel);
long user_matrikel_long = atol(user_matrikel);
if (user_matrikel_long != matrikel) {
return "Studenten ist der Zugriff nur auf ihre eigenen Daten gestattet.";
}
}
if (getStudent(matrikel, &stud) == 1) {
sprintf(antwort,
"\nName: %s %s\nStudienfach: %s\nGeburtsdatum: %s\nDurchschnitt: %.2f\n",
stud.fname, stud.lname, stud.fach, stud.bdate, stud.avg);
char notenout[64] = "Noten:";
int i;
for (i = 0; i < MAXLVs; i++) {
if (stud.marks[i] >= 1) {
char singlenote[5];
sprintf(singlenote, " %.1lf", stud.marks[i]);
strcat(notenout, singlenote);
}
}
strcat(antwort, notenout);
strcat(antwort, "\n");
return antwort;
}
return "Student nicht gefunden";
}
/*
* ************************** Funktion UPDATE ***********************
* Rechte 111, Veraendert die Daten eines Eintrags
*/
if (!strncasecmp(cmd, "update(", 7)) {
// Rechtekontrolle
if (getStatus() != 111) {
return "update() ist nur Admins gestattet.";
}
//Matrikel Parsen
int i = 0;
char matrikel_string[9];
while (cmd[i + 7] != ',') {
if (!isANumber(cmd[i + 7])) {
return "Matrikelnummer besteht nur aus Zahlen.";
}
matrikel_string[i] = cmd[i + 7];
if ((i > 8) && (cmd[i + 7 + 1] != ',')) {
return "Matrikel hat max. 9 Stellen";
}
if ((i < 8) && (cmd[i + 7 + 1] == ',')) {
return "Matrikel besteht aus 9 Stellen";
}
if (isALetter(cmd[i + 7])) {
return "MAtrikel muss aus Nummern bestehen";
}
i++;
}
long matrikel = atol(matrikel_string);
i++;
//Attribut parsen
char attribut[32];
int versatz = i;
while (cmd[i + 7] != ':') {
attribut[i - versatz] = cmd[i + 7];
i++;
}
attribut[i - versatz] = '\0';
i++;
// Attribut pr�fen
if (strcasecmp(attribut, "vorname") && strcasecmp(attribut, "nachname")
&& strcasecmp(attribut, "noten")
&& strcasecmp(attribut, "datum")) {
return "Gueltige Attribute sind: \n"
"- Vorname\n"
"- Nachname\n"
"- Noten\n"
"- Datum\n";
}
char value[32];
versatz = i;
while (cmd[i + 7] != ')') {
if ((!strcasecmp(attribut, "vorname"))
|| (!strcasecmp(attribut, "nachname"))) { //Wenn Vorname oder Nachname: Ueberpruefen ob nur Buchstaben
if (!isALetter(cmd[i + 7])) {
return "Namen bestehen nur aus Buchstaben";
}
}
value[i - versatz] = cmd[i + 7];
i++;
}
if (!strcasecmp(attribut, "datum")) { //Wenn Geburtstag, Ueberpruefen auf gueltiges Datum
char* p;
int day, month;
day = strtol(value, &p, 10);
month = strtol((p + 1), NULL, 10);
if ((day > 31) || (month > 12)) {
return "Kein gueltiges Geburtsdatum";
}
}
value[i - versatz] = '\0';
// DB Operation aufrufen
if (update(matrikel, attribut, value) > 0) {
return "Eintrag erfolgreich modifiziert";
}
return "Eintrag konnte nicht modifiziert werden.";
}
/*
* ************************* Funktion RECHTE *************************
* rechte: 0, Gibt die Aktuellen Rechte aus
*/
if (!strcasecmp(cmd, "rechte")) {
char cache[] = "Deine Rechte: %i";
sprintf(antwort, cache, getStatus());
return antwort;
}
/*
* ************************* Funktion LOGIN ***************************
* rechte: 0, ermoeglicht seine Rechte zu erhoehen
*/
if (!strncmp(cmd, "login(", 6)) {
if (getStatus() > 0) {
return "Mehrfachanmeldung nicht moeglich.";
}
// USername parsen
int i = 6;
char givenName[32];
char givenPwd[32];
int versatz = 6;
while (cmd[i] != ',') {
givenName[i - versatz] = cmd[i];
i++;
if (i > 30) {
return "Fehler in der Namensangabe!";
}
}
givenName[i - versatz] = '\0';
i++;
// Passwort parsen
versatz = i;
while (cmd[i] != ')') {
givenPwd[i - versatz] = cmd[i];
i++;
if (i > 60) {
return "Fehler in der Passwortangabe!";
}
}
givenPwd[i - versatz] = '\0';
// DB Operation aufrufen
int value = login(givenName, givenPwd);
switch (value) {
case 0: {
char cache[] = "Erfolgreich angemeldet als user: %s";
sprintf(antwort, cache, givenName);
return antwort;
}
case 1:
return "Falsches Passwort!";
case -1:
return "Kein Benutzerprofil gefunden.";
}
}
/*
* ******************** Funktion LOGOUT ***********************
* rechte 0, Ermoeglicht ein sicheres Logout
*/
if (!strcasecmp(cmd, "logout")) {
if (getStatus() == 0) {
return "Keine abmeldung erforderlich.";
}
logout();
return "Erfolgreich abgemeldet.";
}
return "Operation nicht bekannt. Probiere \"help\"";
}
