(feature) Add support for thunked ifs.

Author: LittleHelicase

.vscode/launch.json

@@ -22,11 +22,12 @@
     },
     {
       "name": "Debug",
-      "type": "node2",
+      "type": "node",
       "request": "launch",
+      "protocol": "inspector",
       "program": "${workspaceRoot}/.vscode/debug.js",
       "cwd": "${workspaceRoot}",
-      "args": ["print.json", "-l", "languages/c", "-l", "languages/c-like"],
+      "args": ["if.json", "-l", "languages/c-edge-debugger", "-l", "languages/c", "-l", "languages/c-like"],
       "env": {
         "NODE_ENV": "development"
       },

languages/c-edge-debugger/templates/activation.js

@@ -2,10 +2,13 @@ module.exports = {
   EdgeDebugger: {
     activation: (context) => {
       // only handle edges
-      if (Graph.Edge.isValid(context.data)) {
+      if (context.template === 'Compound.defineEdges') {
         // does not yet work with edge selection
-        return !context.options.selectEdge
+        return true
+        // return typeof (context.data.type) === 'string'
+        // return !context.options || !context.options.selectEdge
       }
+      return true
     }
   }
 }

languages/c-edge-debugger/templates/compound.js

@@ -2,7 +2,11 @@ module.exports = {
   Compound: {
     defineEdges: (node) => {
       const edges = Graph.edges(node)
-      return edges.map((e) => `  debug_shared_ptr<${t('Edge.type')(e)}> ${t('Edge.name')(e)};`).join('\n')
+      return edges.map((e) => {
+        if (typeof (e.type) === 'string') {
+          return `  debug_shared_ptr<${t('Edge.type')(e)}> ${t('Edge.name')(e)};`
+        } else return `  std::shared_ptr<${t('Edge.type')(e)}> ${t('Edge.name')(e)};`
+      }).join('\n')
     }
   }
 }

languages/c-edge-debugger/templates/main.js

@@ -1,8 +1,7 @@
 module.exports = {
-  prefix: (graph) => {
-    const structs = Graph.components(graph).filter(Types.isType).filter(Types.isConstructor)
-    return `${t('base')()}
-
+  defineTypes: (graph) => {
+    // const structs = Graph.components(graph).filter(Types.isType).filter(Types.isConstructor)
+    return `
 template <typename T>
 class debug_shared_ptr : public std::shared_ptr<T> {
 public:
@@ -11,12 +10,14 @@ public:
   debug_shared_ptr(const std::shared_ptr<T>& other);
 };
 
+${t('base')()}
+
+` },
 
-${['String', 'IO'].map(t('defineSpecialization')).join('\n')}
-${structs.map(Types.structureData).map((s) => s.name).map(t('defineSpecialization')).join('\n')}
-`},
+// ${structs.map(Types.structureData).map((s) => s.name).map(t('defineSpecialization')).join('\n')}
+// ${['String', 'IO'].map(t('defineSpecialization')).join('\n')}
 
-    defineSpecialization: (typeName) => `
+  defineSpecialization: (typeName) => `
 template <>
 debug_shared_ptr<${typeName}>::debug_shared_ptr(const std::shared_ptr<${typeName}>& other) : std::shared_ptr<${typeName}>(other) {
   std::cout << "Copy: " << ${t('Types.toStringName')(typeName)}(*other) << std::endl;

languages/c-edge-debugger/templates/types.js

@@ -0,0 +1,11 @@
+module.exports = {
+  Types: {
+    definition: (typeName) => {
+      return `${t('base')(typeName)}
+
+  ${t('defineSpecialization')(typeName)}
+
+`
+    }
+  }
+}

languages/c-like/templates/main.js

@@ -8,7 +8,7 @@ module.exports = {
 ${t('prefix')(graph)}
 
 // atomics
-${uniqBy(componentName, atomics).map(t('Process.definition')).join('\n')}
+${uniqBy(t('Component.name'), atomics).map(t('Process.definition')).join('\n')}
 
 // compounds...
 ${compounds.map(t('Compound.definition')).join('\n')}

languages/c/atomics/basic.js

@@ -7,4 +7,12 @@ module.exports = {
   numToStr: (node) => `
   ${variable('outStr')} = std::shared_ptr<String>(new String(${t('Types.toStringName')('Number')}(*${variable('inNumber')})));
 `,
+
+  ifThunk: (node) => `
+  if (${variable('condition')}->value) {
+    (*${variable('inTrue')})(${variable('choice')});
+  } else {
+    (*${variable('inFalse')})(${variable('choice')});
+  }
+`
 }

languages/c/atomics/math.js

@@ -2,4 +2,8 @@ module.exports = {
   'math/add': (node) => `
   ${variable('sum')} = std::shared_ptr<Number>(new Number(${variable('summand1')}->value + ${variable('summand2')}->value));
 `,
+
+  'math/less': (node) => `
+  ${variable('isLess')} = std::shared_ptr<Bool>(new Bool(${variable('lesser')}->value < ${variable('bigger')}->value));
+`
 }

languages/c/templates/component.js

@@ -0,0 +1,11 @@
+module.exports = {
+  Component: {
+    name: (node) => {
+      if (node.componentId === 'functional/lambda') {
+        return t('base')(node) + sanitize(Node.id(Graph.Lambda.implementation(node)))
+      } else {
+        return t('base')(node)
+      }
+    }
+  }
+}

languages/c/templates/compound.js

@@ -27,7 +27,7 @@ ${t('Compound.assignInputs')(node)}
     assignInputs: (node) => {
       const inputPorts = Node.inputPorts(node).map((port) =>
         ({port, edges: Graph.outIncidents(port, graph)}))
-      return `${inputPorts.map((p) => p.edges.map((e) => '  ' + t('Compound.edgeAssign')(e)(`input_${p.port.port}`))).join('\n')}`
+      return `${inputPorts.map((p) => p.edges.map((e) => '  ' + t('Compound.edgeAssign')(e)(`input_${sanitize(p.port.port)}`))).join('\n')}`
     },
 
     edgeAssign: (edge) => (variable) => `${t('Edge.name')(edge)} = ${variable};`,
@@ -47,7 +47,7 @@ ${t('Compound.postfix')(node)}`
       const outputArguments = Node.outputPorts(node).map(t('Port.variable'))
       const functionArguments = inputArguments.concat(outputArguments).join(', ')
 
-      const functionCall = `P_${componentName(node)}(${functionArguments});`
+      const functionCall = `P_${t('Component.name')(node)}(${functionArguments});`
 
       const edgeAssignments = Graph.outIncidents(node, graph).map((edge) =>
         `    ${t('Edge.name')(edge)} = ${t('Port.variable')(edge.from)};`).join('\n')
@@ -61,7 +61,7 @@ ${edgeAssignments}
 
     postfix: (node) => {
       return Node.outputPorts(node).map((p) =>
-        `  output_${p.port} = ${t('Edge.name')(Graph.inIncident(p, graph))};`).join('\n')
+        `  output_${sanitize(p.port)} = ${t('Edge.name')(Graph.inIncident(p, graph))};`).join('\n')
     },
   },
 }