void parseTwitch(char* content) {
if (!strcmp("null", content)) {
printf("Nobody is streaming");
return;
}
int r;
int i;
jsmn_parser p;
jsmntok_t token[20]; /* We expect no more than 20 tokens */
jsmn_init(&p);
r = jsmn_parse(&p, content, strlen(content), token, sizeof(token) / sizeof(token[0]));
if (r <= 0) {
printf("Failed to parse JSON: %d \n", r);
return;
} else {
printf("Aantal tokens found: %d \n", r);
}
char name[20];
char title[20];
char game[20];
char date[15];
memset(name, 0, 20);
memset(title, 0, 20);
memset(game, 0, 20);
memset(date, 0, 15);
for (i = 1; i < r; i++) {
if (jsoneq(content, &token[i], "Name") == 0) {
getStringToken(content, &token[i + 1], name, 20);
i++;
}
else if (jsoneq(content, &token[i], "Title") == 0) {
getStringToken(content, &token[i + 1], title, 20);
i++;
}
else if (jsoneq(content, &token[i], "Game") == 0) {
getStringToken(content, &token[i + 1], game, 20);
i++;
}
else if (jsoneq(content, &token[i], "Date") == 0) {
getStringToken(content, &token[i + 1], date, 15);
i++;
}
}
printf("%s", date);
if(strncmp(date, streamid, 15) != 0)
{
strcpy(data.title, title);
strcpy(data.game, game);
strcpy(data.name, name);
printf("%s - %s - %s", name, title, game);
strcpy(streamid, date);
setCurrentDisplay(DISPLAY_Twitch, 100);
}
}
tokenInfo getStringToken(FILE *fp, buffer B, int i)
{
// Find the string text.
if(i == 0)
{
char *err = "Token size passed to getStringToken() is zero.";
showError(err, B->lineNumber);
return NULL;
}
tokenInfo stringToken = malloc(sizeof(tokenStruct));
char* alphabet = (char*)malloc(i*sizeof(char));
// Check if the buffer has enough space. Else change the buffer.
if(B->fwdPointer >= BUFFERSIZE)
{
// Change buffers.
getStream(fp, B->nextBuffer, BUFFERSIZE);
// Set current buffer to next buffer
if(B->nextBuffer == NULL)
{
return NULL;
}
B = B->nextBuffer;
// Return next token from the next buffer.
return getStringToken(fp, B, i);
}
alphabet[0] = B->buff[B->fwdPointer];
if((alphabet[0] < 'a' || alphabet[0] > 'z') && alphabet[0] != ' ')
{
// Not an alphabet. End here.
free(stringToken);
//free(alphabet);
return NULL;
}
else
{
// It is an alphabet(or a space). Keep going on.
++B->fwdPointer;
tokenInfo nextToken = getStringToken(fp, B, --i);
if(nextToken == NULL)
{
stringToken->token_value = alphabet;
free(nextToken);
//free(alphabet);
return stringToken;
}
else
{
stringToken->token_value = joinStrings(alphabet,nextToken->token_value);
//printf("%s",stringToken->token_value);
//printf("%c",alphabet[0]);
free(nextToken);
//free(alphabet);
return stringToken;
}
}
}
void MapLoader::ParseGlobalBlock() {
while (currentToken != endIter) {
if (currentToken->first == MapTokenMesh) {
StepToken();
std::string meshName = getStringToken("global.mesh: expecting string value for name", false, true);
StepOverLF();
if (currentToken->first != MapTokenBlockStart)
throw TGen::RuntimeException("MapLoader::ParseGlobalBlock", "mesh: expecting block start, not '" + currentToken->second + "'!");
StepToken();
Mesh * newMesh = new Mesh(meshName);
std::cout << "entering mesh " << meshName << "..." << std::endl;
ParseMeshBlock(newMesh);
std::cout << "leaving mesh" << std::endl;
}
else if (currentToken->first != MapTokenEndOfLine) {
throw TGen::RuntimeException("MapLoader::ParseGlobalBlock", "not expecting '" + currentToken->second + "'!");
}
StepToken();
}
}
api_return TransferApi::handleForce(ApiRequest& aRequest) {
auto item = getTransfer(aRequest);
if (item->isDownload()) {
ConnectionManager::getInstance()->force(item->getStringToken());
}
return websocketpp::http::status_code::ok;
}
void parseCommandQue(char* content){
int r;
int i;
jsmn_parser p;
jsmntok_t token[150]; /* We expect no more than 128 tokens */
jsmn_init(&p);
r = jsmn_parse(&p, content, strlen(content), token, sizeof(token)/sizeof(token[0]));
if (r <= 0) {
printf("Failed to parse JSON: %d \n", r);
return;
}else{
printf("Aantal tokens found: %d \n", r);
}
for(i = 0; i < r; i++)
{
if (jsoneq(content, &token[i], "command") == 0) {
if(jsoneq(content, &token[i + 1], "volume") == 0){
char vol = getIntegerToken(content, &token[i + 3]);
printf("Updating volume: \n");
setVolumeManual(vol);
//vol = 128 - ((vol * 128) / 100);
//VsSetVolume(vol, vol);
i += 3;
}else if(jsoneq(content, &token[i + 1], "stopstream") == 0){
killPlayerThread();
i += 3;
}else if(jsoneq(content, &token[i + 1], "startstream") == 0){
u_short port = getIntegerToken(content, &token[i + 9]);
char url[24];
char ip[24];
getStringToken(content, &token[i + 7], url, 24);
getStringToken(content, &token[i + 5], ip, 24);
bool success = connectToStream(ip, port, url);
if (success == true){
play();
}else {
printf("ConnectToStream failed. Aborting.\n\n");
}
i += 9;
}
}
}
}
void MapLoader::ParseMeshBlock(Mesh * mesh) {
while (currentToken != endIter && currentToken->first != MapTokenBlockEnd) {
if (currentToken->first == MapTokenVertices) {
TGen::VertexStructure vertexStructure;
StepToken();
while (currentToken->first != MapTokenEndOfLine && currentToken->first != MapTokenBlockStart) {
std::string format = getStringToken("mesh.vertices: expecting string value for format", false, false);
StepToken();
vertexStructure.AddElement(format);
}
while (currentToken->first == MapTokenEndOfLine) {
StepToken();
}
if (currentToken->first != MapTokenBlockStart)
throw TGen::RuntimeException("MapLoader::ParseMeshBlock", "mesh.vertices: expecting block start, not '" + currentToken->second + "'!");
StepToken();
MeshData * meshData = new MeshData(vertexStructure);
StepToken();
std::cout << "entering vertices..." << std::endl;
ParseVertices(meshData);
std::cout << "leaving vertices" << std::endl;
}
else if (currentToken->first == MapTokenIndices) {
}
else if (currentToken->second == "primitive") {
StepToken();
std::string primitiveType = getStringToken("mesh.primitive: expecting string value for type", false, false);
}
else if (currentToken->first != MapTokenEndOfLine) {
throw TGen::RuntimeException("MapLoader::ParseMeshBlock", "not expecting '" + currentToken->second + "'!");
}
StepToken();
}
}
/* Read and return the next token from the stream. If the token is of
type eString, fill in the token parameter with the token. If the
token is eError, then the status parameter will contain the
specific error. This will be eItemNotFound at the end of file,
indicating that all tokens have been returned. This method will
never return eString twice in a row; instead, multiple adjacent
string tokens will be merged into one, with no intervening
space. */
U_CFUNC enum ETokenType
getNextToken(UCHARBUF* buf,
struct UString *token,
uint32_t *linenumber, /* out: linenumber of token */
struct UString *comment,
UErrorCode *status) {
enum ETokenType result;
UChar32 c;
if (U_FAILURE(*status)) {
return TOK_ERROR;
}
/* Skip whitespace */
c = getNextChar(buf, TRUE, comment, status);
if (U_FAILURE(*status)) {
return TOK_ERROR;
}
*linenumber = lineCount;
switch(c) {
case BADBOM:
return TOK_ERROR;
case OPENBRACE:
return TOK_OPEN_BRACE;
case CLOSEBRACE:
return TOK_CLOSE_BRACE;
case COMMA:
return TOK_COMMA;
case U_EOF:
return TOK_EOF;
case COLON:
return TOK_COLON;
default:
result = getStringToken(buf, c, token, status);
}
*linenumber = lineCount;
return result;
}
CSMFilter::Token CSMFilter::Parser::getNextToken()
{
int size = static_cast<int> (mInput.size());
char c = 0;
for (; mIndex<size; ++mIndex)
{
c = mInput[mIndex];
if (c!=' ')
break;
}
if (mIndex>=size)
return Token (Token::Type_EOS);
switch (c)
{
case '(': ++mIndex; return Token (Token::Type_Open);
case ')': ++mIndex; return Token (Token::Type_Close);
case '[': ++mIndex; return Token (Token::Type_OpenSquare);
case ']': ++mIndex; return Token (Token::Type_CloseSquare);
case ',': ++mIndex; return Token (Token::Type_Comma);
case '!': ++mIndex; return Token (Token::Type_OneShot);
}
if (c=='"' || c=='_' || std::isalpha (c) || c==':')
return getStringToken();
if (c=='-' || c=='.' || std::isdigit (c))
return getNumberToken();
error();
return Token (Token::Type_None);
}
api_return TransferApi::handleDisconnect(ApiRequest& aRequest) {
auto item = getTransfer(aRequest);
ConnectionManager::getInstance()->disconnect(item->getStringToken());
return websocketpp::http::status_code::ok;
}
tokenInfo getNextToken(FILE *fp, buffer B)
{
// Read the input from the buffer.
// Check if the buffer has enough space. Else change the buffer.
if(B->fwdPointer >= BUFFERSIZE)
{
// Change buffers.
getStream(fp, B->nextBuffer, BUFFERSIZE);
// Set current buffer to next buffer
if(B->nextBuffer == NULL)
{
return NULL;
}
B = B->nextBuffer;
// Return next token from the next buffer.
return getNextToken(fp, B);
}
char a = B->buff[B->fwdPointer];
// Check first for the one character tokens.
if(a == '(')
{
tokenInfo token = makeSingleToken(B);
token->token_name = OP;
token->token_value = "(";
return token;
}
else if(a == ')')
{
tokenInfo token = makeSingleToken(B);
token->token_name = CL;
token->token_value = ")";
return token;
}
else if(a == '[')
{
tokenInfo token = makeSingleToken(B);
token->token_name = SQO;
token->token_value = "[";
return token;
}
else if(a == ']')
{
tokenInfo token = makeSingleToken(B);
token->token_name = SQC;
token->token_value = "]";
return token;
}
else if(a == ';')
{
tokenInfo token = makeSingleToken(B);
token->token_name = SEMICOLON;
token->token_value = ";";
return token;
}
else if(a == ',')
{
tokenInfo token = makeSingleToken(B);
token->token_name = COMMA;
token->token_value = ",";
return token;
}
else if(a == '+')
{
tokenInfo token = makeSingleToken(B);
token->token_name = PLUS;
token->token_value = "+";
return token;
}
else if(a == '-')
{
tokenInfo token = makeSingleToken(B);
token->token_name = MINUS;
token->token_value = "-";
return token;
}
else if(a == '*')
{
tokenInfo token = makeSingleToken(B);
token->token_name = MUL;
token->token_value = "*";
return token;
}
else if(a == '/')
{
tokenInfo token = makeSingleToken(B);
token->token_name = DIV;
token->token_value = "/";
return token;
}
else if(a == '@')
{
tokenInfo token = makeSingleToken(B);
token->token_name = SIZE;
token->token_value = "@";
return token;
}
// Check for comments token and safely ignore
else if(a == '#')
{
++B->fwdPointer;
while(B->fwdPointer < BUFFERSIZE && (B->buff[B->fwdPointer]!= '\n' && B->buff[B->fwdPointer]!= EOF))
{
++B->fwdPointer;
}
// Any of the above cases means we have reached the end of the current buffer. Check if exceeded buffer length
if(B->buff[B->fwdPointer] == '\n' || B->buff[B->fwdPointer] == EOF)
{
// The comment has ended. Get the next token and return it.
++B->lineNumber;
getStream(fp, B->nextBuffer, BUFFERSIZE);
// Set current buffer to next buffer
if(B->nextBuffer == NULL)
{
return NULL;
}
B = B->nextBuffer;
// Keep checking for how long comments go and return next token.
return getNextToken(fp, B);
}
if(B->fwdPointer >= BUFFERSIZE)
{
// The comment has overflowed to next buffer. Finish reading comment and return the next token.
getStream(fp, B->nextBuffer, BUFFERSIZE);
// Set current buffer to next buffer
if(B->nextBuffer == NULL)
{
return NULL;
}
B = B->nextBuffer;
// Keep checking for how long comments go and return next token.
return getEndCommentAndNextToken(fp, B);
}
}
else if(a == '>' || a == '<')
{
// Check next token.
++B->fwdPointer;
tokenInfo token = malloc(sizeof(tokenStruct));
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
int curPointer = B->curPointer; // Store the current value temporarily.
tokenInfo nextToken = getNextToken(fp, B);
if(nextToken->token_name == ASSIGNOP)
{
// Assign the correct value to this token.
if(a == '>')
{
token->token_name = GE;
B->curPointer = ++B->fwdPointer;
B->charNumber = B->fwdPointer;
token->token_value = ">=";
free(nextToken);
return token;
}
else
{
token->token_name = LE;
B->curPointer = ++B->fwdPointer;
B->charNumber = B->fwdPointer;
token->token_value = "<=";
free(nextToken);
return token;
}
}
else
{
// Something else. Return LT or GT.
// TODO: Is an error possible in this case?
if(a == '>')
{
token->token_name = GT;
// Lost the next token. Need to generate that one again.
B->curPointer = curPointer + 1;
B->fwdPointer = B->curPointer;
B->charNumber = B->fwdPointer;
token->token_value = ">";
free(nextToken);
return token;
}
else if(a == '<')
{
token->token_name = LT;
// Lost the next token. Need to generate that one again.
B->curPointer = curPointer + 1;
B->fwdPointer = B->curPointer;
B->charNumber = B->fwdPointer;
token->token_value = "<";
free(nextToken);
return token;
}
}
}
else if(a == '=')
{
++B->fwdPointer;
tokenInfo token = malloc(sizeof(tokenStruct));
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
int curPointer = B->curPointer; // Temporary store.
tokenInfo nextToken = getNextToken(fp, B);
if(nextToken->token_name == ASSIGNOP)
{
// EQ token.
token->token_name = EQ;
token->token_value = "==";
B->charNumber = ++B->fwdPointer;
free(nextToken);
return token;
}
else if(nextToken->token_name == DIV)
{
// This should become a NE token
if(B->buff[B->fwdPointer] == '=')
{
// It is the NE token.
token->token_name = NE;
token->token_value = "=/=";
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
return token;
}
else
{
// Not NE token. An error
// TODO: Decide error functions
char *err = "Bad token. Possible Token: NE .";
showError(err, B->lineNumber);
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
free(token);
return NULL;
}
}
else
{
// Something else. This is the ASSIGNOP token
token->token_name = ASSIGNOP;
// Lost the next token. Need to generate again.
B->curPointer = ++curPointer;
token->token_value = "=";
B->fwdPointer = B->curPointer;
B->charNumber = B->fwdPointer;
free(nextToken);
return token;
}
}
else if(a == '.')
{
// One of the logical operators, possibly
++B->fwdPointer;
tokenInfo token = malloc(sizeof(tokenStruct));
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
int curPointer = B->curPointer;
tokenInfo nextToken = getNextToken(fp, B);
if(nextToken->token_name == ID)
{
// Check which of the logical operators
if(!strcmp(nextToken->token_value,"and"))
{
// Maybe the and operator.
if(B->buff[B->fwdPointer] == '.')
{
// AND token.
token->token_name = AND;
token->token_value = ".and.";
// Increment current and fwd pointer.
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
return token;
}
else
{
// Something else. A Lexical error;
char *err = "Lexical error. Possible Token: AND .";
showError(err, B->lineNumber);
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
free(token);
return NULL;
}
}
else if(!strcmp(nextToken->token_value,"or"))
{
// Maybe the or operator
if(B->buff[B->fwdPointer] == '.')
{
// OR token.
token->token_name = OR;
token->token_value = ".or.";
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
return token;
}
else{
// Lexical error.
char *err = "Lexical error. Possible token: OR .";
showError(err, B->lineNumber);
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
free(token);
return NULL;
}
}
else if(!strcmp(nextToken->token_value,"not"))
{
// Maybe the not operator
if(B->buff[B->fwdPointer] == '.')
{
// NOT token.
token->token_name = NOT;
token->token_value = ".not.";
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
return token;
}
else{
// Lexical error.
char *err = "Lexical error. Possible Token: NOT .";
showError(err, B->lineNumber);
++B->fwdPointer;
++B->curPointer;
++B->charNumber;
free(nextToken);
free(token);
return NULL;
}
}
else
{
// Some other identifier. A Lexical error;
char *err = "Lexical error after .";
showError(err, B->lineNumber);
B->curPointer = ++curPointer;
B->fwdPointer = B->curPointer;
B->charNumber = B->fwdPointer;
free(nextToken);
free(token);
return NULL;
}
}
else
{
// A Lexical error;
char *err = "Lexical Error after .";
showError(err,B->lineNumber);
B->curPointer = ++curPointer;
B->fwdPointer = B->curPointer;
B->charNumber = B->fwdPointer;
free(nextToken);
free(token);
return NULL;
}
}
else if(a == '_')
{
// A function identifier
++B->fwdPointer;
tokenInfo token = malloc(sizeof(tokenStruct));
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
token->token_name = FUNID;
char* funvalue = (char*)malloc((1+FUNSIZE)*sizeof(char));
funvalue[0] = '_';
if((B->buff[B->fwdPointer] >= 'a' && B->buff[B->fwdPointer] <= 'z') || (B->buff[B->fwdPointer] >= 'A' && B->buff[B->fwdPointer] <= 'Z'))
{
// Check for the function token.
tokenInfo funToken = getFunctionToken(fp, B, FUNSIZE);
strcpy(funvalue,funToken->token_value);
// No need to store the underscore of the function name.
tokenInfo keywordToken = checkForKeyword(funToken->token_value);
if(keywordToken != NULL)
{
// It is a keyword token. Return as keyword.
free(token);
token = keywordToken;
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(funvalue);
//free(keywordToken);
free(funToken);
return token;
}
else
{
// It is an identifier. Return the identifier itself.
token->token_value = funvalue;
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(funToken);
return token;
}
}
else
{
// Incorrect. Show error.
char *err = "Lexical Error. Function names may start only with alphabets.";
showError(err, B->lineNumber);
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(funvalue);
free(token);
return NULL;
}
}
else if((a >= 'a' && a<= 'z') || (a >= 'A' && a<= 'Z'))
{
// An alphabet identifier
++B->fwdPointer;
tokenInfo token = malloc(sizeof(tokenStruct));
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
token->token_name = ID;
char* idvalue = (char*)malloc((1+IDSIZE)*sizeof(char));
tokenInfo idToken = getIDToken(fp, B, IDSIZE);
// Check if it is a token
idvalue[0] = a;
if(idToken == NULL)
{
// Check for one alphabet identifier only.
token->token_value = idvalue;
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(idToken);
return token;
}
idvalue = joinStrings(idvalue,idToken->token_value);
idToken->token_value = idvalue;
tokenInfo keywordToken = checkForKeyword(idToken->token_value);
if(keywordToken != NULL)
{
// It is a keyword token. Return as keyword.
free(token);
token = keywordToken;
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
//free(keywordToken);
free(idToken);
return token;
}
else
{
// It is an identifier. Return the identifier itself.
token->token_value = idvalue;
//printf("%s",token->token_value);
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(keywordToken);
free(idToken);
return token;
}
}
else if(a >= '0' && a<= '9')
{
// A number identifier
++B->fwdPointer;
tokenInfo token = malloc(sizeof(tokenStruct));
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
char* numvalue = (char*)malloc((1+NUMSIZE)*sizeof(char));
tokenInfo numToken = getNumberToken(fp, B);
token->token_name = numToken->token_name; //whether RealNum or IntNum.
numvalue[0] = a;
token->token_value = joinStrings(numvalue,numToken->token_value);
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(numToken);
return token;
}
else if(a == '\"')
{
// String type.
++B->fwdPointer;
tokenInfo token = malloc(sizeof(tokenStruct));
token->charNumber = B->charNumber;
token->lineNumber = B->lineNumber;
token->token_name = STR;
char* stringValue = (char*)malloc((IDSIZE)*sizeof(char));
tokenInfo stringToken = getStringToken(fp, B, IDSIZE);
// CONSIDER: check if end of string has a '"'
if(B->buff[B->fwdPointer] == '"')
{
// It is a string ending with the '"'
strcpy(stringValue,stringToken->token_value);
token->token_value = stringValue;
++B->fwdPointer;
//printf("%s +++ %s",token->token_value,stringToken->token_value);
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(stringToken);
return token;
}
else
{
// It is not a token. Lexical error
char *err = "Lexical error after \\";
showError(err,B->lineNumber);
++B->fwdPointer;
B->curPointer = B->fwdPointer;
B->charNumber = B->fwdPointer;
free(stringToken);
free(token);
free(stringValue);
return NULL;
}
}
else
{
// All other cases.
if(a == '\n')
{
// New line. Change values of line number and char number
++B->lineNumber;
B->charNumber = 0;
// Change the buffer.
FILE* check = getStream(fp, B->nextBuffer, BUFFERSIZE);
// Set current buffer to next buffer
if(check == NULL)
{
return NULL;
}
B = B->nextBuffer;
return getNextToken(fp, B);
}
else if(a == ' ')
{
++B->fwdPointer;
B->curPointer = B->fwdPointer;
++B->charNumber;
return getNextToken(fp, B);
}
else if(a == EOF)
{
// End of the input file. Stop here.
return NULL;
}
else if(a == '\t')
{
++B->fwdPointer;
B->curPointer = B->fwdPointer;
++B->charNumber;
return getNextToken(fp, B);
}
else
{
// Don't know what type of cases come here. CONSIDER
return NULL;
}
}
return NULL;
}
void parseAlarmJson(char* content){
int r;
int i = 2;
int startidx = 0;
int charAmount = 0;
int usedAlarms[maxAlarms()];
int j;
jsmn_parser p;
jsmntok_t token[160]; /* We expect no more than 128 tokens */
jsmn_init(&p);
r = jsmn_parse(&p, content, strlen(content), token, sizeof(token)/sizeof(token[0]));
if (r <= 0) {
printf("Failed to parse JSON: %d \n", r);
return;
}else{
printf("Aantal tokens found: %d \n", r);
}
struct _tm time = GetRTCTime();
for(j = 0; j < maxAlarms(); j++){
usedAlarms[j] = 0;
}
for(i = 2; i < r; i++)
{
int id = 0;
u_short port = 0;
char url[24];
char ip[24];
char name[17];
char str2[16];
char st = -1;
char oo = -1;
memset(url, 0, 24);
memset(ip, 0, 24);
memset(name, 0, 17);
for (i = i; (st == -1 && i < r); i+=2) { //Zodra ST is gevonden, betekent dit de laatste token van een alarm.
if (jsoneq(content, &token[i], "YYYY") == 0) {
time.tm_year= getIntegerToken(content, &token[i + 1]) - 1900;
}else if (jsoneq(content, &token[i], "MM") == 0) {
time.tm_mon= getIntegerToken(content, &token[i + 1]) - 1;
}else if (jsoneq(content, &token[i], "DD") == 0) {
time.tm_mday = getIntegerToken(content, &token[i + 1]);
}else if (jsoneq(content, &token[i], "hh") == 0) {
time.tm_hour = getIntegerToken(content, &token[i + 1]);
}else if (jsoneq(content, &token[i], "mm") == 0) {
time.tm_min = getIntegerToken(content, &token[i + 1]);
}else if (jsoneq(content, &token[i], "ss") == 0) {
time.tm_sec = getIntegerToken(content, &token[i + 1]);
}else if (jsoneq(content, &token[i], "id") == 0) {
id = getIntegerToken(content, &token[i + 1]);
}else if (jsoneq(content, &token[i], "port") == 0) {
port = getIntegerToken(content, &token[i + 1]);
}else if (jsoneq(content, &token[i], "ip") == 0) {
getStringToken(content, &token[i + 1], ip, 24);
}else if (jsoneq(content, &token[i], "url") == 0) {
getStringToken(content, &token[i + 1], url, 24);
}else if (jsoneq(content, &token[i], "name") == 0) {
getStringToken(content, &token[i + 1], name, 18);
}else if (jsoneq(content, &token[i], "oo") == 0) {
oo = getIntegerToken(content, &token[i + 1]);
}else if (jsoneq(content, &token[i], "st") == 0) {
st = getIntegerToken(content, &token[i + 1]);
}
}
int idx = alarmExist(id);
if(idx == -1){
printf("New alarm found!\n");
printf("Alarm time is: %02d:%02d:%02d\n", time.tm_hour, time.tm_min, time.tm_sec);
printf("Alarm date is: %02d.%02d.%02d\n", time.tm_mday, (time.tm_mon + 1), (time.tm_year + 1900));
printf("Alarm stream data is: %s:%d%s\n", ip, port, url);
printf("Alarm id and name and st is: %d %s %d\n\n", id, name, st);
charAmount = 0;
for (i = 0; i < 16;i++){
if (name[i] != 0){
charAmount = charAmount + 1;
}
}
startidx = (8-(charAmount/2));
charAmount = 0;
for(i = 0; i < 16; i++){
if (i >= startidx){
if (name[charAmount] != 0){
str2[i] = name[charAmount];
} else {
str2[i] = ' ';
}
charAmount++;
} else {
str2[i] = ' ';
}
}
//zoek naar een vrije plaats in de alarm array
for(j = 0; j < maxAlarms(); j++){
if(usedAlarms[j] == 0){ //Dit is een lege plaats, hier kunnen we ons nieuwe alarm plaatsen
if (oo == 1){
eenmaligAlarm(time,str2,ip,port,url,st,id,j);
} else {
setAlarm(time, str2, ip, port, url, st, id, j);
}
usedAlarms[j] = 1;
j = 10; //Uit de for loop
}
}
}else{
usedAlarms[idx] = 1; //Alarm bestaat al, dus we houden deze plaats vrij voor dat alarm
}
}
for(j = 0; j < maxAlarms(); j++){ //Alle overige plaatsen, die wij niet gezet hebben, verwijderen.
if(usedAlarms[j] == 0){
deleteAlarm(j);
};
}
}
