format option

Author: thradams

manual.md

@@ -14,6 +14,8 @@ Options
   -target=standard Output target C standard (c99, c11, c2x, cxx).
   -std=standard    Assume that the input sources are for standard (c99, c11, c2x, cxx).
   -n               Check naming conventions (it is hardcoded for it own naming convention)
+  -fi              Format input (format before language convertion)
+  -fo              Format output (format after language convertion, result parsed again)
 ```
 The ouput dir is `./out`
 

src/Web/cake.js

@@ -102,6 +102,8 @@ <h1 id="toc_0">Command line</h1>
   -target=standard Output target C standard (c99, c11, c2x, cxx).
   -std=standard    Assume that the input sources are for standard (c99, c11, c2x, cxx).
   -n               Check naming conventions (it is hardcoded for it own naming convention)
+  -fi              Format input (format before language convertion)
+  -fo              Format output (format after language convertion, result parsed again)
 </code></pre>
 
 <p>The ouput dir is <code>./out</code></p>

src/Web/manual.html

@@ -25,7 +25,8 @@
  " type.h " \
  " pre_expressions.h " \
  " expressions.h " \
- " visit.h "
+ " visit.h " \
+ " formatvisit.h "
 
 #define SOURCE_FILES \
 " token.c " \
@@ -41,7 +42,8 @@
 " type.c " \
 " parser.c " \
 " visit.c " \
-" error.c " 
+" error.c " \
+" formatvisit.c "
 
 
 void compile_cake()

src/build.c

@@ -1,61 +1,25 @@
 
 
-struct X {
-    int i;
-};
-
-struct Y {
-    double d;
-};
-
-enum E { A = 1 };
-enum E e1;
-struct X* F() { return 0; }
+#include <stdio.h>
 
 int main()
 {
-    enum E { B } E2; 
-    //static_assert(typeid(e2) == typeid(enum E));
-    //static_assert(typeid(e2) != typeid(e1));
-
-    struct X x;
-    struct Y y;
-
-    static_assert(typeid(x) == typeid(struct X));
-    static_assert(typeid(x) != typeid(struct Y));
-
-    static_assert(typeid(int(double)) != typeid(int()));
-    int aa[10];
-
-    static_assert(typeid(*F()) == typeid(struct X));
-    static_assert(typeid(&aa) == typeid(int(*)[10]));
-
-    int* p = 0;
-    static_assert(typeid(*(p + 1)) == typeid(int));
-    
-    static_assert(1 == typeid(int));
-
-    static_assert(typeid(main) == typeid(int()));
-    
-    
-    static_assert(typeid(main) != typeid(int(double)));
-    static_assert(typeid(main) != typeid(int));
-
-
-    struct X x;
-    enum E e;
-    static_assert(typeid(e) == typeid(enum E));
-    static_assert(typeid(x) == typeid(struct X));
-    static_assert(typeid(e) != typeid(struct X));
-
-    
-        
-    static_assert(1L == typeid(long));
-    static_assert(1UL == typeid(unsigned long));
-    static_assert(1ULL == typeid(unsigned long long));
-    static_assert(A == typeid(int));
-    static_assert(1.0 == typeid(double));
-    static_assert(1.0f == typeid(float));
-    static_assert(1.0L == typeid(long double));
-  
+
+    do
+    {
+        FILE* f = fopen("in.txt", "r");
+        if (f == NULL) break;
+        defer fclose(f);
+
+        FILE* f2 = fopen("out.txt", "w");
+        if (f2 == NULL) break;
+        defer fclose(f2);
+
+        //...
+
+       /*success here*/
+    } while (0);
+
+
 }
+

src/file.c

@@ -0,0 +1,280 @@
+#include "formatvisit.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+void ajust_line_and_identation(struct token* token, struct format_visit_ctx* ctx)
+{
+    /*
+    * Before this token we must have a identation and before identation a new line.
+    * If we don't have it we need to insert.
+    */
+
+    if (token && token->level == 0)
+    {
+        struct token* previous_token = token->prev;
+        if (previous_token)
+        {
+            if (previous_token->type == TK_BLANKS)
+            {
+                char blanks[50] = {0};
+                if (ctx->identation > 0)
+                  snprintf(blanks, sizeof blanks, "%*c", (ctx->identation * 4), ' ');
+                
+                /*only adjust the number of spaces*/
+                free(previous_token->lexeme);
+                previous_token->lexeme = strdup(blanks);
+
+                struct token* previous_previous_token =
+                    previous_token->prev;
+
+                if (previous_previous_token->type != TK_NEWLINE)
+                {
+                    struct error error = { 0 };
+                    struct token_list list = tokenizer("\n", NULL, 0, TK_FLAG_NONE, &error);
+                    token_list_insert_after(&ctx->ast.token_list, previous_previous_token, &list);                    
+                }                
+            }
+            else if (previous_token->type != TK_NEWLINE)
+            {
+                char blanks[50];
+                if (ctx->identation > 0)
+                {
+                    snprintf(blanks, sizeof blanks, "\n%*c", (ctx->identation * 4), ' ');
+                }
+                else
+                {
+                    snprintf(blanks, sizeof blanks, "\n");
+                }
+
+                struct error error = { 0 };
+                struct token_list list = tokenizer(blanks, NULL, 0, TK_FLAG_NONE, &error);
+                token_list_insert_after(&ctx->ast.token_list, previous_token, &list);
+            }
+        }
+    }
+}
+
+static void format_visit_unlabeled_statement(struct format_visit_ctx* ctx, struct unlabeled_statement* p_unlabeled_statement, struct error* error);
+
+static void format_visit_statement(struct format_visit_ctx* ctx, struct statement* p_statement, struct error* error)
+{
+    if (p_statement->labeled_statement)
+    {
+        //format_visit_labeled_statement(ctx, p_statement->labeled_statement, error);
+    }
+    else if (p_statement->unlabeled_statement)
+    {
+        format_visit_unlabeled_statement(ctx, p_statement->unlabeled_statement, error);
+    }
+}
+
+
+
+static void format_visit_selection_statement(struct format_visit_ctx* ctx, struct selection_statement* p_selection_statement, struct error* error)
+{
+    if (p_selection_statement->secondary_block)
+    {
+
+        ajust_line_and_identation(p_selection_statement->secondary_block->first, ctx);
+
+        if (p_selection_statement->secondary_block &&
+            p_selection_statement->secondary_block->statement &&
+            p_selection_statement->secondary_block->statement->unlabeled_statement &&
+            p_selection_statement->secondary_block->statement->unlabeled_statement->primary_block &&
+            p_selection_statement->secondary_block->statement->unlabeled_statement->primary_block->compound_statement)
+        {
+            format_visit_statement(ctx, p_selection_statement->secondary_block->statement, error);
+        }
+        else
+        {
+            ctx->identation++;
+            //ajust_line_and_identation(p_selection_statement->secondary_block->first, ctx);
+
+            format_visit_statement(ctx, p_selection_statement->secondary_block->statement, error);
+            ctx->identation--;
+        }
+
+
+        //ajust_line_and_identation(p_selection_statement->secondary_block->last, ctx);
+    }
+
+}
+
+static void format_visit_jump_statement(struct format_visit_ctx* ctx, struct jump_statement* p_jump_statement, struct error* error)
+{
+
+
+
+    if (p_jump_statement->token->type == TK_KEYWORD_THROW ||
+        p_jump_statement->token->type == TK_KEYWORD_RETURN ||
+        p_jump_statement->token->type == TK_KEYWORD_BREAK ||
+        p_jump_statement->token->type == TK_KEYWORD_CONTINUE ||
+        p_jump_statement->token->type == TK_KEYWORD_GOTO)
+    {
+        ajust_line_and_identation(p_jump_statement->token, ctx);
+    }
+    else
+    {
+        assert(false);
+    }
+}
+
+static void format_visit_compound_statement(struct format_visit_ctx* ctx, struct compound_statement* p_compound_statement, struct error* error);
+
+
+static void format_visit_secondary_block(struct format_visit_ctx* ctx, struct secondary_block* p_secondary_block, struct error* error)
+{
+    format_visit_statement(ctx, p_secondary_block->statement, error);
+}
+
+static void format_visit_iteration_statement(struct format_visit_ctx* ctx, struct iteration_statement* p_iteration_statement, struct error* error)
+{
+
+    if (p_iteration_statement->expression1)
+    {
+        //format_visit_expression(ctx, p_iteration_statement->expression1, error);
+    }
+
+    if (p_iteration_statement->expression2)
+    {
+        //format_visit_expression(ctx, p_iteration_statement->expression2, error);
+    }
+
+    
+
+    if (p_iteration_statement->secondary_block)
+    {
+        format_visit_secondary_block(ctx, p_iteration_statement->secondary_block, error);
+    }
+}
+
+
+
+static void format_visit_primary_block(struct format_visit_ctx* ctx, struct primary_block* p_primary_block, struct error* error)
+{
+    if (p_primary_block->defer_statement)
+    {
+        //visit_defer_statement(ctx, p_primary_block->defer_statement, error);
+    }
+    else
+    {
+        if (p_primary_block->compound_statement)
+        {
+            format_visit_compound_statement(ctx, p_primary_block->compound_statement, error);
+        }
+        else if (p_primary_block->iteration_statement)
+        {
+            format_visit_iteration_statement(ctx, p_primary_block->iteration_statement, error);
+        }
+        else if (p_primary_block->selection_statement)
+        {
+            format_visit_selection_statement(ctx, p_primary_block->selection_statement, error);
+        }
+    }
+
+}
+
+
+static void format_visit_expression_statement(struct format_visit_ctx* ctx, struct expression_statement* p_expression_statement, struct error* error)
+{
+    if (p_expression_statement->expression)
+    {
+        //ajust_line_and_identation(p_expression_statement->first_token, ctx);
+    }
+}
+
+static void format_visit_unlabeled_statement(struct format_visit_ctx* ctx, struct unlabeled_statement* p_unlabeled_statement, struct error* error)
+{
+    if (p_unlabeled_statement->primary_block)
+    {
+        format_visit_primary_block(ctx, p_unlabeled_statement->primary_block, error);
+    }
+    else if (p_unlabeled_statement->expression_statement)
+    {
+        format_visit_expression_statement(ctx, p_unlabeled_statement->expression_statement, error);
+    }
+    else if (p_unlabeled_statement->jump_statement)
+    {
+        format_visit_jump_statement(ctx, p_unlabeled_statement->jump_statement, error);
+    }
+    else
+    {
+        assert(false);
+    }
+}
+
+static void format_visit_block_item(struct format_visit_ctx* ctx, struct block_item* p_block_item, struct error* error)
+{
+    ajust_line_and_identation(p_block_item->first_token, ctx);
+
+    if (p_block_item->declaration)
+    {
+        //visit_declaration(ctx, p_block_item->declaration, error);
+    }
+    else if (p_block_item->unlabeled_statement)
+    {
+        format_visit_unlabeled_statement(ctx, p_block_item->unlabeled_statement, error);
+    }
+    else if (p_block_item->labeled_statement)
+    {
+        //visit_labeled_statement(ctx, p_block_item->labeled_statement, error);
+    }
+}
+
+static void format_visit_block_item_list(struct format_visit_ctx* ctx, struct block_item_list* p_block_item_list, struct error* error)
+{
+    struct block_item* p_block_item = p_block_item_list->head;
+    while (error->code == 0 && p_block_item)
+    {
+        format_visit_block_item(ctx, p_block_item, error);
+        p_block_item = p_block_item->next;
+    }
+}
+
+static void format_visit_compound_statement(struct format_visit_ctx* ctx, struct compound_statement* p_compound_statement, struct error* error)
+{
+    ajust_line_and_identation(p_compound_statement->first, ctx);
+
+    ctx->identation++;
+    format_visit_block_item_list(ctx, &p_compound_statement->block_item_list, error);
+
+    ctx->identation--;
+    
+    ajust_line_and_identation(p_compound_statement->last, ctx);
+}
+
+static void format_visit_declaration(struct format_visit_ctx* ctx, struct declaration* p_declaration, struct error* error)
+{
+    if (p_declaration->static_assert_declaration)
+    {
+        //format_visit_static_assert_declaration(ctx, p_declaration->static_assert_declaration, error);
+    }
+
+    if (p_declaration->declaration_specifiers)
+    {
+        //format_visit_declaration_specifiers(ctx, p_declaration->declaration_specifiers, error);
+
+    }
+
+    if (p_declaration->init_declarator_list.head)
+    {
+        //format_visit_init_declarator_list(ctx, &p_declaration->init_declarator_list, error);
+    }
+
+    if (p_declaration->function_body)
+    {
+        format_visit_compound_statement(ctx, p_declaration->function_body, error);
+    }
+}
+
+void format_visit(struct format_visit_ctx* ctx, struct error* error)
+{
+    struct declaration* p_declaration = ctx->ast.declaration_list.head;
+    while (error->code == 0 && p_declaration)
+    {
+        format_visit_declaration(ctx, p_declaration, error);
+        p_declaration = p_declaration->next;
+    }
+}