x_ite 4.0.5 → 4.7.5

package/src/x_ite/Parser/XMLParser.js

@@ -50,11 +50,11 @@
 define ([
 	"jquery",
 	"x_ite/Basic/X3DField",
-	"x_ite/Basic/X3DArrayField",
 	"x_ite/Basic/X3DBaseNode",
 	"x_ite/Components/Core/X3DPrototypeInstance",
 	"x_ite/Fields",
 	"x_ite/Parser/Parser",
+	"x_ite/Parser/X3DParser",
 	"x_ite/Parser/HTMLSupport",
 	"x_ite/Prototype/X3DExternProtoDeclaration",
 	"x_ite/Prototype/X3DProtoDeclaration",
@@ -62,12 +62,12 @@ define ([
 ],
 function ($,
           X3DField,
-          X3DArrayField,
           X3DBaseNode,
           X3DPrototypeInstance,
           Fields,
           Parser,
-          HTMLSupport,   
+          X3DParser,
+          HTMLSupport,
           X3DExternProtoDeclaration,
           X3DProtoDeclaration,
           X3DConstants)
@@ -84,21 +84,33 @@ function ($,
 
 	function XMLParser (scene)
 	{
-		this .scene             = scene;
-		this .executionContexts = [ scene ];
+		X3DParser .call (this, scene);
+
 		this .protoDeclarations = [ ];
 		this .parents           = [ ];
-		this .parser            = new Parser (this .scene, true);
+		this .parser            = new Parser (scene);
 		this .url               = new Fields .MFString ();
+
+		try
+		{
+			this .setUnits (this .getScene () .getMetaData ("generator"));
+			this .parser .setUnits (this .getUnits ());
+		}
+		catch (error)
+		{ }
 	}
 
-	XMLParser .prototype =
+	XMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
 	{
 		constructor: XMLParser,
-		parseIntoScene: function (xmlElement)
+		parseIntoScene: function (xmlElement, success, error)
 		{
-			this .scene .setEncoding ("XML");
-			this .scene .setProfile (this .getBrowser () .getProfile ("Full"));
+			this .scene .dom = xmlElement;
+			this .success    = success;
+			this .error      = error;
+
+			this .getScene () .setEncoding ("XML");
+			this .getScene () .setProfile (this .getBrowser () .getProfile ("Full"));
 
 			this .xmlElement (xmlElement);
 		},
@@ -126,33 +138,124 @@ function ($,
 							this .x3dElement (X3D [i]);
 					}
 					else
-						this .childrenElements (xmlElement);
+					{
+						if (this .success)
+						{
+							require (this .getProviderUrls (),
+							function ()
+							{
+								try
+								{
+									this .childrenElements (xmlElement);
+									this .success (this .getScene ());
+								}
+								catch (error)
+								{
+									if (this .error)
+										this .error (error);
+								}
+							}
+							.bind (this),
+							function (error)
+							{
+								if (this .error)
+									this .error (error);
+							}
+							.bind (this));
+						}
+						else
+						{
+							this .childrenElements (xmlElement);
+						}
+					}
 
 					break;
 				}
 				case "X3D":
+				{
 					this .x3dElement (xmlElement);
 					break;
+				}
 				case "Scene":
 				case "SCENE":
-					this .sceneElement (xmlElement);
+				{
+					if (this .success)
+					{
+						require (this .getProviderUrls (),
+						function ()
+						{
+							try
+							{
+								this .sceneElement (xmlElement);
+								this .success (this .getScene ());
+							}
+							catch (error)
+							{
+								if (this .error)
+									this .error (error);
+							}
+						}
+						.bind (this),
+						function (error)
+						{
+							if (this .error)
+								this .error (error);
+						}
+						.bind (this));
+					}
+					else
+					{
+						this .sceneElement (xmlElement);
+					}
+
 					break;
+				}
 				default:
-					this .childElement (xmlElement);
+				{
+					if (this .success)
+					{
+						require (this .getProviderUrls (),
+						function ()
+						{
+							try
+							{
+								this .childrenElements (xmlElement);
+								this .success (this .getScene ());
+							}
+							catch (error)
+							{
+								if (this .error)
+									this .error (error);
+							}
+						}
+						.bind (this),
+						function (error)
+						{
+							if (this .error)
+								this .error (error);
+						}
+						.bind (this));
+					}
+					else
+					{
+						this .childrenElements (xmlElement);
+					}
+
 					break;
+				}
 			}
 		},
 		x3dElement: function (xmlElement)
 		{
-			// Profile
-
 			try
 			{
+				// Profile
+
 				var
 					profileNameId = xmlElement .getAttribute ("profile"),
 					profile       = this .getBrowser () .getProfile (profileNameId || "Full");
 
-				this .scene .setProfile (profile);
+				this .getScene () .setProfile (profile);
 			}
 			catch (error)
 			{
@@ -164,16 +267,48 @@ function ($,
 			var specificationVersion = xmlElement .getAttribute ("version");
 
 			if (specificationVersion)
-				this .scene .specificationVersion = specificationVersion;
+				this .getScene () .setSpecificationVersion (specificationVersion);
 
 			// Process child nodes
 
 			var childNodes = xmlElement .childNodes;
 
 			for (var i = 0; i < childNodes .length; ++ i)
-				this .x3dElementChild (childNodes [i])
+				this .x3dElementChildHead (childNodes [i])
+
+			if (this .success)
+			{
+				require (this .getProviderUrls (),
+				function ()
+				{
+					try
+					{
+						for (var i = 0; i < childNodes .length; ++ i)
+							this .x3dElementChildScene (childNodes [i])
+
+						this .success (this .getScene ());
+					}
+					catch (error)
+					{
+						if (this .error)
+							this .error (error);
+					}
+				}
+				.bind (this),
+				function (error)
+				{
+					if (this .error)
+						this .error (error);
+				}
+				.bind (this));
+			}
+			else
+			{
+				for (var i = 0; i < childNodes .length; ++ i)
+					this .x3dElementChildScene (childNodes [i])
+			}
 		},
-		x3dElementChild: function (xmlElement)
+		x3dElementChildHead: function (xmlElement)
 		{
 			switch (xmlElement .nodeName)
 			{
@@ -181,6 +316,12 @@ function ($,
 				case "HEAD":
 					this .headElement (xmlElement);
 					return;
+			}
+		},
+		x3dElementChildScene: function (xmlElement)
+		{
+			switch (xmlElement .nodeName)
+			{
 				case "Scene":
 				case "SCENE":
 					this .sceneElement (xmlElement);
@@ -190,9 +331,17 @@ function ($,
 		headElement: function (xmlElement)
 		{
 			var childNodes = xmlElement .childNodes;
-	
+
 			for (var i = 0; i < childNodes .length; ++ i)
 				this .headElementChild (childNodes [i]);
+
+			try
+			{
+				this .setUnits (this .getScene () .getMetaData ("generator"));
+				this .parser .setUnits (this .getUnits ());
+			}
+			catch (error)
+			{ }
 		},
 		headElementChild: function (xmlElement)
 		{
@@ -219,16 +368,16 @@ function ($,
 				var
 					componentNameIdCharacters = xmlElement .getAttribute ("name"),
 					componentSupportLevel = parseInt (xmlElement .getAttribute ("level"));
-	
+
 				if (componentNameIdCharacters === null)
 					return console .warn ("XML Parser Error: Bad component statement: Expected name attribute.");
-	
+
 				if (componentSupportLevel === null)
 					return console .warn ("XML Parser Error: Bad component statement: Expected level attribute.");
 
 				var component = this .getBrowser () .getComponent (componentNameIdCharacters, componentSupportLevel);
-	
-				this .scene .addComponent (component);
+
+				this .getScene () .addComponent (component);
 			}
 			catch (error)
 			{
@@ -251,7 +400,7 @@ function ($,
 			if (conversionFactor === null)
 				return console .warn ("XML Parser Error: Bad unit statement: Expected conversionFactor attribute.");
 
-			this .scene .updateUnit (category, name, parseFloat (conversionFactor));
+			this .getScene () .updateUnit (category, name, parseFloat (conversionFactor));
 		},
 		metaElement: function (xmlElement)
 		{
@@ -260,12 +409,12 @@ function ($,
 				metavalue = xmlElement .getAttribute ("content");
 
 			if (metakey === null)
-				return console .warn ("XML Parser Error: Bad meta statement: Expected name attribute.");	
+				return console .warn ("XML Parser Error: Bad meta statement: Expected name attribute.");
 
 			if (metavalue === null)
 				return console .warn ("XML Parser Error: Bad meta statement: Expected content attribute.");
 
-			this .scene .setMetaData (metakey, metavalue);
+			this .getScene () .setMetaData (metakey, metavalue);
 		},
 		sceneElement: function (xmlElement)
 		{
@@ -289,7 +438,7 @@ function ($,
 				case "#cdata-section":
 					this .cdataNode (xmlElement);
 					return;
-				
+
 				case "ExternProtoDeclare":
 				case "EXTERNPROTODECLARE":
 					this .externProtoDeclareElement (xmlElement);
@@ -346,12 +495,12 @@ function ($,
 
 				if (url === null)
 					return console .warn ("XML Parser Error: Bad ExternProtoDeclare statement: Expected url attribute.");
-				
+
 				this .parser .setInput (url);
 				Parser .prototype .sfstringValues .call (this .parser, this .url);
 
 				var externproto = new X3DExternProtoDeclaration (this .getExecutionContext ());
-							
+
 				this .pushParent (externproto);
 				this .protoInterfaceElement (xmlElement); // parse fields
 				this .popParent ();
@@ -360,7 +509,7 @@ function ($,
 				externproto .url_ = this .url;
 				externproto .setup ();
 
-				this .getExecutionContext () .externprotos .add (name, externproto);	
+				this .getExecutionContext () .externprotos .add (name, externproto);
 			}
 		},
 		protoDeclareElement: function (xmlElement)
@@ -403,11 +552,13 @@ function ($,
 						case "ProtoBody":
 						case "PROTOBODY":
 						{
-							this .pushExecutionContext (proto);
+							this .pushPrototype (proto);
+							this .pushExecutionContext (proto .getBody ());
 							this .pushParent (proto);
 							this .protoBodyElement (child);
 							this .popParent ();
 							this .popExecutionContext ();
+							this .popPrototype ();
 							break;
 						}
 						default:
@@ -448,39 +599,39 @@ function ($,
 					return;
 
 				var node = this .getParent ();
-	
+
 				if (! (node instanceof X3DBaseNode))
 					return;
 
 				if (! node .hasUserDefinedFields ())
 					return;
-	
+
 				var accessType = AccessType [xmlElement .getAttribute ("accessType")];
-	
+
 				if (accessType === undefined)
 					accessType = X3DConstants .initializeOnly;
-	
+
 				var type = Fields [xmlElement .getAttribute ("type")];
-	
+
 				if (type === undefined)
 					return;
-	
+
 				var name = xmlElement .getAttribute ("name");
-	
+
 				if (! this .id (name))
 					return;
-	
+
 				var field = new type ();
-	
+
 				if (accessType & X3DConstants .initializeOnly)
 				{
 					this .fieldValue (field, xmlElement .getAttribute ("value"));
-	
+
 					this .pushParent (field);
 					this .childrenElements (xmlElement);
 					this .popParent ();
 				}
-	
+
 				node .addUserDefinedField (accessType, name, field);
 			}
 			catch (error)
@@ -494,7 +645,7 @@ function ($,
 		},
 		isElement: function (xmlElement)
 		{
-			if (this .getExecutionContext () instanceof X3DProtoDeclaration)
+			if (this .isInsideProtoDefinition ())
 			{
 				var childNodes = xmlElement .childNodes;
 
@@ -531,7 +682,7 @@ function ($,
 
 				var
 					node  = this .getParent (),
-					proto = this .getExecutionContext ();
+					proto = this .getPrototype ();
 
 				if (! (node instanceof X3DBaseNode))
 					return;
@@ -545,10 +696,10 @@ function ($,
 					if (protoField .isReference (nodeField .getAccessType ()))
 						nodeField .addReference (protoField);
 					else
-						throw new Error ("Field '" + nodeField .getName () + "' and '" + protoField .getName () + "' in PROTO " + this .getExecutionContext () . getName () + " are incompatible as an IS mapping.");
+						throw new Error ("Field '" + nodeField .getName () + "' and '" + protoField .getName () + "' in PROTO " + proto .getName () + " are incompatible as an IS mapping.");
 				}
 				else
-					throw new Error ("Field '" + nodeField .getName () + "' and '" + protoField .getName () + "' in PROTO " + this .getExecutionContext () .getName () + " have different types.");
+					throw new Error ("Field '" + nodeField .getName () + "' and '" + protoField .getName () + "' in PROTO " + this .proto .getName () + " have different types.");
 			}
 			catch (error)
 			{
@@ -568,6 +719,9 @@ function ($,
 				{
 					var node = this .getExecutionContext () .createProto (name, false);
 
+					if (! node)
+						throw new Error ("Unknown proto or externproto type '" + name + "'.");
+
 					//AP: attach node to DOM xmlElement for access from DOM.
 					xmlElement .x3d = node;
 
@@ -575,7 +729,10 @@ function ($,
 					this .addNode (xmlElement, node);
 					this .pushParent (node);
 					this .childrenElements (xmlElement);
-					this .getExecutionContext () .addUninitializedNode (node);
+
+					if (! this .isInsideProtoDefinition ())
+						node .setup ();
+
 					this .popParent ();
 				}
 			}
@@ -608,6 +765,11 @@ function ($,
 
 				if (accessType & X3DConstants .initializeOnly)
 				{
+					if (field .getType () === X3DConstants .MFNode)
+					{
+						field .length = 0
+					}
+
 					this .fieldValue (field, xmlElement .getAttribute ("value"));
 
 					this .pushParent (field);
@@ -629,6 +791,9 @@ function ($,
 
 				var node = this .getExecutionContext () .createNode (xmlElement .nodeName, false);
 
+				if (! node)
+					throw new Error ("Unknown node type '" + xmlElement .nodeName + "', you probably have insufficient component/profile statements.");
+
 				//AP: attach node to DOM xmlElement for access from DOM.
 				xmlElement .x3d = node;
 
@@ -637,11 +802,22 @@ function ($,
 				this .pushParent (node);
 				this .nodeAttributes (xmlElement, node);
 				this .childrenElements (xmlElement);
-				this .getExecutionContext () .addUninitializedNode (node);
+
+				if (! this .isInsideProtoDefinition ())
+					node .setup ();
+
 				this .popParent ();
 			}
 			catch (error)
 			{
+				// NULL
+
+				if (xmlElement .nodeName == "NULL")
+				{
+					this .addNode (xmlElement, null);
+					return;
+				}
+
 				//console .error (error);
 
 				console .error ("XML Parser Error: " + error .message);
@@ -679,6 +855,7 @@ function ($,
 			}
 			catch (error)
 			{
+				console .log (error);
 				console .warn ("XML Parser Error: " + error .message);
 			}
 		},
@@ -688,21 +865,21 @@ function ($,
 			{
 				var
 					inlineNodeName   = xmlElement .getAttribute ("inlineDEF"),
-					exportedNodeName = xmlElement .getAttribute ("exportedDEF"),
+					exportedNodeName = xmlElement .getAttribute ("importedDEF") || xmlElement .getAttribute ("exportedDEF"),
 					localNodeName    = xmlElement .getAttribute ("AS");
 
 				if (inlineNodeName === null)
-					throw new Error ("Bad IMPORT statement: Expected exportedDEF attribute.");
+					throw new Error ("Bad IMPORT statement: Expected inlineDEF attribute.");
 
 				if (exportedNodeName === null)
-					throw new Error ("Bad IMPORT statement: Expected exportedDEF attribute.");
+					throw new Error ("Bad IMPORT statement: Expected importedDEF attribute.");
 
 				if (! localNodeName)
 					localNodeName = exportedNodeName;
 
-				var namedNode = this .getExecutionContext () .getNamedNode (inlineNodeName);
+				var inlineNode = this .getExecutionContext () .getNamedNode (inlineNodeName);
 
-				this .getExecutionContext () .updateImportedNode (namedNode, exportedNodeName, localNodeName);
+				this .getExecutionContext () .updateImportedNode (inlineNode, exportedNodeName, localNodeName);
 			}
 			catch (error)
 			{
@@ -713,7 +890,7 @@ function ($,
 		{
 			try
 			{
-				if (this .scene !== this .getExecutionContext ())
+				if (this .getScene () !== this .getExecutionContext ())
 					return;
 
 				var
@@ -728,7 +905,7 @@ function ($,
 
 				var localNode = this .getExecutionContext () .getLocalNode (localNodeName);
 
-				this .scene .updateExportedNode (exportedNodeName, localNode);
+				this .getScene () .updateExportedNode (exportedNodeName, localNode);
 			}
 			catch (error)
 			{
@@ -749,7 +926,6 @@ function ($,
 				if (field)
 				{
 					field .push (xmlElement .data);
-					field .setSet (true);
 				}
 			}
 		},
@@ -810,9 +986,12 @@ function ($,
 		{
 			try
 			{
-				var field = node .getField (this .attributeToCamelCase (xmlAttribute .name));
+				var
+					field      = node .getField (this .attributeToCamelCase (xmlAttribute .name)),
+					accessType = field .getAccessType ();
 
-				this .fieldValue (field, xmlAttribute .value);
+				if (accessType & X3DConstants .initializeOnly)
+					this .fieldValue (field, xmlAttribute .value);
 			}
 			catch (error)
 			{
@@ -824,10 +1003,12 @@ function ($,
 			if (value === null)
 				return;
 
-			field .setSet (true);
+			this .parser .pushExecutionContext (this .getExecutionContext ());
 
 			this .parser .setInput (value);
 			this .fieldTypes [field .getType ()] .call (this .parser, field);
+
+			this .parser .popExecutionContext ();
 		},
 		addNode: function (xmlElement, node)
 		{
@@ -845,39 +1026,40 @@ function ($,
 				{
 					case X3DConstants .SFNode:
 						parent .setValue (node);
-						parent .setSet (true);
 						return;
 
 					case X3DConstants .MFNode:
 						parent .push (node);
-						parent .setSet (true);
 						return;
 				}
-					
+
 				return;
 			}
-				
+
 			// parent is a node.
 
 			try
 			{
 				var containerField = xmlElement .getAttribute ("containerField");
-				
+
 				if (! containerField)
-					containerField = node .getContainerField ();
-				
+				{
+					if (node)
+						containerField = node .getContainerField ();
+					else
+						throw new Error ("NULL node must have a container field attribute.");
+				}
+
 				var field = parent .getField (containerField);
 
 				switch (field .getType ())
 				{
 					case X3DConstants .SFNode:
 						field .setValue (node);
-						field .setSet (true);
 						return;
 
 					case X3DConstants .MFNode:
 						field .push (node);
-						field .setSet (true);
 						return;
 				}
 			}
@@ -886,29 +1068,13 @@ function ($,
 				//console .warn (error .message);
 			}
 		},
-		getBrowser: function ()
-		{
-			return this .scene .getBrowser ();
-		},
-		getExecutionContext: function ()
-		{
-			return this .executionContexts [this .executionContexts .length - 1];
-		},
-		pushExecutionContext: function (executionContext)
-		{
-			return this .executionContexts .push (executionContext);
-		},
-		popExecutionContext: function ()
-		{
-			this .executionContexts .pop ();
-		},
 		getParents: function ()
 		{
 			return this .parents;
 		},
 		getParent: function ()
 		{
-			return this .parents [this .parents .length - 1];
+			return this .parents .at (-1);
 		},
 		pushParent: function (parent)
 		{
@@ -930,12 +1096,10 @@ function ($,
 		},
 		attributeToCamelCase: function (name)
 		{
-			if (name !== name .toLowerCase())
-				return name ;
-			
-			return HTMLSupport .attributeLowerCaseToCamelCase [name] ;
+			// Function also needed by X_ITE DOM.
+			return HTMLSupport .fields .get (name);
 		},
-	};
+	});
 
 	XMLParser .prototype .fieldTypes = [ ];
 	XMLParser .prototype .fieldTypes [X3DConstants .SFBool]      = Parser .prototype .sfboolValue;
@@ -949,9 +1113,9 @@ function ($,
 	XMLParser .prototype .fieldTypes [X3DConstants .SFMatrix3d]  = Parser .prototype .sfmatrix3fValue;
 	XMLParser .prototype .fieldTypes [X3DConstants .SFMatrix4f]  = Parser .prototype .sfmatrix4dValue;
 	XMLParser .prototype .fieldTypes [X3DConstants .SFMatrix4d]  = Parser .prototype .sfmatrix4fValue;
-	XMLParser .prototype .fieldTypes [X3DConstants .SFNode]      = function (field) { field .set (null); };
+	XMLParser .prototype .fieldTypes [X3DConstants .SFNode]      = function (field) { field .setValue (null); };
 	XMLParser .prototype .fieldTypes [X3DConstants .SFRotation]  = Parser .prototype .sfrotationValue;
-	XMLParser .prototype .fieldTypes [X3DConstants .SFString]    = function (field) { field .set (this .input); };
+	XMLParser .prototype .fieldTypes [X3DConstants .SFString]    = function (field) { field .setValue (Fields .SFString .unescape (this .input)); };
 	XMLParser .prototype .fieldTypes [X3DConstants .SFTime]      = Parser .prototype .sftimeValue;
 	XMLParser .prototype .fieldTypes [X3DConstants .SFVec2d]     = Parser .prototype .sfvec2dValue;
 	XMLParser .prototype .fieldTypes [X3DConstants .SFVec2f]     = Parser .prototype .sfvec2fValue;
@@ -971,7 +1135,7 @@ function ($,
 	XMLParser .prototype .fieldTypes [X3DConstants .MFMatrix3f]  = Parser .prototype .sfmatrix3fValues;
 	XMLParser .prototype .fieldTypes [X3DConstants .MFMatrix4d]  = Parser .prototype .sfmatrix4dValues;
 	XMLParser .prototype .fieldTypes [X3DConstants .MFMatrix4f]  = Parser .prototype .sfmatrix4fValues;
-	XMLParser .prototype .fieldTypes [X3DConstants .MFNode]      = function () { };
+	XMLParser .prototype .fieldTypes [X3DConstants .MFNode]      = function (field) { field .length = 0; };
 	XMLParser .prototype .fieldTypes [X3DConstants .MFRotation]  = Parser .prototype .sfrotationValues;
 	XMLParser .prototype .fieldTypes [X3DConstants .MFString]    = Parser .prototype .sfstringValues;
 	XMLParser .prototype .fieldTypes [X3DConstants .MFTime]      = Parser .prototype .sftimeValues;
@@ -982,5 +1146,106 @@ function ($,
 	XMLParser .prototype .fieldTypes [X3DConstants .MFVec4d]     = Parser .prototype .sfvec4dValues;
 	XMLParser .prototype .fieldTypes [X3DConstants .MFVec4f]     = Parser .prototype .sfvec4fValues;
 
+	/*
+	 * Lazy parse functions.
+	 */
+
+	var
+		infs            = /\binf\b/g,
+		nans            = /\bnan\b/g,
+		trimWhitespaces = /^[\x20\n,\t\r"]+|[\x20\n,\t\r"]+$/g,
+		whitespaces     = /[\x20\n,\t\r"]+/,
+		strings         = new RegExp ('"((?:[^\\\\"]|\\\\\\\\|\\\\\\")*)"', 'g');
+
+   function prepareBools (string)
+	{
+		return string .replace (trimWhitespaces, "") .split (whitespaces);
+	}
+
+   function prepareFloats (string)
+	{
+		return (string
+			.replace (infs, "Infinity")
+			.replace (nans, "NaN")
+			.replace (trimWhitespaces, "")
+			.split (whitespaces));
+	}
+
+   function prepareInts (string)
+	{
+		return string .replace (trimWhitespaces, "") .split (whitespaces);
+	}
+
+   function prepareStrings (string)
+	{
+		var
+			match = null,
+			array = [ ];
+
+		while (match = strings .exec (string))
+			array .push (match [1]);
+
+		return array .map (Fields .SFString .unescape);
+	}
+
+	// Unitless fields.
+
+	XMLParser .prototype .fieldTypes [X3DConstants .MFColor] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFColorRGBA] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFMatrix3d] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFMatrix3f] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFMatrix4d] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFMatrix4f] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFVec4d] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFVec4f] = function (field)
+	{
+		field .setValue (prepareFloats (this .getInput ()) .map (function (value)
+		{
+			return parseFloat (value);
+		}));
+	};
+
+	XMLParser .prototype .fieldTypes [X3DConstants .MFBool] = function (field)
+	{
+		field .setValue (prepareBools (this .getInput ()) .map (function (value)
+		{
+			if (value === "true" || value === "TRUE")
+				return true;
+
+			return false;
+		}));
+	};
+
+	XMLParser .prototype .fieldTypes [X3DConstants .MFInt32] = function (field)
+	{
+		field .setValue (prepareInts (this .getInput ()) .map (function (value)
+		{
+			return parseInt (value);
+		}));
+	};
+
+	// Unit fields.
+
+	XMLParser .prototype .fieldTypes [X3DConstants .MFDouble] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFFloat] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFVec2d] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFVec2f] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFVec3d] =
+	XMLParser .prototype .fieldTypes [X3DConstants .MFVec3f] = function (field)
+	{
+		var category = field .getUnit ();
+
+		field .setValue (prepareFloats (this .getInput ()) .map (function (value)
+		{
+			return this .fromUnit (category, parseFloat (value));
+		},
+		this));
+	};
+
+	XMLParser .prototype .fieldTypes [X3DConstants .MFString] = function (field)
+	{
+		field .setValue (prepareStrings (this .getInput ()));
+	};
+
 	return XMLParser;
 });