285 lines
5.0 KiB
C
285 lines
5.0 KiB
C
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#include "botforth.h"
|
|
|
|
#define STRINGLENGTH 255
|
|
#define DEBUG printf("\n---DEBUG---\n");
|
|
|
|
|
|
struct node *node_create(void *content, int type)
|
|
{
|
|
struct node *n = malloc(sizeof(struct node));
|
|
//char *name;
|
|
assert(type < 20);
|
|
n->content = content;
|
|
n->type = type;
|
|
/*
|
|
name=malloc(5);
|
|
sprintf(name,"none");
|
|
*/
|
|
n->name = NULL;
|
|
return n;
|
|
}
|
|
|
|
struct node *node_copy(struct node *n)
|
|
{
|
|
struct node *c;
|
|
void *content;
|
|
assert(n != NULL);
|
|
assert(n->type < 20);
|
|
switch (n->type) {
|
|
case BF_TYPE_INT:
|
|
content = malloc(sizeof(int));
|
|
memcpy(content, n->content, sizeof(int));
|
|
break;
|
|
case BF_TYPE_FLOAT:
|
|
content = malloc(sizeof(float));
|
|
memcpy(content, n->content, sizeof(float));
|
|
break;
|
|
case BF_TYPE_STRING:
|
|
assert(n->content != NULL);
|
|
content = malloc(strlen(n->content) + 1);
|
|
memcpy(content, n->content, strlen(n->content) + 1);
|
|
break;
|
|
case BF_TYPE_POINTER:
|
|
content = n->content;
|
|
break;
|
|
case BF_TYPE_VECTOR:
|
|
content =
|
|
(void *) vector_copy((struct vector *) n->content);
|
|
break;
|
|
default:
|
|
printf
|
|
("Der Datentyp %i kann bislang nicht kopiert werden.\n",
|
|
n->type);
|
|
exit(1);
|
|
break;
|
|
}
|
|
c = node_create(content, n->type);
|
|
if (n->name) {
|
|
c->name = malloc(strlen(n->name) + 1);
|
|
sprintf(c->name, "%s", n->name);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
|
|
int node_destroy(struct node *n)
|
|
{
|
|
if (n == NULL)
|
|
return 0;
|
|
// todo: alle typen abfragen
|
|
switch (n->type) {
|
|
case BF_TYPE_C_TEXT:
|
|
case BF_TYPE_STRING:
|
|
case BF_TYPE_INT:
|
|
case BF_TYPE_FLOAT:
|
|
free(n->content);
|
|
break;
|
|
//case BF_TYPE_C_EXT: // leider nein, weil sonst der cache sich rekursiv dematerialisiert
|
|
case BF_TYPE_VECTOR:
|
|
if(n != n->content)
|
|
vector_destroy((struct vector *) n->content);
|
|
break;
|
|
case BF_TYPE_NODE:
|
|
if(n != n->content)
|
|
node_destroy((struct node *) n->content);
|
|
break;
|
|
case BF_TYPE_DB:
|
|
{
|
|
struct db *tmp = n->content;
|
|
assert(tmp);
|
|
if (tmp->query)
|
|
free(tmp->query);
|
|
if (tmp->field)
|
|
free(tmp->field);
|
|
break;
|
|
}
|
|
case BF_TYPE_POINTER:
|
|
// nichts loeschen, der node hier gehoert ja wem anders
|
|
break;
|
|
}
|
|
if (n->name)
|
|
free(n->name);
|
|
free(n);
|
|
return 1;
|
|
}
|
|
|
|
int node_toInt(struct node *n)
|
|
{
|
|
int temp;
|
|
if (n == NULL)
|
|
return 0;
|
|
switch (n->type) {
|
|
case BF_TYPE_INT:
|
|
temp = *(int *) n->content;
|
|
node_destroy(n);
|
|
return temp;
|
|
break;
|
|
case BF_TYPE_FLOAT:
|
|
temp = (int) *(float *) n->content;
|
|
node_destroy(n);
|
|
return temp;
|
|
break;
|
|
case BF_TYPE_STRING:
|
|
temp = atoi(n->content);
|
|
node_destroy(n);
|
|
return temp;
|
|
break;
|
|
default:
|
|
node_destroy(n);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
float node_toFloat(struct node *n)
|
|
{
|
|
float temp;
|
|
if (n == NULL)
|
|
return 0.0;
|
|
switch (n->type) {
|
|
case BF_TYPE_FLOAT:
|
|
temp = *(float *) n->content;
|
|
node_destroy(n);
|
|
return temp;
|
|
break;
|
|
case BF_TYPE_INT:
|
|
temp = (float) *(int *) n->content;
|
|
node_destroy(n);
|
|
return temp;
|
|
break;
|
|
case BF_TYPE_STRING:
|
|
temp = atof(n->content);
|
|
node_destroy(n);
|
|
return temp;
|
|
break;
|
|
default:
|
|
node_destroy(n);
|
|
}
|
|
return 0.0;
|
|
}
|
|
|
|
char *node_toString(struct node *n)
|
|
{
|
|
char *temp, *r;
|
|
//printf("%i\n",n->type);
|
|
if (n == NULL) {
|
|
temp = malloc(1);
|
|
temp[0] = '\0';
|
|
return temp;
|
|
}
|
|
switch (n->type) {
|
|
case BF_TYPE_STRING:
|
|
case BF_TYPE_C_TEXT:
|
|
r = n->content;
|
|
if (n->name)
|
|
free(n->name);
|
|
free(n);
|
|
break;
|
|
case BF_TYPE_INT:
|
|
r = malloc(sizeof(char) * 100); // todo: moeglicher bufferoverflow
|
|
sprintf(r, "%i", node_toInt(n));
|
|
break;
|
|
case BF_TYPE_FLOAT:
|
|
r = malloc(sizeof(char) * 100); // todo: moeglicher bufferoverflow
|
|
sprintf(r, "%g", node_toFloat(n));
|
|
break;
|
|
case BF_TYPE_VECTOR:
|
|
r = malloc(7);
|
|
sprintf(r, "Vector");
|
|
node_destroy(n);
|
|
break;
|
|
case BF_TYPE_NODE:
|
|
r = malloc(5);
|
|
sprintf(r, "Node");
|
|
node_destroy(n);
|
|
break;
|
|
case BF_TYPE_DB:
|
|
r = malloc(strlen("db") + 1);
|
|
strcpy(r, "db");
|
|
node_destroy(n);
|
|
break;
|
|
default:
|
|
r = malloc(1);
|
|
r[0] = '\0';
|
|
node_destroy(n);
|
|
break;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
struct vector *node_toVector(struct node *n)
|
|
{
|
|
struct vector *content;
|
|
if (n == NULL)
|
|
return NULL;
|
|
switch (n->type) {
|
|
case BF_TYPE_C_EXT:
|
|
case BF_TYPE_VECTOR:
|
|
content = n->content;
|
|
if (n->name)
|
|
free(n->name);
|
|
free(n);
|
|
return content;
|
|
break;
|
|
default:
|
|
node_destroy(n);
|
|
return NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
struct node *node_toPointer(struct node *n)
|
|
{
|
|
struct node *content;
|
|
if (n == NULL)
|
|
return NULL;
|
|
if (n->type == BF_TYPE_POINTER) {
|
|
content = n->content;
|
|
if (n->name)
|
|
free(n->name);
|
|
free(n);
|
|
return content;
|
|
}
|
|
node_destroy(n);
|
|
return NULL;
|
|
}
|
|
|
|
struct db *node_todb(struct node *n)
|
|
{
|
|
struct db *content = 0;
|
|
if (!n)
|
|
return content;
|
|
if (n->type == BF_TYPE_DB) {
|
|
content = (struct db *) n->content;
|
|
if (n->name)
|
|
free(n->name);
|
|
free(n);
|
|
return content;
|
|
}
|
|
node_destroy(n);
|
|
return content;
|
|
}
|
|
|
|
|
|
struct node *node_toNode(struct node *n)
|
|
{
|
|
struct node *content;
|
|
if (n == NULL)
|
|
return NULL;
|
|
if (n->type == BF_TYPE_NODE) {
|
|
if (n->name)
|
|
free(n->name);
|
|
content = n->content;
|
|
free(n);
|
|
return content;
|
|
} else {
|
|
node_destroy(n);
|
|
}
|
|
return NULL;
|
|
}
|