jformat-toc.hpp

/* Copyright 2025 Jonathan S. Arney
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      https://github.com/jarney/gyoji/blob/master/LICENSE
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
#pragma once
 
#include "jbackend.hpp"
 
 
namespace Gyoji::backend::toc {
    
    class Statement {
    };
    
    enum TypeType {
    TYPE_PRIMITIVE,
    TYPE_STRUCT,
    TYPE_POINTER
    };
    
    class Type;
    
    class LValue {
    public:
    int id;
    std::shared_ptr<Type> type;
    };
    
    class RValue {
    int id;
    std::shared_ptr<Type> type;
    };
    
    class Member {
    public:
    std::string name;
    std::shared_ptr<Type> type;
    };
    
    class Type {
    public:
    TypeType type;
    std::string primitive;        // PRIMITIVE TYPES
    std::list<std::shared_ptr<Member>> members;    // Member variables.
    std::shared_ptr<Type> target; // Target type of the pointer.
    };
    
// Expressions propagate types
// binary operations must all be same type.
// & operator adds an indirection to a type.
// * removes an indirection from a type.
// Functions have return types.
// Arithmetic is banned except for primitive types.
    class Expression {
    public:
    std::shared_ptr<Type> type;
    };
    
    class StatementDeclaration : public Statement {
    public:
    std::string variable_name;
    std::shared_ptr<Type> type; // Type of variable being declared.
    };
    
    class StatementAssignment : public Statement {
    public:
    std::shared_ptr<LValue> lvalue; // Target of declaration
    std::shared_ptr<Expression> rvalue; // Expression to assign value to.
    };
    
    class FunctionBody {
    public:
    std::list<Statement> statements;
    };
    
    class FunctionArgument {
    public:
    std::shared_ptr<Type> type;
    std::string name;
    };
    
// This is the definition
// of a function.
    class Function {
    public:
    std::shared_ptr<Type> return_type;
    std::string name;
    std::list<std::shared_ptr<FunctionArgument>> arguments;
    std::shared_ptr<FunctionBody> body;
    };
    
    class FunctionTable {
    public:
    std::list<std::shared_ptr<Function>> functions;
    };
    
    class TypeTable {
    public:
    std::map<std::string, std::shared_ptr<Type>> typedefs;
    };
    
    class JBackendToC : public JBackend {
    public:
    JBackendToC();
    ~JBackendToC();
    virtual int process(ASTNode::ptr file);
    
    std::string collect_comments(ASTNode::ptr node);
    std::string break_multiline_comment(std::string str);
    
    //  void print_whitespace(ASTDataNonSyntax::ptr node);
    //  void print_comments(std::vector<ASTDataNonSyntax::ptr> &non_syntax_list);
    //  void print_comment_single_line(ASTDataNonSyntax::ptr node);
    //  void print_comment_multi_line(ASTDataNonSyntax::ptr node);
    //  void print_file_metadata(ASTDataNonSyntax::ptr node);
    //  void print_non_syntax(ASTDataNonSyntax::ptr node);
    
    //  void print_node_generic(ASTNode::ptr node);
    //  void print_node_plain(ASTNode::ptr node);
    void print_scope_body(ASTNode::ptr node);
    void newline();
    void print_typedef(ASTNode::ptr node);
    void print_import(ASTNode::ptr node);
    void print_node_function_definition(ASTNode::ptr node);
    
    void process_definition(ASTNode::ptr node);
    
    void dump_types();
    void dump_functions();
    
    int indent_level;
    int depth;
    
    FunctionTable function_table;
    TypeTable type_table;
    };
    
};