auto-gen the C code

src/Layout.c

@@ -317,7 +317,7 @@ void layoutNode(css_node_t *node) {
   float mainContentDim = 0;
   unsigned int flexibleChildrenCount = 0;
   for (unsigned int i = 0; i < node->children_count; ++i) {
-    css_node_t *child = node->children[i];
+    css_node_t* child = node->children[i];
     if (isUndefined(node->layout.dimensions[dim[mainAxis]]) || !getFlex(child)) {
       layoutNode(child);
       mainContentDim += getDimWithMargin(child, mainAxis);
@@ -337,7 +337,7 @@ void layoutNode(css_node_t *node) {
     if (flexibleChildrenCount) {
       float flexibleMainDim = remainingMainDim / flexibleChildrenCount;
       for (unsigned int i = 0; i < node->children_count; ++i) {
-        css_node_t *child = node->children[i];
+        css_node_t* child = node->children[i];
         if (getFlex(child)) {
           child->layout.dimensions[dim[mainAxis]] = flexibleMainDim;
           layoutNode(child);
@@ -347,10 +347,10 @@ void layoutNode(css_node_t *node) {
       css_justify_t justifyContent = getJustifyContent(node);
       if (justifyContent == CSS_JUSTIFY_FLEX_START) {
         // Do nothing
-      } else if (justifyContent == CSS_JUSTIFY_FLEX_END) {
-        leadingMainDim = remainingMainDim;
       } else if (justifyContent == CSS_JUSTIFY_CENTER) {
         leadingMainDim = remainingMainDim / 2;
+      } else if (justifyContent == CSS_JUSTIFY_FLEX_END) {
+        leadingMainDim = remainingMainDim;
       } else if (justifyContent == CSS_JUSTIFY_SPACE_BETWEEN) {
         betweenMainDim = remainingMainDim / (node->children_count - 1);
       } else if (justifyContent == CSS_JUSTIFY_SPACE_AROUND) {
@@ -363,7 +363,7 @@ void layoutNode(css_node_t *node) {
   float crossDim = 0;
   float mainPos = getPadding(node, leading[mainAxis]) + leadingMainDim;
   for (unsigned int i = 0; i < node->children_count; ++i) {
-    css_node_t *child = node->children[i];
+    css_node_t* child = node->children[i];
     child->layout.position[pos[mainAxis]] += mainPos;
     mainPos += getDimWithMargin(child, mainAxis) + betweenMainDim;
 
@@ -379,14 +379,14 @@ void layoutNode(css_node_t *node) {
     getPadding(node, trailing[crossAxis]);
 
   if (isUndefined(node->layout.dimensions[dim[mainAxis]]) && !mainDimInStyle) {
-    node->layout.dimensions[dim[mainAxis]] = fmaxf(mainPos, 0);
+    node->layout.dimensions[dim[mainAxis]] = mainPos > 0 ? mainPos : 0;
   }
   if (isUndefined(node->layout.dimensions[dim[crossAxis]])) {
-    node->layout.dimensions[dim[crossAxis]] = fmaxf(crossDim, 0);
+    node->layout.dimensions[dim[crossAxis]] = crossDim > 0 ? crossDim : 0;
   }
 
   for (unsigned int i = 0; i < node->children_count; ++i) {
-    css_node_t *child = node->children[i];
+    css_node_t* child = node->children[i];
     css_align_t alignItem = getAlignItem(node, child);
     float remainingCrossDim = node->layout.dimensions[dim[crossAxis]] -
       getDimWithMargin(child, crossAxis) -

src/Layout.js

@@ -8,6 +8,9 @@ function computeLayout(node) {
       top: 0,
       left: 0
     };
+    if (!node.style) {
+      node.style = {};
+    }
     if (!node.children) {
       node.children = [];
     }
@@ -140,53 +143,53 @@ function computeLayout(node) {
   var CSS_ALIGN_FLEX_END = 'flex-end';
   var CSS_ALIGN_STRETCH = 'stretch';
 
-  function layoutNode(node) {
+function layoutNode(node) {
-    var mainAxis = getFlexDirection(node);
+  var/*css_flex_direction_t*/ mainAxis = getFlexDirection(node);
-    var crossAxis = mainAxis == CSS_FLEX_DIRECTION_ROW ?
+  var/*css_flex_direction_t*/ crossAxis = mainAxis == CSS_FLEX_DIRECTION_ROW ?
     CSS_FLEX_DIRECTION_COLUMN :
     CSS_FLEX_DIRECTION_ROW;
 
-    var mainDimInStyle = isDimDefined(node, mainAxis);
+  var/*bool*/ mainDimInStyle = isDimDefined(node, mainAxis);
   if (isUndefined(node.layout[dim[mainAxis]]) && mainDimInStyle) {
     node.layout[dim[mainAxis]] = node.style[dim[mainAxis]];
   }
 
-    var crossDimInStyle = isDimDefined(node, crossAxis);
+  var/*bool*/ crossDimInStyle = isDimDefined(node, crossAxis);
   if (isUndefined(node.layout[dim[crossAxis]]) && crossDimInStyle) {
     node.layout[dim[crossAxis]] = node.style[dim[crossAxis]];
   }
 
-    var mainContentDim = 0;
+  var/*float*/ mainContentDim = 0;
-    var flexibleChildrenCount = 0;
+  var/*unsigned int*/ flexibleChildrenCount = 0;
-    for (var i = 0; i < node.children.length; ++i) {
+  for (var/*unsigned int*/ i = 0; i < node.children.length; ++i) {
-      var child = node.children[i];
+    var/*css_node_t**/ child = node.children[i];
     if (isUndefined(node.layout[dim[mainAxis]]) || !getFlex(child)) {
       layoutNode(child);
       mainContentDim += getDimWithMargin(child, mainAxis);
     } else {
       flexibleChildrenCount++;
     }
-    };
+  }
 
-    var leadingMainDim = 0;
+  var/*float*/ leadingMainDim = 0;
-    var betweenMainDim = 0;
+  var/*float*/ betweenMainDim = 0;
   if (!isUndefined(node.layout[dim[mainAxis]])) {
-      var remainingMainDim = node.layout[dim[mainAxis]] -
+    var/*float*/ remainingMainDim = node.layout[dim[mainAxis]] -
       getPadding(node, leading[mainAxis]) -
       getPadding(node, trailing[mainAxis]) -
       mainContentDim;
 
     if (flexibleChildrenCount) {
-        var flexibleMainDim = remainingMainDim / flexibleChildrenCount;
+      var/*float*/ flexibleMainDim = remainingMainDim / flexibleChildrenCount;
-        for (var i = 0; i < node.children.length; ++i) {
+      for (var/*unsigned int*/ i = 0; i < node.children.length; ++i) {
-          var child = node.children[i];
+        var/*css_node_t**/ child = node.children[i];
         if (getFlex(child)) {
           child.layout[dim[mainAxis]] = flexibleMainDim;
           layoutNode(child);
         }
       }
     } else {
-        var justifyContent = getJustifyContent(node);
+      var/*css_justify_t*/ justifyContent = getJustifyContent(node);
       if (justifyContent == CSS_JUSTIFY_FLEX_START) {
         // Do nothing
       } else if (justifyContent == CSS_JUSTIFY_CENTER) {
@@ -202,15 +205,15 @@ function computeLayout(node) {
     }
   }
 
-    var crossDim = 0;
+  var/*float*/ crossDim = 0;
-    var mainPos = getPadding(node, leading[mainAxis]) + leadingMainDim;
+  var/*float*/ mainPos = getPadding(node, leading[mainAxis]) + leadingMainDim;
-    for (var i = 0; i < node.children.length; ++i) {
+  for (var/*unsigned int*/ i = 0; i < node.children.length; ++i) {
-      var child = node.children[i];
+    var/*css_node_t**/ child = node.children[i];
     child.layout[pos[mainAxis]] += mainPos;
     mainPos += getDimWithMargin(child, mainAxis) + betweenMainDim;
 
     if (!isUndefined(child.layout[dim[crossAxis]])) {
-        var childCrossDim = getDimWithMargin(child, crossAxis);
+      var/*float*/ childCrossDim = getDimWithMargin(child, crossAxis);
       if (childCrossDim > crossDim) {
         crossDim = childCrossDim;
       }
@@ -227,15 +230,15 @@ function computeLayout(node) {
     node.layout[dim[crossAxis]] = crossDim > 0 ? crossDim : 0;
   }
 
-    for (var i = 0; i < node.children.length; ++i) {
+  for (var/*unsigned int*/ i = 0; i < node.children.length; ++i) {
-      var child = node.children[i];
+    var/*css_node_t**/ child = node.children[i];
-      var alignItem = getAlignItem(node, child);
+    var/*css_align_t*/ alignItem = getAlignItem(node, child);
-      var remainingCrossDim = node.layout[dim[crossAxis]] -
+    var/*float*/ remainingCrossDim = node.layout[dim[crossAxis]] -
       getDimWithMargin(child, crossAxis) -
       getPadding(node, leading[crossAxis]) -
       getPadding(node, trailing[crossAxis]);
 
-      var leadingCrossDim = getPadding(node, leading[crossAxis]);
+    var/*float*/ leadingCrossDim = getPadding(node, leading[crossAxis]);
     if (alignItem == CSS_ALIGN_FLEX_START) {
       // Do nothing
     } else if (alignItem == CSS_ALIGN_CENTER) {
@@ -256,11 +259,22 @@ function computeLayout(node) {
     getRelativePosition(node, mainAxis);
   node.layout[leading[crossAxis]] += getMargin(node, leading[crossAxis]) +
     getRelativePosition(node, crossAxis);
-  }
+}
+
+  var c_code = layoutNode.toString()
+    .replace(/\.children\.length/g, '.children_count')
+    .replace(/layout\[dim/g, 'layout.dimensions[dim')
+    .replace(/layout\[pos/g, 'layout.position[pos')
+    .replace(/layout\[leading/g, 'layout.position[leading')
+    .replace(/style\[dim/g, 'style.dimensions[dim')
+    .replace(/node\./g, 'node->')
+    .replace(/child\./g, 'child->')
+    .replace(/var\/\*([^\/]+)\*\//g, '$1');
+  console.log(c_code);
 
   fillNodes(node);
-
   layoutNode(node);
   return extractNodes(node);
 }
 
+computeLayout({});