[Sarnold]: An attempt to produce a Tcl-equivalent to [JSON], a data format easily parsable by Web applications.
Here we have a simple code to handle this format at Tcl-level, with a little sugar to handle types, that is required
by the [Javascript] version.

[Lars H], 2008-02-06: Do you have an example of what the data format looks like? 
Also, what is the point of doing a more Tclish format in this case? I'd expect it to be easier to teach Tcl to parse a data structure with Javascript syntax than vice versa, but on the other hand it is probably good for the mountain to come to Muhammed every once in a while too.

[Sarnold]: The data format maps Tcl's [list]. The structure of the data is separate from the data itself, due to [EIAS].
The data structure is also a [list].
======
 Data structure syntax for Tclon:

 list : type ?type ...?
    | list '*' # the star matches one or more values
    | '*' # same remark
    | 'list' type # this is a list where all elements have the same type (the argument) 
 type : name | list | dict
 dict : 'dict'  # a non-formal dict (keys and values are just strings)
             | 'dict' type type; # a formal dict : second and third types are the types of keys and values, resp.
======
The data structure is a 'list' as the syntax shows.
======
 Data format examples:

 Structure:                  Data sample:
 ==========                  ============
 *                           {a b {c d e}}
 {dict}                      {{opt value opt2 value2}}
 {{dict key {a b c}}}        {{colors {red green blue} values {100 200 300}}}
======
----
'''Javascript code:'''
======
var tclon = new Object();
tclon.tclon=function (input, types) {
	return tclon._tclon(tclon.parse(input), tclon.parse(types));
}

tclon._tclon = function (input, types) {
	if (types.length == 0 || (types.length==1 && types[0]=="*"))
		return input;
	var res=new Array(), i, tab, elt;
	for (i=0; i<input.length && i<types.length; i++) {
		var t = types[i];
		var d = input[i];
		if (typeof t == "string") {
			if (t == "dict")
				res.push(tclon.toDict(d));
			else if (t == 'list')
				res.push(d);
			else if (typeof d == "Array")
				res.push(d.join());
			else
				res.push(d);
		} else if (t[0]=="list") {
			tab = new Array();
			for (j in d) {
				tab.push(tclon._tclon(d[j], t[1]));
			}
			res.push(tab);
		} else if (t[0]=="dict") {
			if (t.length != 3) throw "invalid dict type";
			res.push(tclon.toDictWithType(d,t[1],t[2]));
		}
	}
	return res;
}

tclon.toDict = function (arr) {
	var dict = new Object();
	if(arr.length%2!=0) {
		alert(arr);
		throw "not a dict";
	}
	for (var i = 0; i <arr.length;i+=2)
		dict[arr[i]]=arr[i+1];
	return dict;
}

tclon.toDictWithType = function (arr, ktype, vtype) {
	var dict = new Object();
	if(arr.length%2!=0) {
		alert(arr);
		throw "not a dict";
	}
	for (var i = 0; i <arr.length;i+=2)
		dict[tclon._tclon(arr[i], ktype)]=tclon._tclon(arr[i+1], vtype);
	return dict;
}

tclon.StdEscapeSequences = {
	"{" : "{", "}": "}", "\"": "\"", "r": "\r", "t": "\t",
	"a": "\a", "b": "\b", "n": "\n", "v": "\v", "f": "\f"
};

tclon.getSeq = function (str, pos) {
	var my = str.substr(pos+1, 10);
	if (my.charAt(0)=="x")
		return String.fromCharCode(parseInt(my.substr(1,2), 16));
	if (my.charAt(0)=="u")
		return String.fromCharCode(parseInt(my.substr(1,4), 16));
	return tclon.StdEscapeSequences[my];
}

tclon.seqLen = function (str, pos) {
	var my = str.substr(pos+1, 10);
	if (my.charAt(0)=="x")
		return 3;
	if (my.charAt(0)=="u")
		return 4;
	return 1;
}

tclon.parse = function (str) {
	var tab;
	var res = new Array();
	var i = 0, level = 0, work="", c = 0, inString = false;
	res.push(new Array());
	for (i = 0; i <str.length; i++) {
		switch(str.charAt(i)) {
			case "{":
				if (inString) {
					work+="{";
					break;
				}
				level++;
				res.push(new Array());
				break;
			case "}":
				if (inString) {
					work+="}";
					break;
				}
				level--;
				if (level < 0) throw "unmatched braces";
				tab = res[res.length-1];
				if (str.charAt(i-1)!="}") tab.push(work);
				res.pop();
				res[res.length-1].push(tab);
				work = "";
				break;
			case "\\":
				// Escape sequence
				work+=tclon.getSeq(str, i+1);
				i+=tclon.escapeSeq(str, i+1);
				break;
			case "\"":
				inString = !instring;
				break;
			default:
				if (str.charAt(i).match("[ \t\r\n\v\f]")) {
					if (str.charAt(i-1)!="}") res[res.length-1].push(work);
					work = "";
				}	else
					work+=str.charAt(i);
				break;
		}
	}
	if (str.charAt(str.length-1)!="}") res[0].push(work);
	if (level != 0)
		throw "unmatched braces";
	if (inString)
		throw "missing double-quotes";
	return res[0];
}

alert(tclon.tclon("a {{b c} {d e}} f", "s {list {a b}} s"));
======
----
'''Tcl code:'''
======
proc tclon {data {type *}} {
	if {![llength $type] || $type eq "*"} {return $data}
	set res ""
	foreach t $type d $data {
		if {[llength $t]<=1} {
			lappend res $d
		} elseif {[lindex $t 0] eq "dict"} {
			set dict [list]
			foreach {k v} $d {
				lappend dict [tclon $k [lindex $t 1]] [tclon $v [lindex $t 2]]
			}
			lappend res $dict
		} elseif {[lindex $t 0] eq "list"} {
			set l [list]
			foreach v $d {lappend l [tclon $v [lindex $t 1]]}
			lappend res $l
		} else {
			lappend res [tclon $d $t]
		}
	}
	set res
}



proc fromtclon {data {type *}} {
	if {![llength $type] || $type eq "*"} {return $data}
	set res [list]
	foreach t $type d $data {
		if {[llength $t]<=1} {
			lappend res $d
		} elseif {[lindex $t 0] eq "dict"} {
			set dict [list]
			foreach {k v} $d {
				lappend dict [fromtclon $k [lindex $t 1]] [fromtclon $v [lindex $t 2]]
			}
			lappend res $dict
		} elseif {[lindex $t 0] eq "list"} {
			set l [list]
			foreach v $d {lappend l [fromtclon $v [lindex $t 1]]}
			lappend res $l
		} else {		
			lappend res [fromtclon $d $t]
		}
	}
	set res
}

======
----
Some testing:
======
proc ? {s r} {
	if {![string equal $r [uplevel 1 $s]]} {error "assertion failed"}
}

proc validate {data type} {
	set out [fromtclon [tclon $data $type] $type]
	if {$out ne $data} {puts "Difference:"
	puts "1: $data"
	puts "2: [tclon $data $type]"
	puts "3: $out"
	error "assertion failed"
	}
}

? {tclon 1 int} 1
? {tclon {a b}} {a b}
? {tclon {{a b} b c} {{list s} *}} {{a b} b c}
validate 1 int
validate {a b} {s s}
validate {{a b} b c} {{list s} *}
validate {{x {1 2} y {23 4}}} {{dict key {a b}}}
======
----
!!!!!!
%| [Category Internet] |%
!!!!!!