repositories / TP_AL_C.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add includes to avoid missing prototype warning.
[TP_AL_C.git] / lexer / syntactic_analyzer.c
diff --git a/lexer/syntactic_analyzer.c b/lexer/syntactic_analyzer.c
index e23c130d5bb24c22fa93c966fd9c736c8c4c35db..0f1b1818b3a6c2ced9a65c8cc912fe3bd61385e2 100644 (file)
--- a/lexer/syntactic_analyzer.c
+++ b/lexer/syntactic_analyzer.c
@@ -1,122 +1,233 @@
 /* Syntactic analyzer */
 
 #include <stdbool.h>
-#include <stdarg.h>
+#include <stdlib.h>
 
 #include "global_vars.h"
+#include "print_helper.h"
+#include "syntactic_analyzer.h"
 #include "lexical_analyzer.h"
 
+#define PRINT_TOKEN 1
+
 /* Syntactic analyzer functions implementation */
 
 enum TokenType tokenType;
 
-static bool analyze_TEXT() {
-    bool rtval = true;
+static void analyze_TEXT() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
     if (tokenType == MOT) {
+        #if PRINT_TOKEN
+        wprint_ctoken(stdout);
+        #endif
+        if (target != NULL) {
+            fputws((const wchar_t*)tokenValue, target);
+            fputws(L" ", target);
+        }
         scanner();
-        rtval = analyze_TEXT();
+        analyze_TEXT();
     } else if (tokenType != MOTCLE && tokenType != NPARA && tokenType != SECTION && \
                 tokenType != SSECTION && tokenType != FIN) {
-        rtval = false;
+        fprintf(stderr, "%s follows error on %s\n", __func__, tokenTypestr[tokenType]);
+        fflush(stderr);
+        exit(EXIT_FAILURE);
     }
-    return rtval;
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-static bool analyze_P() {
-    bool rtval = true;
+static void analyze_P() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
     if (tokenType == NPARA) {
+        #if PRINT_TOKEN
+        wprint_ctoken(stdout);
+        #endif /* PRINT_TOKEN */
+        if (target != NULL) {
+            fputws(L"<p>\n", target);
+        }
         scanner();
-        if (tokenType == MOT) {
-            scanner();
-            rtval = analyze_TEXT();
-            rtval = analyze_P();
+        analyze_TEXT();
+        if (target != NULL) {
+            fputws(L"\n</p>\n", target);
         }
-    } else if (tokenType != SECTION && tokenType != SSECTION && tokenType != FIN) {
-        rtval = false;
-    }
-    return rtval;
+        analyze_P();
+        } else if (tokenType != SECTION && tokenType != SSECTION && tokenType != FIN) {
+            fprintf(stderr, "%s follows error on %s\n", __func__, tokenTypestr[tokenType]);
+            fflush(stderr);
+            exit(EXIT_FAILURE);
+        }
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-static bool analyze_HEAD() {
-    bool rtval = true;
-    if (tokenType == MOTCLE) {
+static void analyze_HEAD() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
+    if (tokenType == MOTCLE && wcscmp(L">Titre", (const wchar_t*)tokenValue) == 0) {
+        if (target != NULL) {
+            fputws(L"<title>\n", target);
+            fputws(L" ", target);
+        }
         scanner();
-        rtval = analyze_TEXT();
-        if (tokenType == MOTCLE) {
+        analyze_TEXT();
+        if (target != NULL) {
+            fputws(L"\n</title>\n", target);
+        }
+        if (tokenType == MOTCLE && wcscmp(L">Auteur", (const wchar_t*)tokenValue) == 0) {
+            #if PRINT_TOKEN
+            wprint_ctoken(stdout);
+            #endif /* PRINT_TOKEN */
+            fputws(L"<meta name=\"author\" content=\"", target);
             scanner();
-            rtval = analyze_TEXT();
-        } else {
-            rtval = false;
+            analyze_TEXT();
+            fputws(L"\">", target);
+        } else if (tokenType != NPARA && tokenType != SECTION && tokenType != FIN) {
+            fprintf(stderr, "%s follows error on %s\n", __func__, tokenTypestr[tokenType]);
+            fflush(stderr);
+            exit(EXIT_FAILURE);
         }
-    } else {
-        rtval = false;
     }
-    return rtval;
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-static bool analyze_H1() {
-    bool rtval = true;
+static void analyze_H1() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
     if (tokenType == SECTION) {
+        #if PRINT_TOKEN
+        wprint_ctoken(stdout);
+        #endif /* PRINT_TOKEN */
+        if (target != NULL) {
+            fputws(L"<h1>\n", target);
+        }
         scanner();
-        rtval = analyze_TEXT();
+        analyze_TEXT();
+        if (target != NULL) {
+            fputws(L"\n</h1>\n", target);
+        }
     } else {
-        rtval = false;
+        fprintf(stderr, "%s error\n", __func__);
+        fflush(stderr);
+        exit(EXIT_FAILURE);
     }
-    return rtval;
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-static bool analyze_H2() {
-    bool rtval = true;
+static void analyze_H2() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
     if (tokenType == SSECTION) {
+        #if PRINT_TOKEN
+        wprint_ctoken(stdout);
+        #endif /* PRINT_TOKEN */
+        if (target != NULL) {
+            fputws(L"<h2>\n", target);
+        }
         scanner();
-        rtval = analyze_TEXT();
-    } else {
-        rtval = false;
+        analyze_TEXT();
+        if (target != NULL) {
+            fputws(L"\n</h2>\n", target);
+        }
     }
-    return rtval;
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-static bool analyze_S2() {
-    bool rtval = true;
-    if (analyze_H2()) {
-        rtval = analyze_P();
-        rtval = analyze_S2();
+static void analyze_S2() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
+    if (tokenType == SSECTION) {
+        analyze_H2();
+        analyze_P();
+        analyze_S2();
     } else if (tokenType != SECTION && tokenType != FIN) {
-        rtval = false;
-    } else {
-        rtval = false;
+        fprintf(stderr, "%s follows error on %s\n", __func__, tokenTypestr[tokenType]);
+        fflush(stderr);
+        exit(EXIT_FAILURE);
     }
-    return rtval;
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-static bool analyze_S1() {
-    bool rtval = true;
-    if (analyze_H1()) {
-        rtval = analyze_P();
-        rtval = analyze_S2();
-        rtval = analyze_S1();
+static void analyze_S1() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
+    if (tokenType == SECTION) {
+        analyze_H1();
+        analyze_P();
+        analyze_S2();
+        analyze_S1();
     } else if (tokenType != FIN) {
-        rtval = false;
-    } else {
-        rtval = false;
+        fprintf(stderr, "%s follows error on %s\n", __func__, tokenTypestr[tokenType]);
+        fflush(stderr);
+        exit(EXIT_FAILURE);
     }
-    return rtval;
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-static bool analyze_BODY() {
-    bool rtval = true;
-    rtval = analyze_P();
-    rtval = analyze_S1();
-    return rtval;
+static void analyze_BODY() {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
+    analyze_P();
+    analyze_S1();
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
 }
 
-bool analyze_AXIOME() {
-    bool rtval = true;
-    scanner();
-    rtval = analyze_HEAD();
-    rtval = analyze_BODY();
+void analyze_AXIOME(void) {
+    #if DEBUG
+    fprintf(stdout, "entering %s\n", __func__);
+    #endif
+    /* print the lexical analysis result */
+    #if PRINT_TOKEN
+    wprint_ctoken(stdout);
+    #endif /* PRINT_TOKEN */
+    if (target != NULL) {
+        fputws(L"<head>\n", target);
+    }
+    analyze_HEAD();
+    if (target != NULL) {
+        fputws(L"\n</head>\n", target);
+    }
+    if (target != NULL) {
+        fputws(L"<body>\n", target);
+    }
+    analyze_BODY();
+    if (target != NULL) {
+        fputws(L"\n<body>\n", target);
+    }
+    #if PRINT_TOKEN
+    wprint_ctoken(stdout);
+    #endif /* PRINT_TOKEN */
     if (tokenType != FIN) {
-        rtval = false;
+        fprintf(stderr, "%s follows error on %s\n", __func__, tokenTypestr[tokenType]);
+        fflush(stderr);
+        exit(EXIT_FAILURE);
     }
-    return rtval;
+    fprintf(stdout, "successful syntactic analysis\n");
+    #if DEBUG
+    fprintf(stdout, "leaving %s\n", __func__);
+    #endif
+    fflush(stdout);
 }
HUGo Polytech'Marseille TP Automata and Langages