Reimplementable calls now being generated

Author: tiagolascasas

.gitignore

@@ -142,3 +142,7 @@ vitis-examples/async-static-multiple/async-static-multiple_vadd/vadd/
 build/
 
 tools/header-to-json/woven_code/
+
+tools/json-to-c/output/
+
+tools/json-to-c/woven_code/

tools/json-to-c/src/Entrypoint.ts

@@ -3,6 +3,6 @@ import Io from "@specs-feup/lara/api/lara/Io.js";
 
 const json = Io.readJson("../intermediate-data/all_signatures.json");
 
-const converter = new JsonToCConverter("hls_");
+const converter = new JsonToCConverter();
 const success = converter.convert(json);
 console.log(success ? "Conversion successful" : "Conversion failed");

tools/json-to-c/src/JsonToCConverter.ts

@@ -1,17 +1,15 @@
 import Clava from "@specs-feup/clava/api/clava/Clava.js";
 import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
-import { SynthesizableHandler } from "./SignatureTypeHandlers.js";
+import { ReimplementableHandler, SynthesizableHandler } from "./SignatureTypeHandlers.js";
 
 export class JsonToCConverter {
-    private prefix: string;
-
-    constructor(prefix: string = '') {
-        this.prefix = prefix;
+    constructor() {
         Clava.pushAst(ClavaJoinPoints.program());
     }
 
     public convert(json: Record<string, any>): boolean {
         const synthHandler = new SynthesizableHandler();
+        const reimpHandler = new ReimplementableHandler();
 
         for (const [key, value] of Object.entries(json)) {
             const type = value["type"];
@@ -21,6 +19,9 @@ export class JsonToCConverter {
             if (type == "synthesizable") {
                 synthHandler.handle(value);
             }
+            if (type == "reimplementable") {
+                reimpHandler.handle(value);
+            }
         }
         Clava.writeCode("output");
         return true;

tools/json-to-c/src/SignatureTypeHandlers.ts

@@ -61,21 +61,39 @@ abstract class AHandler {
         return newFun;
     }
 
+    protected abstract buildFunctionImpl(signature: Record<string, any>, newSig: FunctionJp): FunctionJp;
+}
+
+export class SynthesizableHandler extends AHandler {
+    constructor() {
+        super("hls-libc-synthesizable");
+    }
+
     protected buildFunctionImpl(signature: Record<string, any>, newSig: FunctionJp): FunctionJp {
         const newFun = newSig.copy() as FunctionJp;
 
         const args = newFun.params.map(param => param.varref());
         const call = ClavaJoinPoints.callFromName(signature["name"], newFun.returnType, ...args);
         const retExpr = ClavaJoinPoints.returnStmt(call);
-        const scope = ClavaJoinPoints.scope(retExpr);
 
+        const scope = ClavaJoinPoints.scope(retExpr);
         newFun.setBody(scope);
         return newFun;
     }
 }
 
-export class SynthesizableHandler extends AHandler {
+export class ReimplementableHandler extends AHandler {
     constructor() {
-        super("hls-libc-synthesizable");
+        super("hls-libc-reimplemented");
+    }
+
+    protected buildFunctionImpl(signature: Record<string, any>, newSig: FunctionJp): FunctionJp {
+        const newFun = newSig.copy() as FunctionJp;
+
+        const comment = ClavaJoinPoints.comment("TODO: Implement this function");
+
+        const scope = ClavaJoinPoints.scope(comment);
+        newFun.setBody(scope);
+        return newFun;
     }
 }