DaddyFrosty/yoga
1
0
Fork 0
Code Issues 96 Pull Requests 31 Actions Packages Projects Releases 33 Wiki Activity

-Weverything and fix all the warnings

Browse Source
This commit is contained in:
Christopher Chedeau
2014-05-16 18:04:24 -07:00
parent 0708b5eb75
commit eae5cdfe68
7 changed files with 3365 additions and 3505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -1,4 +1,4 @@
test: test:
@gcc src/__tests__/Layout-test.c src/Layout.c src/Layout-test-utils.c && ./a.out @gcc -Weverything -Werror -Wno-padded src/__tests__/Layout-test.c src/Layout.c src/Layout-test-utils.c && ./a.out
@rm a.out @rm a.out

BIN
lib/jasmine-2.0.0/jasmine_favicon.png Executable file → Normal file
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.0 KiB

After

Width:  |  Height:  |  Size: 1.3 KiB

16
src/Layout-test-utils.c
View File

@@ -1,12 +1,16 @@
#include "Layout-test-utils.h" #include "Layout-test-utils.h"
bool are_layout_equal(css_node_t *a, css_node_t *b) { static bool eq(float a, float b) {
if (a->layout.dimensions[CSS_WIDTH] != b->layout.dimensions[CSS_WIDTH] || return fabs(a - b) < 0.0001;
a->layout.dimensions[CSS_HEIGHT] != b->layout.dimensions[CSS_HEIGHT] || }
a->layout.position[CSS_TOP] != b->layout.position[CSS_TOP] ||
a->layout.position[CSS_LEFT] != b->layout.position[CSS_LEFT] || static bool are_layout_equal(css_node_t *a, css_node_t *b) {
a->children_count != b->children_count) { if (!eq(a->layout.dimensions[CSS_WIDTH], b->layout.dimensions[CSS_WIDTH]) ||
!eq(a->layout.dimensions[CSS_HEIGHT], b->layout.dimensions[CSS_HEIGHT]) ||
!eq(a->layout.position[CSS_TOP], b->layout.position[CSS_TOP]) ||
!eq(a->layout.position[CSS_LEFT], b->layout.position[CSS_LEFT]) ||
!eq(a->children_count, b->children_count)) {
return false; return false;
} }
for (int i = 0; i < a->children_count; ++i) { for (int i = 0; i < a->children_count; ++i) {

78
src/Layout.c
View File

@@ -6,7 +6,11 @@
#include "Layout.h" #include "Layout.h"
void init_css_node(css_node_t *node) { static bool eq(float a, float b) {
return fabs(a - b) < 0.0001;
}
static void init_css_node(css_node_t *node) {
node->style.align_items = CSS_ALIGN_FLEX_START; node->style.align_items = CSS_ALIGN_FLEX_START;
// Some of the fields default to undefined and not 0 // Some of the fields default to undefined and not 0
@@ -29,14 +33,14 @@ css_node_t *new_css_node() {
} }
void init_css_node_children(css_node_t *node, int children_count) { void init_css_node_children(css_node_t *node, int children_count) {
node->children = calloc(children_count, sizeof(css_node_t)); node->children = calloc((unsigned long)children_count, sizeof(css_node_t));
for (int i = 0; i < children_count; ++i) { for (int i = 0; i < children_count; ++i) {
init_css_node(&node->children[i]); init_css_node(&node->children[i]);
} }
node->children_count = children_count; node->children_count = children_count;
} }
void cleanup_css_node(css_node_t *node) { static void cleanup_css_node(css_node_t *node) {
for (int i = 0; i < node->children_count; ++i) { for (int i = 0; i < node->children_count; ++i) {
cleanup_css_node(&node->children[i]); cleanup_css_node(&node->children[i]);
} }
@@ -48,29 +52,29 @@ void free_css_node(css_node_t *node) {
free(node); free(node);
} }
void indent(int n) { static void indent(int n) {
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
printf(" "); printf(" ");
} }
} }
void print_number_0(const char *str, float number) { static void print_number_0(const char *str, float number) {
if (number != 0) { if (!eq(number, 0)) {
printf("%s: %g, ", str, number); printf("%s: %g, ", str, number);
} }
} }
void print_number_nan(const char *str, float number) { static void print_number_nan(const char *str, float number) {
if (!isnan(number)) { if (!isnan(number)) {
printf("%s: %g, ", str, number); printf("%s: %g, ", str, number);
} }
} }
bool four_equal(float four[4]) { static bool four_equal(float four[4]) {
return return
four[0] == four[1] && eq(four[0], four[1]) &&
four[0] == four[2] && eq(four[0], four[2]) &&
four[0] == four[3]; eq(four[0], four[3]);
} }
void print_style(css_node_t *node, int level) { void print_style(css_node_t *node, int level) {
@@ -181,106 +185,106 @@ void print_layout(css_node_t *node, int level) {
int leading[2] = { static css_position_t leading[2] = {
/* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP, /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP,
/* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT /* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT
}; };
int trailing[2] = { static css_position_t trailing[2] = {
/* CSS_FLEX_DIRECTION_COLUMN = */ CSS_BOTTOM, /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_BOTTOM,
/* CSS_FLEX_DIRECTION_ROW = */ CSS_RIGHT /* CSS_FLEX_DIRECTION_ROW = */ CSS_RIGHT
}; };
int pos[2] = { static css_position_t pos[2] = {
/* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP, /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP,
/* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT /* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT
}; };
int dim[2] = { static css_dimension_t dim[2] = {
/* CSS_FLEX_DIRECTION_COLUMN = */ CSS_HEIGHT, /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_HEIGHT,
/* CSS_FLEX_DIRECTION_ROW = */ CSS_WIDTH /* CSS_FLEX_DIRECTION_ROW = */ CSS_WIDTH
}; };
bool isUndefined(float value) { static bool isUndefined(float value) {
return isnan(value); return isnan(value);
} }
float getMargin(css_node_t *node, int location) { static float getMargin(css_node_t *node, int location) {
return node->style.margin[location]; return node->style.margin[location];
} }
float getPadding(css_node_t *node, int location) { static float getPadding(css_node_t *node, int location) {
if (node->style.padding[location] >= 0) { if (node->style.padding[location] >= 0) {
return node->style.padding[location]; return node->style.padding[location];
} }
return 0; return 0;
} }
float getBorder(css_node_t *node, int location) { static float getBorder(css_node_t *node, int location) {
if (node->style.border[location] >= 0) { if (node->style.border[location] >= 0) {
return node->style.border[location]; return node->style.border[location];
} }
return 0; return 0;
} }
float getPaddingAndBorder(css_node_t *node, int location) { static float getPaddingAndBorder(css_node_t *node, int location) {
return getPadding(node, location) + getBorder(node, location); return getPadding(node, location) + getBorder(node, location);
} }
float getMarginAxis(css_node_t *node, css_flex_direction_t axis) { static float getMarginAxis(css_node_t *node, css_flex_direction_t axis) {
return getMargin(node, leading[axis]) + getMargin(node, trailing[axis]); return getMargin(node, leading[axis]) + getMargin(node, trailing[axis]);
} }
float getPaddingAndBorderAxis(css_node_t *node, css_flex_direction_t axis) { static float getPaddingAndBorderAxis(css_node_t *node, css_flex_direction_t axis) {
return getPaddingAndBorder(node, leading[axis]) + getPaddingAndBorder(node, trailing[axis]); return getPaddingAndBorder(node, leading[axis]) + getPaddingAndBorder(node, trailing[axis]);
} }
css_position_type_t getPositionType(css_node_t *node) { static css_position_type_t getPositionType(css_node_t *node) {
return node->style.position_type; return node->style.position_type;
} }
css_justify_t getJustifyContent(css_node_t *node) { static css_justify_t getJustifyContent(css_node_t *node) {
return node->style.justify_content; return node->style.justify_content;
} }
css_align_t getAlignItem(css_node_t *node, css_node_t *child) { static css_align_t getAlignItem(css_node_t *node, css_node_t *child) {
if (child->style.align_self != CSS_ALIGN_AUTO) { if (child->style.align_self != CSS_ALIGN_AUTO) {
return child->style.align_self; return child->style.align_self;
} }
return node->style.align_items; return node->style.align_items;
} }
css_flex_direction_t getFlexDirection(css_node_t *node) { static css_flex_direction_t getFlexDirection(css_node_t *node) {
return node->style.flex_direction; return node->style.flex_direction;
} }
css_flex_t getFlex(css_node_t *node) { static css_flex_t getFlex(css_node_t *node) {
return node->style.flex; return node->style.flex;
} }
bool isFlex(css_node_t *node) { static bool isFlex(css_node_t *node) {
return getPositionType(node) == CSS_POSITION_RELATIVE && getFlex(node); return getPositionType(node) == CSS_POSITION_RELATIVE && getFlex(node);
} }
float getDimWithMargin(css_node_t *node, css_flex_direction_t axis) { static float getDimWithMargin(css_node_t *node, css_flex_direction_t axis) {
return node->layout.dimensions[dim[axis]] + return node->layout.dimensions[dim[axis]] +
getMargin(node, leading[axis]) + getMargin(node, leading[axis]) +
getMargin(node, trailing[axis]); getMargin(node, trailing[axis]);
} }
bool isDimDefined(css_node_t *node, css_flex_direction_t axis) { static bool isDimDefined(css_node_t *node, css_flex_direction_t axis) {
return !isUndefined(node->style.dimensions[dim[axis]]); return !isUndefined(node->style.dimensions[dim[axis]]);
} }
bool isPosDefined(css_node_t *node, css_position_t pos) { static bool isPosDefined(css_node_t *node, css_position_t position) {
return !isUndefined(node->style.position[pos]); return !isUndefined(node->style.position[position]);
} }
bool isMeasureDefined(css_node_t *node) { static bool isMeasureDefined(css_node_t *node) {
return node->style.measure; return node->style.measure;
} }
float getPosition(css_node_t *node, css_position_t pos) { static float getPosition(css_node_t *node, css_position_t position) {
float result = node->style.position[pos]; float result = node->style.position[position];
if (!isUndefined(result)) { if (!isUndefined(result)) {
return result; return result;
} }
@@ -288,7 +292,7 @@ float getPosition(css_node_t *node, css_position_t pos) {
} }
// When the user specifically sets a value for width or height // When the user specifically sets a value for width or height
void setDimensionFromStyle(css_node_t *node, css_flex_direction_t axis) { static void setDimensionFromStyle(css_node_t *node, css_flex_direction_t axis) {
// The parent already computed us a width or height. We just skip it // The parent already computed us a width or height. We just skip it
if (!isUndefined(node->layout.dimensions[dim[axis]])) { if (!isUndefined(node->layout.dimensions[dim[axis]])) {
return; return;
@@ -307,7 +311,7 @@ void setDimensionFromStyle(css_node_t *node, css_flex_direction_t axis) {
// If both left and right are defined, then use left. Otherwise return // If both left and right are defined, then use left. Otherwise return
// +left or -right depending on which is defined. // +left or -right depending on which is defined.
float getRelativePosition(css_node_t *node, css_flex_direction_t axis) { static float getRelativePosition(css_node_t *node, css_flex_direction_t axis) {
float lead = node->style.position[leading[axis]]; float lead = node->style.position[leading[axis]];
if (!isUndefined(lead)) { if (!isUndefined(lead)) {
return lead; return lead;

2
src/Layout.h
View File

@@ -103,7 +103,7 @@ typedef struct css_node {
// Lifecycle of nodes and children // Lifecycle of nodes and children
css_node_t *new_css_node(); css_node_t *new_css_node(void);
void init_css_node_children(css_node_t *node, int children_count); void init_css_node_children(css_node_t *node, int children_count);
void free_css_node(css_node_t *node); void free_css_node(css_node_t *node);

6658
src/__tests__/Layout-test.c
View File

File diff suppressed because it is too large Load Diff

68
src/transpile.html
View File

@@ -67,6 +67,13 @@ function printLayout(test) {
res.push(indent(level) + str); res.push(indent(level) + str);
} }
function isEmpty(obj) {
for (var key in obj) {
return false;
}
return true;
}
function indent(level) { function indent(level) {
var result = ''; var result = '';
for (var i = 0; i < level; ++i) { for (var i = 0; i < level; ++i) {
@@ -75,9 +82,25 @@ function printLayout(test) {
return result; return result;
} }
add('{');
level++;
// Output the style node
add('css_node_t *root_node = new_css_node();');
add('{');
level++;
if (!isEmpty(test.node.style) || test.node.children && test.node.children.length) {
add('css_node_t *node_0 = root_node;');
}
function rec_style(node) {
function addStyle(str) {
add('node_' + (level - 3) + '->style.' + str);
}
function addEnum(node, js_key, c_key, dict) { function addEnum(node, js_key, c_key, dict) {
if (js_key in node.style) { if (js_key in node.style) {
add('node->style' + '.' + c_key + ' = ' + dict[node.style[js_key]] + ';'); addStyle(c_key + ' = ' + dict[node.style[js_key]] + ';');
} }
} }
@@ -86,7 +109,7 @@ function printLayout(test) {
if (positive === 'positive' && node.style[js_key] < 0) { if (positive === 'positive' && node.style[js_key] < 0) {
// do nothing // do nothing
} else { } else {
add('node->style' + '.' + c_key + ' = ' + node.style[js_key] + ';'); addStyle(c_key + ' = ' + node.style[js_key] + ';');
} }
} }
} }
@@ -105,20 +128,11 @@ function printLayout(test) {
function addMeasure(node) { function addMeasure(node) {
if ('measure' in node.style) { if ('measure' in node.style) {
add('node->style.measure = measure;'); addStyle('measure = measure;');
add('node->style.measure_context = "' + node.style.measure.toString() + '";'); addStyle('measure_context = "' + node.style.measure.toString() + '";');
} }
} }
add('{');
level++;
// Output the style node
add('css_node_t *root_node = new_css_node();');
add('{');
level++;
add('css_node_t *node = root_node;');
function rec_style(node) {
addEnum(node, 'flexDirection', 'flex_direction', { addEnum(node, 'flexDirection', 'flex_direction', {
'row': 'CSS_FLEX_DIRECTION_ROW', 'row': 'CSS_FLEX_DIRECTION_ROW',
'column': 'CSS_FLEX_DIRECTION_COLUMN' 'column': 'CSS_FLEX_DIRECTION_COLUMN'
@@ -162,14 +176,13 @@ function printLayout(test) {
addMeasure(node); addMeasure(node);
if (node.children) { if (node.children) {
add('init_css_node_children(node, ' + node.children.length + ');'); add('init_css_node_children(node_' + (level - 3) +', ' + node.children.length + ');');
add('{'); add('{');
level++; level++;
add('css_node_t *outer_node_' + (level - 3) + ' = node;'); add('css_node_t *node_' + (level - 3) + ';');
add('css_node_t *node;');
for (var i = 0; i < node.children.length; ++i) { for (var i = 0; i < node.children.length; ++i) {
add('node = &outer_node_' + (level - 3) + '->children[' + i + '];'); add('node_' + (level - 3) + ' = &node_' + (level - 4) + '->children[' + i + '];');
rec_style(node.children[i]); rec_style(node.children[i]);
} }
@@ -186,23 +199,26 @@ function printLayout(test) {
add('css_node_t *root_layout = new_css_node();'); add('css_node_t *root_layout = new_css_node();');
add('{'); add('{');
level++; level++;
add('css_node_t *node = root_layout;'); add('css_node_t *node_0 = root_layout;');
function rec_layout(node) { function rec_layout(node) {
add('node->layout.position[CSS_TOP] = ' + node.top + ';'); function addLayout(str) {
add('node->layout.position[CSS_LEFT] = ' + node.left + ';'); add('node_' + (level - 3) + '->layout.' + str);
add('node->layout.dimensions[CSS_WIDTH] = ' + node.width + ';'); }
add('node->layout.dimensions[CSS_HEIGHT] = ' + node.height + ';');
addLayout('position[CSS_TOP] = ' + node.top + ';');
addLayout('position[CSS_LEFT] = ' + node.left + ';');
addLayout('dimensions[CSS_WIDTH] = ' + node.width + ';');
addLayout('dimensions[CSS_HEIGHT] = ' + node.height + ';');
if (node.children) { if (node.children) {
add('init_css_node_children(node, ' + node.children.length + ');'); add('init_css_node_children(node_' + (level - 3) +', ' + node.children.length + ');');
add('{'); add('{');
level++; level++;
add('css_node_t *outer_node_' + (level - 3) + ' = node;'); add('css_node_t *node_' + (level - 3) + ';');
add('css_node_t *node;');
for (var i = 0; i < node.children.length; ++i) { for (var i = 0; i < node.children.length; ++i) {
add('node = &outer_node_' + (level - 3) + '->children[' + i + '];'); add('node_' + (level - 3) + ' = &node_' + (level - 4) + '->children[' + i + '];');
rec_layout(node.children[i]); rec_layout(node.children[i]);
} }