/// <summary>
		///		Interpreta un nodo
		/// </summary>
		private MLNode ParseNode(string strName, ParserTokenizer objTokenizer, bool blnSearchBracket)
		{ MLNode objMLNode = new MLNode(strName);

				// Captura el siguiente nodo
					if (!objTokenizer.IsEof())
						{ if (blnSearchBracket)
								{	// Obtiene el siguiente token
										GetNextToken(objTokenizer);
									// Debería ser una llave de apertura
										if (intIDActualType == TokenType.BraceOpen)
											objMLNode.Nodes.Add(ParseNodesArray(objTokenizer));
										else if (intIDActualType != TokenType.BracketOpen)
											throw new ParserException("Se esperaba una llave de apertura");
										else
											ParseNodeAttributes(objTokenizer, objMLNode);
								}
							else
								ParseNodeAttributes(objTokenizer, objMLNode);
						}
				// Devuelve el nodo interpretado
					return objMLNode;
		}
		/// <summary>
		///		Interpreta los atributos de un nodo "id":"value","id":"value", ... ó "id":{object} ó "id":[array]
		/// </summary>
		private void ParseNodeAttributes(ParserTokenizer objTokenizer, MLNode objMLNodeParent)
		{ bool blnEnd = false;

				// Obtiene los nodos
					while (!objTokenizer.IsEof() && !blnEnd)		
						{ // Lee el siguiente Token, debería ser un identificador
								GetNextToken(objTokenizer);
							// Comprueba que sea correcto
								if (intIDActualType == TokenType.BracketClose) // ... es un objeto vacío
									blnEnd = true;
								else if (intIDActualType != TokenType.String) // ... no se ha encontrado el identificador
									throw new ParserException("Se esperaba el identificador del elemento");
								else
									{ MLAttribute objMLAttribute = new MLAttribute();

											// Asigna el código del atributo
												objMLAttribute.Name = objActualToken.Lexema;
											// Lee el siguiente token. Deberían ser dos puntos
												GetNextToken(objTokenizer);
											// Comprueba que sea correcto
												if (intIDActualType != TokenType.Colon)
													throw new ParserException("Se esperaban dos puntos (separador de identificador / valor)");
												else
													{ // Lee el siguiente token...
															GetNextToken(objTokenizer);
														// Interpreta el valor
															switch (intIDActualType)
																{ case TokenType.String:
																	case TokenType.True:
																	case TokenType.False:
																	case TokenType.Numeric:
																	case TokenType.Null:
																			// Asigna el valor al atributo
																				switch (intIDActualType)
																					{ case TokenType.Null:
																								objMLAttribute.Value = "";
																							break;
																						case TokenType.String:
																								objMLAttribute.Value = ParseUnicode(objActualToken.Lexema);
																							break;
																						default:
																								objMLAttribute.Value = objActualToken.Lexema;
																							break;
																					}
																			// Añade el atributo al nodo
																				objMLNodeParent.Attributes.Add(objMLAttribute);
																		break;
																	case TokenType.BracketOpen: // ... definición de objeto
																			MLNode objMLNode = ParseNode(objMLAttribute.Name, objTokenizer, false);

																				// Añade el nodo como objeto
																					objMLNodeParent.Nodes.Add(objMLNode);
																		break;
																	case TokenType.BraceOpen: // ... definición de array
																			objMLNodeParent.Nodes.Add(ParseNodesArray(objMLAttribute.Name, objTokenizer));
																		break;
																	default:
																		throw new ParserException("Cadena desconocida. " + objActualToken.Lexema);
																}
													}
											// Lee el siguiente token
												GetNextToken(objTokenizer);
											// Si es una coma, seguir con el siguiente atributo del nodo, si es una llave de cierre, terminar
												switch (intIDActualType)
													{ case TokenType.Comma:
																// ... no hace nada, simplemente pasa a la creación del siguiente nodo
															break;
														case TokenType.BracketClose:
																blnEnd = true;
															break;
														default:
															throw new ParserException("Cadena desconocida. " + objActualToken.Lexema);
													}
									}
						}
		}
		/// <summary>
		///		Interpreta los nodos de un array
		/// </summary>
		private MLNode ParseNodesArray(string strNodeParent, ParserTokenizer objTokenizer)
		{ MLNode objMLNode = new MLNode(strNodeParent);
			bool blnEnd = false;
			int intIndex = 0;

				// Obtiene el siguiente token (puede que se trate de un array vacío)
					while (!objTokenizer.IsEof() && !blnEnd)
						{ // Obtiene el siguiente token
								GetNextToken(objTokenizer);
							// Interpreta el nodo
								switch (intIDActualType)
									{ case TokenType.BracketOpen:
												objMLNode.Nodes.Add(ParseNode("Struct", objTokenizer, false));
											break;
										case TokenType.BraceOpen:
												objMLNode.Nodes.Add(ParseNodesArray(objTokenizer));
											break;
										case TokenType.String:
										case TokenType.Numeric:
										case TokenType.True:
										case TokenType.False:
										case TokenType.Null:
												objMLNode.Nodes.Add("Item", objActualToken.Lexema);
											break;
										case TokenType.Comma: // ... no hace nada, simplemente pasa al siguiente incrementando el índice
												intIndex++;
											break;
										case TokenType.BraceClose: // ... corchete de cierre, indica que ha terminado
												blnEnd = true;
											break;
										default:
											throw new NotImplementedException("No se ha encontrado un token válido ('" + objActualToken.Lexema + "')");
									}
						}
				// Si no se ha encontrado un corchete, lanza una excepción
					if (!blnEnd)
						throw new ParserException("No se ha encontrado el carácter de fin del array ']'");
				// Devuelve la colección de nodos
					return objMLNode;
		}