Skip to content

Commit

Permalink
feat: franciser
Browse files Browse the repository at this point in the history
  • Loading branch information
@valerierx
valerierx committed May 26, 2024
1 parent 7c08a14 commit 51fb9d8
Show file tree
Hide file tree
Showing 10 changed files with 371 additions and 353 deletions.
4 changes: 2 additions & 2 deletions CosmicYonder.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -235,8 +235,8 @@ void invBoucle(WINDOW *mainwin, int *touche, InvMenu *invMenu, Inventaire* inven

// SAUVEGARDE
void sauvegardeBoucle(WINDOW * mainwin, EntreeTexte * sauve, int x, int y, int hauteur, int longueur, int* touche);
void saveGame(Partie * partie, char * nomFichier);
Partie * loadGame(char * nomFichier);
void sauveJeu(Partie * partie, char * nomFichier);
Partie * chargerJeu(char * nomFichier);
int verifFichier(char * nomSauvegarde);
//JEU
Partie * creerPartie();
Expand Down
168 changes: 84 additions & 84 deletions json/json.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,23 +12,23 @@
#include "../logger.h"


char * skipSpaces(char *str) { // ignore les espaces
char * sauteEspaces(char *str) { // ignore les espaces
while(isspace(*str)) {
str++;
}
return str;
}

int chrLookup(char **str, char chr) { // place le caractère recherché en index 0 de la chaine de caractères
*str = skipSpaces(*str);
int chercheChar(char **str, char chr) { // place le caractère recherché en index 0 de la chaine de caractères
*str = sauteEspaces(*str);
if (**str == chr) {
(*str)++;
return 1;
}
return 0;
}

int intLength(int i) { // retourne la longueur d'un entier, plus rapide que log10()
int longueurInt(int i) { // retourne la longueur d'un entier, plus rapide que log10()
if(i < 0) {
i = -i;
}
Expand Down Expand Up @@ -62,8 +62,8 @@ int intLength(int i) { // retourne la longueur d'un entier, plus rapide que log1
return 1;
}

char * parseJSONString(char **str) {
*str = skipSpaces(*str);
char * parserChaineJSON(char **str) {
*str = sauteEspaces(*str);
if (**str != '"') { // pas une chaine de caractères
return NULL;
}
Expand All @@ -80,7 +80,7 @@ char * parseJSONString(char **str) {
char * result = NULL;
result = malloc(length + 1);
if (result == NULL) {
logMessage(CRITICAL, "erreur malloc result parseJSONString");
logMessage(CRITICAL, "erreur malloc result parserChaineJSON");
exit(1);
}

Expand All @@ -90,13 +90,13 @@ char * parseJSONString(char **str) {
return result;
}

int parseJSONInt(char **str, int sign) {
*str = skipSpaces(*str);
int parserEntierJSON(char **str, int sign) {
*str = sauteEspaces(*str);
int result;
int verif = -1;
verif = sscanf(*str, "%d", &result);
if(verif != 1) {
logMessage(CRITICAL, "erreur sscanf parseJSONInt");
logMessage(CRITICAL, "erreur sscanf parserEntierJSON");
}
while(isdigit(**str)) { // déplace le curseur
(*str)++;
Expand All @@ -107,133 +107,133 @@ int parseJSONInt(char **str, int sign) {
return result;
}

int parseJSONBool(char **str) {
*str = skipSpaces(*str);
int parserBooleenJSON(char **str) {
*str = sauteEspaces(*str);
if (strncmp(*str, "true", 4) == 0) {
*str += 4;
return 1;
} else if (strncmp(*str, "false", 5) == 0) {
*str += 5;
return 0;
}
logMessage(CRITICAL, "erreur parse parseJSONBool");
logMessage(CRITICAL, "erreur parse parserBooleenJSON");
return -1; // Erreur
}

JSONArray * parseJSONArray(char **str) {
if (!chrLookup(str, '[')) {
logMessage(CRITICAL, "erreur parseJSONArray, [ manquant");
JSONArray * parserTabJSON(char **str) {
if (!chercheChar(str, '[')) {
logMessage(CRITICAL, "erreur parserTabJSON, [ manquant");
exit(1); // Erreur
}
JSONArray * array = NULL;
array = malloc(sizeof(JSONArray));
if(array == NULL) {
logMessage(CRITICAL, "erreur malloc array parseJSONArray");
logMessage(CRITICAL, "erreur malloc array parserTabJSON");
exit(1);
}
array->values = NULL;
array->length = 0;

while (!chrLookup(str, ']')) {
JSONKeyValuePair pair; //creation du couple clé-valeur
pair.value = parseJSONValue(str);
array->values = realloc(array->values, sizeof(JSONKeyValuePair) * (array->length + 1)); // agrandit l'allocation mémoire des valeurs
while (!chercheChar(str, ']')) {
JSONCleValeurCouple pair; //creation du couple clé-valeur
pair.value = parserValeurJSON(str);
array->values = realloc(array->values, sizeof(JSONCleValeurCouple) * (array->length + 1)); // agrandit l'allocation mémoire des valeurs
array->values[array->length++] = pair;
chrLookup(str, ','); // avance à la virgule suivante
chercheChar(str, ','); // avance à la virgule suivante
}

return array;

}

JSONValue parseJSONValue(char **str) {
*str = skipSpaces(*str);
JSONValue v;
JSONValeur parserValeurJSON(char **str) {
*str = sauteEspaces(*str);
JSONValeur v;
if (**str == '"') {
v.type = JSON_STRING;
v.stringValue = parseJSONString(str);
v.type = JSON_CHAINE;
v.stringValue = parserChaineJSON(str);
} else if (**str == '{') {
v.type = JSON_OBJECT;
v.objectValue = parseJSONObject(str);
v.type = JSON_OBJET;
v.objectValue = parserObjetJSON(str);
} else if (**str == '[') {
v.type = JSON_ARRAY;
v.arrayValue = parseJSONArray(str);
v.type = JSON_TABLEAU;
v.arrayValue = parserTabJSON(str);
} else if (**str == '-') {
(*str)++;
v.type = JSON_NUMBER;
v.numberValue = parseJSONInt(str, 0);
v.type = JSON_NOMBRE;
v.numberValue = parserEntierJSON(str, 0);
} else if (isdigit(**str)) {
v.type = JSON_NUMBER;
v.numberValue = parseJSONInt(str, 1);
v.type = JSON_NOMBRE;
v.numberValue = parserEntierJSON(str, 1);
} else if (strncmp(*str, "true", 4) == 0 || strncmp(*str, "false", 5) == 0) {
v.type = JSON_BOOL;
v.boolValue = parseJSONBool(str);
v.boolValue = parserBooleenJSON(str);
} else {
logMessage(CRITICAL, "erreur parseJSONValue");
logMessage(CRITICAL, "erreur parserValeurJSON");
v.type = JSON_NULL; // Erreur
}
return v;
}



JSONObject * parseJSONObject(char ** str) {
if (!chrLookup(str, '{')) {
logMessage(CRITICAL, "erreur parseJSONObject, { manquant");
JSONObjet * parserObjetJSON(char ** str) {
if (!chercheChar(str, '{')) {
logMessage(CRITICAL, "erreur parserObjetJSON, { manquant");
exit(1); // Erreur
}
JSONObject * object = NULL;
object = malloc(sizeof(JSONObject));
JSONObjet * object = NULL;
object = malloc(sizeof(JSONObjet));
if(object == NULL) {
logMessage(CRITICAL, "erreur malloc object parseJSONObject");
logMessage(CRITICAL, "erreur malloc object parserObjetJSON");
exit(1);
}
object->pairs = NULL;
object->length = 0;

while (!chrLookup(str, '}')) {
JSONKeyValuePair pair;
pair.key = parseJSONString(str);
if (!pair.key || !chrLookup(str, ':')) {
while (!chercheChar(str, '}')) {
JSONCleValeurCouple pair;
pair.key = parserChaineJSON(str);
if (!pair.key || !chercheChar(str, ':')) {
free(object);
logMessage(CRITICAL, "erreur parseJSONObject, : manquant");
logMessage(CRITICAL, "erreur parserObjetJSON, : manquant");
exit(1); // Erreur
}
pair.value = parseJSONValue(str);
object->pairs = realloc(object->pairs, sizeof(JSONKeyValuePair) * (object->length + 1)); // agrandit l'allocation mémoire des couples clé-valeur
pair.value = parserValeurJSON(str);
object->pairs = realloc(object->pairs, sizeof(JSONCleValeurCouple) * (object->length + 1)); // agrandit l'allocation mémoire des couples clé-valeur
object->pairs[object->length++] = pair;
chrLookup(str, ','); // avance à la virgule suivante
chercheChar(str, ','); // avance à la virgule suivante
}
return object;
}

char * serializeJSONString(JSONValue str) {
char * serializeChaineJSON(JSONValeur str) {
char * result = NULL;
result = malloc(strlen(str.stringValue) + 3);
if (result == NULL) {
logMessage(CRITICAL, "erreur malloc result serializeJSONString");
logMessage(CRITICAL, "erreur malloc result serializeChaineJSON");
exit(1);
}
sprintf(result, "\"%s\"", str.stringValue);
return result;
}

char * serializeJSONInt(JSONValue i) {
char * serializeEntierJSON(JSONValeur i) {
char * result = NULL;
result = malloc(sizeof(char) * intLength(i.numberValue) + 1);
result = malloc(sizeof(char) * longueurInt(i.numberValue) + 1);
if (result == NULL) {
logMessage(CRITICAL, "erreur malloc result serializeJSONInt");
logMessage(CRITICAL, "erreur malloc result serializeEntierJSON");
exit(1);
}
sprintf(result, "%d", i.numberValue);
return result;
}

char * serializeJSONBool(JSONValue b) {
char * serializeBooleenJSON(JSONValeur b) {
char * result = NULL;
result = malloc(sizeof(char) * 6);
if (result == NULL) {
logMessage(CRITICAL, "erreur malloc result serializeJSONBool");
logMessage(CRITICAL, "erreur malloc result serializeBooleenJSON");
exit(1);
}
if (b.boolValue) {
Expand All @@ -244,36 +244,36 @@ char * serializeJSONBool(JSONValue b) {
return result;
}

char * serializeJSONArray(JSONArray a) {
char * serializeTabJSON(JSONArray a) {
char * result = NULL;
char * finalString = NULL;
char * value = NULL;

result = malloc(sizeof(char));
if (result == NULL) {
logMessage(CRITICAL, "erreur malloc result serializeJSONArray");
logMessage(CRITICAL, "erreur malloc result serializeTabJSON");
exit(1);
}
result[0] = '\0';
for (int i = 0; i < a.length; i++) {
switch (a.values[i].value.type) {
case JSON_STRING:
value = serializeJSONString(a.values[i].value);
case JSON_CHAINE:
value = serializeChaineJSON(a.values[i].value);
break;
case JSON_NUMBER:
value = serializeJSONInt(a.values[i].value);
case JSON_NOMBRE:
value = serializeEntierJSON(a.values[i].value);
break;
case JSON_BOOL:
value = serializeJSONBool(a.values[i].value);
value = serializeBooleenJSON(a.values[i].value);
break;
case JSON_OBJECT:
value = serializeJSONObject(*a.values[i].value.objectValue);
case JSON_OBJET:
value = serializeObjetJSON(*a.values[i].value.objectValue);
break;
case JSON_ARRAY:
value = serializeJSONArray(*a.values[i].value.arrayValue);
case JSON_TABLEAU:
value = serializeTabJSON(*a.values[i].value.arrayValue);
break;
default:
logMessage(CRITICAL, "erreur serializeJSONArray");
logMessage(CRITICAL, "erreur serializeTabJSON");
exit(1);
}
result = realloc(result, strlen(result) + strlen(value) + 2);
Expand All @@ -286,44 +286,44 @@ char * serializeJSONArray(JSONArray a) {
}
finalString = malloc(strlen(result) + 3);
if (finalString == NULL) {
logMessage(CRITICAL, "erreur malloc finalResult serializeJSONArray");
logMessage(CRITICAL, "erreur malloc finalResult serializeTabJSON");
exit(1);
}
sprintf(finalString, "[%s]", result);
free(result);
return finalString;
}

char * serializeJSONObject(JSONObject o) {
char * serializeObjetJSON(JSONObjet o) {
char * result = NULL;
char * value = NULL;
char * finalString = NULL;

result = malloc(sizeof(char));
if (result == NULL) {
logMessage(CRITICAL, "erreur malloc result serializeJSONObject");
logMessage(CRITICAL, "erreur malloc result serializeObjetJSON");
exit(1);
}
result[0] = '\0';
for (int i = 0; i < o.length; i++) {
switch (o.pairs[i].value.type) {
case JSON_STRING:
value = serializeJSONString(o.pairs[i].value);
case JSON_CHAINE:
value = serializeChaineJSON(o.pairs[i].value);
break;
case JSON_NUMBER:
value = serializeJSONInt(o.pairs[i].value);
case JSON_NOMBRE:
value = serializeEntierJSON(o.pairs[i].value);
break;
case JSON_BOOL:
value = serializeJSONBool(o.pairs[i].value);
value = serializeBooleenJSON(o.pairs[i].value);
break;
case JSON_OBJECT:
value = serializeJSONObject(*o.pairs[i].value.objectValue);
case JSON_OBJET:
value = serializeObjetJSON(*o.pairs[i].value.objectValue);
break;
case JSON_ARRAY:
value = serializeJSONArray(*o.pairs[i].value.arrayValue);
case JSON_TABLEAU:
value = serializeTabJSON(*o.pairs[i].value.arrayValue);
break;
default:
logMessage(CRITICAL, "erreur serializeJSONObject");
logMessage(CRITICAL, "erreur serializeObjetJSON");
exit(1);
}
result = realloc(result, strlen(result) + strlen(o.pairs[i].key) + strlen(value) + 5);
Expand All @@ -340,7 +340,7 @@ char * serializeJSONObject(JSONObject o) {

finalString = malloc(strlen(result) + 3); // + accolades et \0
if (finalString == NULL) {
logMessage(CRITICAL, "erreur malloc finalString serializeJSONObject");
logMessage(CRITICAL, "erreur malloc finalString serializeObjetJSON");
exit(1);
}
sprintf(finalString, "{%s}", result); // ajoute les accolades
Expand Down
Loading

0 comments on commit 51fb9d8

Please sign in to comment.