From 3e65ed4d410fb72848c41789a5753b5d2daed3bf Mon Sep 17 00:00:00 2001
From: Fazli Sapuan <fazli@sapuan.org>
Date: Sun, 28 Feb 2016 15:14:19 +0800
Subject: [PATCH 1/3] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index a2558df7..204cb808 100644
--- a/README.md
+++ b/README.md
@@ -70,7 +70,7 @@ The created function is a regular JavaScript function, you can use it like regul
 
 ```js
 myFunc();
-// Result: [0, 1, 2, 3, ... 100]
+// Result: [0, 1, 2, 3, ... 99]
 ```
 
 Note: Instead of creating an object, you can use the chainable shortcut methods as a neater way of specificying options.
@@ -81,7 +81,7 @@ var myFunc = gpu.createKernel(function() {
 }).dimensions([100]);
     
 myFunc();
-// Result: [0, 1, 2, 3, ... 100]
+// Result: [0, 1, 2, 3, ... 99]
 ```
 ### Accepting Input
 

From ec9c3304e2ee78b36a2c8b4bdcfafee7917c1868 Mon Sep 17 00:00:00 2001
From: Fazli Sapuan <fazli@sapuan.org>
Date: Sun, 28 Feb 2016 16:03:01 +0800
Subject: [PATCH 2/3] Add loopMaxIterations option

---
 src/backend/fallback.js           |  5 +++++
 src/backend/functionBuilder.js    | 22 ++++++++++++--------
 src/backend/functionNode.js       |  4 ++--
 src/backend/functionNode_webgl.js | 34 ++++++++++++++++++++-----------
 src/backend/glsl.js               |  9 ++++++--
 test/src/features/for_loop.js     |  3 ++-
 6 files changed, 51 insertions(+), 26 deletions(-)

diff --git a/src/backend/fallback.js b/src/backend/fallback.js
index f05ba43e..20411038 100644
--- a/src/backend/fallback.js
+++ b/src/backend/fallback.js
@@ -167,6 +167,11 @@
 			return ret;
 		};
 		
+		ret.loopMaxIterations = function(max) {
+			opt.loopMaxIterations = max;
+			return ret;
+		};
+		
 		ret.wraparound = function() {
 			opt.wraparound = false;
 			return ret;
diff --git a/src/backend/functionBuilder.js b/src/backend/functionBuilder.js
index 04388b4a..c02845dc 100644
--- a/src/backend/functionBuilder.js
+++ b/src/backend/functionBuilder.js
@@ -64,7 +64,7 @@ var functionBuilder = (function() {
 	///
 	/// Returns:
 	/// 	{[String,...]}  Returning list of function names that is traced. Including itself.
-	function traceFunctionCalls( functionName, retList ) {
+	function traceFunctionCalls( functionName, retList, opt ) {
 		functionName = functionName || "kernel";
 		retList = retList || [];
 		
@@ -76,9 +76,9 @@ var functionBuilder = (function() {
 			} else {
 				retList.push(functionName);
 				
-				fNode.getWebglFunctionString(); //ensure JS trace is done
+				fNode.getWebglFunctionString(opt); //ensure JS trace is done
 				for(var i=0; i<fNode.calledFunctions.length; ++i) {
-					this.traceFunctionCalls( fNode.calledFunctions[i], retList );
+					this.traceFunctionCalls( fNode.calledFunctions[i], retList, opt );
 				}
 			}
 		}
@@ -96,12 +96,12 @@ var functionBuilder = (function() {
 	/// Returns:
 	/// 	{String} The full webgl string, of all the various functions. Trace optimized if functionName given
 	///
-	function webglString_fromFunctionNames(functionList) {
+	function webglString_fromFunctionNames(functionList, opt) {
 		var ret = [];
 		for(var i=0; i<functionList.length; ++i) {
 			var node = this.nodeMap[functionList[i]];
 			if(node) {
-				ret.push( this.nodeMap[functionList[i]].getWebglFunctionString() );
+				ret.push( this.nodeMap[functionList[i]].getWebglFunctionString(opt) );
 			}
 		}
 		return ret.join("\n");
@@ -117,11 +117,15 @@ var functionBuilder = (function() {
 	/// Returns:
 	/// 	{String} The full webgl string, of all the various functions. Trace optimized if functionName given
 	///
-	function webglString(functionName) {
-		if(functionName) {
-			return this.webglString_fromFunctionNames( this.traceFunctionCalls(functionName, []).reverse() );
+	function webglString(functionName, opt) {
+		if (opt == undefined) {
+			opt = {};
 		}
-		return this.webglString_fromFunctionNames(Object.keys(this.nodeMap));
+		
+		if(functionName) {
+			return this.webglString_fromFunctionNames( this.traceFunctionCalls(functionName, [], opt).reverse(), opt );
+		}
+		return this.webglString_fromFunctionNames( Object.keys(this.nodeMap), opt );
 	}
 	functionBuilder.prototype.webglString = webglString;
 	
diff --git a/src/backend/functionNode.js b/src/backend/functionNode.js
index 68f86a86..49d143f6 100644
--- a/src/backend/functionNode.js
+++ b/src/backend/functionNode.js
@@ -248,12 +248,12 @@ var functionNode = (function() {
 	/// Returns:
 	/// 	{String} webgl function string, result is cached under this.webglFunctionString
 	///
-	function getWebglFunctionString() {
+	function getWebglFunctionString(opt) {
 		if( this.webglFunctionString ) {
 			return this.webglFunctionString;
 		}
 
-		return this.webglFunctionString = functionNode_webgl(this);
+		return this.webglFunctionString = functionNode_webgl(this, opt);
 	}
 	functionNode.prototype.getWebglFunctionString = getWebglFunctionString;
 
diff --git a/src/backend/functionNode_webgl.js b/src/backend/functionNode_webgl.js
index 584de289..1a617956 100644
--- a/src/backend/functionNode_webgl.js
+++ b/src/backend/functionNode_webgl.js
@@ -1,7 +1,7 @@
 // Closure capture for the ast function, prevent collision with existing AST functions
 var functionNode_webgl = (function() {
 	
-	var gpu, jsFunctionString;
+	var gpu, opt, jsFunctionString;
 	
 	function isIdentifierKernelParam(paramName, ast, funcParam) {
 		return funcParam.paramNames.indexOf(paramName) != -1;
@@ -31,8 +31,9 @@ var functionNode_webgl = (function() {
 	/// Returns:
 	/// 	the converted webGL function string
 	///
-	function functionNode_webgl( inNode ) {
+	function functionNode_webgl( inNode, _opt ) {
 		gpu = inNode.gpu;
+		opt = _opt;
 		jsFunctionString = inNode.jsFunctionString;
 		inNode.webglFunctionString_array = ast_generic( inNode.getJS_AST(), [], inNode );
 		inNode.webglFunctionString = webgl_regex_optimize(
@@ -344,15 +345,26 @@ var functionNode_webgl = (function() {
 		}
 		
 		if (forNode.test && forNode.test.type == "BinaryExpression") {
-			if (forNode.test.right.type != "Literal") {
-				retArr.push("{\n");
-				retArr.push("float ");
-				ast_generic(forNode.init, retArr, funcParam);
-				retArr.push(";\n");
-				retArr.push("for (float i=0.0; i<LOOP_MAX; i++, ");
-				ast_generic(forNode.update, retArr, funcParam);
-				retArr.push(") {\n");
+			if (forNode.test.right.type == "Identifier"
+				&& forNode.test.operator == "<") {
 				
+				console.log(opt.loopMaxIterations);
+				if (opt.loopMaxIterations === undefined) {
+					console.warn("Warning: loopMaxIterations is not set! Using default of 100 which may result in unintended behavior.");
+					console.warn("Set loopMaxIterations or use a for loop of fixed length to silence this message.");
+				}
+				
+				retArr.push("for (float ");
+				ast_generic(forNode.init, retArr, funcParam);
+				retArr.push(";");
+				ast_generic(forNode.test.left, retArr, funcParam);
+				retArr.push(forNode.test.operator);
+				retArr.push("LOOP_MAX");
+				retArr.push(";");
+				ast_generic(forNode.update, retArr, funcParam);
+				retArr.push(")");
+				
+				retArr.push("{\n");
 				retArr.push("if (");
 				ast_generic(forNode.test.left, retArr, funcParam);
 				retArr.push(forNode.test.operator);
@@ -363,8 +375,6 @@ var functionNode_webgl = (function() {
 				}
 				retArr.push("} else {\n");
 				retArr.push("break;\n");
-				retArr.push("}\n");
-				
 				retArr.push("}\n");
 				retArr.push("}\n");
 				
diff --git a/src/backend/glsl.js b/src/backend/glsl.js
index 6b0e69fc..31e2b96d 100644
--- a/src/backend/glsl.js
+++ b/src/backend/glsl.js
@@ -242,7 +242,7 @@
 					'precision highp float;',
 					'precision highp int;',
 					'',
-					'#define LOOP_MAX 10000000.0',
+					'#define LOOP_MAX '+ (opt.loopMaxIterations ? parseInt(opt.loopMaxIterations)+'.0' : '100.0'),
 					'',
 					opt.hardcodeConstants ? 'vec3 uOutputDim = vec3('+threadDim[0]+','+threadDim[1]+', '+ threadDim[2]+');' : 'uniform vec3 uOutputDim;',
 					opt.hardcodeConstants ? 'vec2 uTexSize = vec2('+texSize[0]+','+texSize[1]+');' : 'uniform vec2 uTexSize;',
@@ -315,7 +315,7 @@
 					'}',
 					'',
 					paramStr,
-					builder.webglString("kernel"),
+					builder.webglString("kernel", opt),
 					'',
 					'void main(void) {',
 					'	index = floor(vTexCoord.s * float(uTexSize.x)) + floor(vTexCoord.t * float(uTexSize.y)) * uTexSize[0];',
@@ -511,6 +511,11 @@
 			opt.graphical = flag;
 			return ret;
 		};
+		
+		ret.loopMaxIterations = function(max) {
+			opt.loopMaxIterations = max;
+			return ret;
+		};
 
 		ret.wraparound = function(flag) {
 			opt.wraparound = flag;
diff --git a/test/src/features/for_loop.js b/test/src/features/for_loop.js
index 9d976c7a..907e9416 100644
--- a/test/src/features/for_loop.js
+++ b/test/src/features/for_loop.js
@@ -58,7 +58,8 @@ QUnit.test( "for_loop (CPU)", function( assert ) {
 	var evil_while_cpuRef = new GPU();
 	var evil_while_cpuRef_f =  evil_while_cpuRef.createKernel(evil_while_kernalFunction, {
 		dimensions : [6],
-		mode : "cpu"
+		mode : "cpu",
+		loopMaxIterations: 10000
 	});
 
 	var evil_while_exp = evil_while_cpuRef_f(evil_while_a,evil_while_b);

From e175f8a1a32f55d5ff34aacc715df7a0511642df Mon Sep 17 00:00:00 2001
From: Fazli Sapuan <fazli@sapuan.org>
Date: Sun, 28 Feb 2016 16:03:16 +0800
Subject: [PATCH 3/3] Add loopMaxIterations option

---
 src/backend/functionNode_webgl.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/backend/functionNode_webgl.js b/src/backend/functionNode_webgl.js
index 1a617956..23132338 100644
--- a/src/backend/functionNode_webgl.js
+++ b/src/backend/functionNode_webgl.js
@@ -348,7 +348,6 @@ var functionNode_webgl = (function() {
 			if (forNode.test.right.type == "Identifier"
 				&& forNode.test.operator == "<") {
 				
-				console.log(opt.loopMaxIterations);
 				if (opt.loopMaxIterations === undefined) {
 					console.warn("Warning: loopMaxIterations is not set! Using default of 100 which may result in unintended behavior.");
 					console.warn("Set loopMaxIterations or use a for loop of fixed length to silence this message.");