From 407be557bb1e7db73fb59e464bc3742ddae5584d Mon Sep 17 00:00:00 2001
From: bringert <bringert@cs.chalmers.se>
Date: Fri, 15 Dec 2006 16:08:39 +0000
Subject: [PATCH] Include update function in generated VoiceXML. Generated
 linearization javaScript now uses the same abstract syntax representation as
 SISR.

---
 javascript/gflib.js | 62 +++++++++++++++++++++++++++++++++++++--------
 1 file changed, 51 insertions(+), 11 deletions(-)

diff --git a/javascript/gflib.js b/javascript/gflib.js
index f40b2ab55..630c01a3d 100644
--- a/javascript/gflib.js
+++ b/javascript/gflib.js
@@ -2,20 +2,52 @@
 
 function Fun(name) {
 	this.name = name;
-	this.children = copy_arguments(arguments, 1);
 }
 Fun.prototype.toString = function () { return this.show(0); } ;
 Fun.prototype.show = function (prec) {
 	var s = this.name;
-	for (var i = 0; i < this.children.length; i++) {
-		s += " " + this.children[i].show(1);
+	var cs = this.getChildren();
+	for (var c in cs) {
+		s += " " + c.show(1);
 	}
-	if (prec > 0 && this.children.length > 0) {
+	if (prec > 0 && cs.length > 0) {
 		s = "(" + s + ")" ;
 	}
 	return s;
+};
+Fun.prototype.getChild = function (i) {
+	return this['arg'+i];
+};
+Fun.prototype.setChild = function (i,c) {
+	this['arg'+i] = c;
+};
+/* Gets an array containing all the children. Modifying the array does not
+   change the tree, but modifying the elements of the array does. */
+Fun.prototype.getChildren = function () {
+	var a = new Array();
+	for (var i = 0; ; i++) {
+		var c = this.getChild(i);
+		if (isUndefined(c)) { break; }
+		a.push(c);
+	}
+	return a;
 } ;
 
+/* Hack to get around the fact that our SISR doesn't build real Fun objects. */
+function copyTree(x) {
+	if (typeof x == 'string' && x == '?') {
+		return '?';
+	} else {
+		var t = new Fun(x.name);
+		for (var i = 0; ; i++) {
+			var c = x['arg' + i];
+			if (isUndefined(c)) { break; }
+			t.setChild(i, copyTree(c));
+		}
+		return t;
+	}
+}
+
 function parseTree(str) { 
 	return parseTree_(str.match(new RegExp("[\\w\\']+|\\(|\\)","g")), 0); 
 }
@@ -31,15 +63,15 @@ function parseTree_(tokens, prec) {
 		var tree = new Fun(t);
 		if (prec == 0) {
 			var c;
-			while ((c = parseTree_(tokens, 1)) !== null) { 
-				tree.children.push(c); 
+			var i;
+			for (i = 0; (c = parseTree_(tokens, 1)) !== null; i++) {
+				tree.setChild(i,c);
 			}
 		}
 		return tree;
 	}
 }
 
-
 /* Concrete syntax terms */
 
 function Arr() { this.values = copy_arguments(arguments, 0); }
@@ -84,15 +116,23 @@ Linearizer.prototype.rule = function (name, cs) { return this.rules[name](cs); }
 Linearizer.prototype.addRule = function (name, f) { this.rules[name] = f; };
 Linearizer.prototype.linearize = function (tree) { return this.linearizeToTerm(tree).print(); };
 Linearizer.prototype.linearizeToTerm = function (tree) {
-	var cs = new Array();
-	for (var i = 0; i < tree.children.length; i++) {
-		cs[i] = this.linearizeToTerm(tree.children[i]);
+	if (typeof tree == 'string' && tree == '?') {
+		return new Meta();
+	} else {
+		var cs = tree.getChildren();
+		for (var i = 0; i < cs.length; i++) {
+			cs[i] = this.linearizeToTerm(cs[i]);
+		}
+		return this.rule(tree.name, cs);
 	}
-	return this.rule(tree.name, cs);
 };
 
 /* Utilities */
 
+function isString(a) { return typeof a == 'string'; }
+function isArray(a) { return a && typeof a == 'object' && a.constructor == Array; }
+function isUndefined(a) { return typeof a == 'undefined'; }
+
 function copy_arguments(args, start) {
 	var arr = new Array();
 	for (var i = 0; i < args.length - start; i++) {