Added Cfront mode, an educational C++ to C transformation.

Author: andreasfertig

Diff for: ASTHelpers.cpp

@@ -0,0 +1,150 @@
+/******************************************************************************
+ *
+ * C++ Insights, copyright (C) by Andreas Fertig
+ * Distributed under an MIT license. See LICENSE for details
+ *
+ ****************************************************************************/
+
+#ifndef INSIGHTS_AST_HELPERS_H
+#define INSIGHTS_AST_HELPERS_H
+//-----------------------------------------------------------------------------
+
+#include <array>
+#include <span>
+#include <string_view>
+#include <vector>
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ExprCXX.h"
+#include "llvm/ADT/SmallVector.h"
+
+#include "InsightsStrongTypes.h"
+//-----------------------------------------------------------------------------
+
+namespace clang::insights::asthelpers {
+void ReplaceNode(Stmt* parent, Stmt* oldNode, Stmt* newNode);
+
+using params_vector = std::vector<std::pair<std::string_view, QualType>>;
+using params_store  = std::vector<std::pair<std::string, QualType>>;
+
+params_vector to_params_view(params_store& params);
+
+QualType GetRecordDeclType(const CXXMethodDecl* md);
+QualType GetRecordDeclType(const RecordDecl* rd);
+
+DeclRefExpr* mkVarDeclRefExpr(std::string_view name, QualType type);
+
+STRONG_BOOL(DoCast);
+STRONG_BOOL(AsReference);
+
+CallExpr* CallConstructor(QualType         ctorType,
+                          QualType         lhsType,
+                          const FieldDecl* fieldDecl,
+                          ArrayRef<Expr*>  callParams,
+                          DoCast           doCast      = DoCast::No,
+                          AsReference      asReference = AsReference::No);
+
+CallExpr* CallConstructor(QualType        ctorType,
+                          const VarDecl*  fieldDecl,
+                          ArrayRef<Expr*> callParams,
+                          DoCast          doCast      = DoCast::No,
+                          AsReference     asReference = AsReference::No);
+
+CXXBoolLiteralExpr* Bool(bool b);
+CallExpr*           CallDestructor(const VarDecl* fieldDecl);
+CXXNewExpr*         New(ArrayRef<Expr*> placementArgs, const Expr* expr, QualType t);
+BinaryOperator*     Mul(Expr* lhs, Expr* rhs);
+QualType            Typedef(std::string_view name, QualType underlayingType);
+
+SmallVector<Expr*, 5> ArgsToExprVector(const Expr* expr);
+
+///! A helper type to have a container for ArrayRef
+struct StmtsContainer
+{
+    SmallVector<Stmt*, 64> mStmts{};
+
+    StmtsContainer() = default;
+    StmtsContainer(std::initializer_list<const Stmt*> stmts)
+    {
+        for(const auto& stmt : stmts) {
+            Add(stmt);
+        }
+    }
+
+    void clear() { mStmts.clear(); }
+
+    void Add(const Stmt* stmt)
+    {
+        if(stmt) {
+            mStmts.push_back(const_cast<Stmt*>(stmt));
+        }
+    }
+
+    void AddBodyStmts(Stmt* body);
+
+    operator ArrayRef<Stmt*>() { return mStmts; }
+};
+//-----------------------------------------------------------------------------
+
+template<typename... Dcls>
+DeclStmt* mkDeclStmt(Dcls... dcls)
+{
+    std::array<Decl*, sizeof...(dcls)> decls{dcls...};
+
+    DeclStmt* _mkDeclStmt(std::span<Decl*> decls);
+    return _mkDeclStmt(decls);
+}
+
+Stmt*          Comment(std::string_view comment);
+VarDecl*       Variable(std::string_view name, QualType type, DeclContext* dc = nullptr);
+CXXRecordDecl* Struct(std::string_view name);
+ReturnStmt*    Return(Expr* stmt = nullptr);
+ReturnStmt*    Return(const ValueDecl* stmt);
+
+CompoundStmt* mkCompoundStmt(ArrayRef<Stmt*> bodyStmts, SourceLocation beginLoc = {}, SourceLocation endLoc = {});
+DeclRefExpr*  mkDeclRefExpr(const ValueDecl* vd);
+NullStmt*     mkNullStmt();
+FieldDecl*    mkFieldDecl(DeclContext* dc, std::string_view name, QualType type);
+
+ArraySubscriptExpr*       ArraySubscript(const Expr* lhs, uint64_t index, QualType type);
+MemberExpr*               AccessMember(const Expr* expr, const ValueDecl* vd, bool isArrow = true);
+CXXMemberCallExpr*        CallMemberFun(Expr* memExpr, QualType retType);
+ImplicitCastExpr*         CastLToRValue(const VarDecl* vd);
+FunctionDecl*             Function(std::string_view name, QualType returnType, const params_vector& parameters);
+ParmVarDecl*              Parameter(const FunctionDecl* fd, std::string_view name, QualType type);
+BinaryOperator*           Assign(DeclRefExpr* declRef, ValueDecl* field, Expr* assignExpr);
+BinaryOperator*           Assign(MemberExpr* me, ValueDecl* field, Expr* assignExpr);
+BinaryOperator*           Assign(DeclRefExpr* declRef, Expr* assignExpr);
+BinaryOperator*           Assign(const VarDecl* var, Expr* assignExpr);
+BinaryOperator*           Assign(UnaryOperator* var, Expr* assignExpr);
+BinaryOperator*           Assign(Expr* var, Expr* assignExpr);
+BinaryOperator*           Equal(Expr* var, Expr* assignExpr);
+CXXStaticCastExpr*        StaticCast(QualType toType, const Expr* toExpr, bool makePointer = false);
+CXXStaticCastExpr*        CastToVoidFunPtr(std::string_view name);
+CXXStaticCastExpr*        Cast(const Expr* toExpr, QualType toType);
+IntegerLiteral*           Int32(uint64_t value);
+IfStmt*                   If(const Expr* condition, ArrayRef<Stmt*> bodyStmts);
+SwitchStmt*               Switch(Expr* stmt);
+CaseStmt*                 Case(int value, Stmt* stmt);
+BreakStmt*                Break();
+LabelStmt*                Label(std::string_view name);
+GotoStmt*                 Goto(std::string_view labelName);
+UnaryOperator*            Not(const Expr* stmt);
+UnaryOperator*            Not(const VarDecl* stmt);
+UnaryOperator*            Ref(const Expr* e);
+UnaryOperator*            Ref(const ValueDecl* d);
+UnaryOperator*            Dref(const Expr* stmt);
+UnaryOperator*            AddrOf(const Expr* stmt);
+CallExpr*                 Call(const FunctionDecl* fd, ArrayRef<Expr*> params);
+CallExpr*                 Call(std::string_view name, ArrayRef<Expr*> args);
+CXXTryStmt*               Try(const Stmt* tryBody, CXXCatchStmt* catchAllBody);
+CXXCatchStmt*             Catch(Stmt* body);
+CXXCatchStmt*             Catch(ArrayRef<Stmt*> body);
+CXXThrowExpr*             Throw(const Expr* expr = nullptr);
+UnaryExprOrTypeTraitExpr* Sizeof(QualType toType);
+QualType                  Ptr(QualType srcType);
+CanQualType               VoidTy();
+
+}  // namespace clang::insights::asthelpers
+
+#endif /* INSIGHTS_AST_HELPERS_H */

Diff for: ASTHelpers.h

@@ -496,14 +496,17 @@ endif()
 
 # name the executable and all source files
 add_clang_tool(insights
+    ASTHelpers.cpp
     CodeGenerator.cpp
+    CfrontCodeGenerator.cpp
     CoroutinesCodeGenerator.cpp
     DPrint.cpp
     FunctionDeclHandler.cpp
     GlobalVariableHandler.cpp
     Insights.cpp
     InsightsBase.cpp
     InsightsHelpers.cpp
+    LifetimeTracker.cpp
     OutputFormatHelper.cpp
     RecordDeclHandler.cpp
     TemplateHandler.cpp