parse_bool and parse_number methods implemented in JSONParser, TODO: fix some bugs

src/Device.cpp

@@ -529,9 +529,7 @@ void Device::read_engine_settings()
 	DiskFile* file = m_filesystem->open("crown.cfg", FOM_READ);
 	JSONParser json(file);
 	
-	// const char* value = json.get_array("crown").get_object("utils").get_string("file").to_string();
-
-	// os::printf("Value:\t%s\n", value);
+	json.get_array("crown");
 }
 
 

src/JSONParser.cpp

@@ -67,10 +67,8 @@ JSONError JSONParser::parse()
 			{
 				token = allocate_token();
 
-				if (token == NULL)
-				{
-					return JSON_NO_MEMORY;
-				}
+				assert(token != NULL);
+
 				if (m_prev_token != -1)
 				{
 					m_tokens[m_prev_token].m_size++;
@@ -88,10 +86,7 @@ JSONError JSONParser::parse()
 			{
 				type = c == '}' ? JSON_OBJECT : JSON_ARRAY;
 
-				if (m_next_token < 1)
-				{
-					return JSON_INV_CHAR;
-				}
+				assert(m_next_token > 0);
 
 				token = &m_tokens[m_next_token - 1];
 
@@ -99,12 +94,14 @@ JSONError JSONParser::parse()
 				{
 					if (token->m_start != -1 && token->m_end == -1)
 					{
-						if (token->m_type != type)
-						{
-							return JSON_INV_CHAR;
-						}
+						// FIXME
+						os::printf("Token:%s\n", token->m_value);
+						os::printf("previous:%d\ncurrent:%d\n", token->m_type, type);
+						assert(token->m_type == type);
+						
 						token->m_end = m_pos + 1;
 						m_prev_token = token->m_parent;
+
 						break;
 					}
 
@@ -123,7 +120,7 @@ JSONError JSONParser::parse()
 			case '\"':
 			case '\'':
 			{
-				error = parse_string();
+				parse_string();
             	if (m_prev_token != -1)
             	{
             		m_tokens[m_prev_token].m_size++;
@@ -153,16 +150,27 @@ JSONError JSONParser::parse()
             case '7':
             case '8':
             case '9':
-            case 't':
-            case 'f':
-            case 'n':
             {
-            	error = parse_primitive();
+            	parse_number();
+            	if (m_prev_token != -1)
+            	{
+            		m_tokens[m_prev_token].m_size++;
+            	}
+            	break;
+            }
+            case 't':	// true
+            case 'f':	// false
+            {
+            	parse_bool();
             	if (m_prev_token != -1)
             	{
             		m_tokens[m_prev_token].m_size++;
             	}
             	break;
+            }
+            case 'n':	// null
+            {
+            	break;
             }
 		}
 	}
@@ -171,7 +179,7 @@ JSONError JSONParser::parse()
 	{
 		if (m_tokens[i].m_start != -1 && m_tokens[i].m_end == -1)
 		{
-			return JSON_INV_PART;
+			assert(false); // FIXME
 		}
 	}
 
@@ -179,7 +187,7 @@ JSONError JSONParser::parse()
 }
 
 //--------------------------------------------------------------------------
-JSONError JSONParser::parse_string()
+void JSONParser::parse_string()
 {
 	JSONToken* token;
 
@@ -196,16 +204,12 @@ JSONError JSONParser::parse_string()
 		{
 			token = allocate_token();
 
-			if (token == NULL)
-			{
-				m_pos = start;
-				return JSON_NO_MEMORY;
-			}
+			assert(token != NULL);
 
 			fill_token(token, JSON_STRING, start + 1, m_pos);
 			token->m_parent = m_prev_token;
 
-			return JSON_SUCCESS;
+			return;
 		}
 
 		if (c == '\\')
@@ -229,21 +233,18 @@ JSONError JSONParser::parse_string()
                 }
                 default:
                	{
-                	m_pos = start;
-                	return JSON_INV_CHAR;
+                	assert(false);
                 }
 			}
 		}
 	}
 	m_pos = start;
-	return JSON_INV_PART;
 }
 
 //--------------------------------------------------------------------------
-JSONError JSONParser::parse_primitive()
+void JSONParser::parse_number()
 {
 	JSONToken* token;
-	JSONType type = JSON_INT;
 
 	int start = m_file->position();
 
@@ -256,17 +257,6 @@ JSONError JSONParser::parse_primitive()
 
 		switch (c)
 		{
-			case '.':
-			{
-				type = JSON_FLOAT;
-				break;
-			}
-			case 'r':
-			case 'a':
-			{
-				type = JSON_BOOL;
-				break;
-			}
 			case ' ':
 			case ',': 
 			case '}':
@@ -274,28 +264,59 @@ JSONError JSONParser::parse_primitive()
 			{
 				token = allocate_token();
 
-				if (token == NULL)
-				{
-					m_pos = start;
-					return JSON_NO_MEMORY;
-				}
-
-				fill_token(token, type, start, m_pos);
+				assert(token != NULL);
+				
+				fill_token(token, JSON_NUMBER, start, m_pos);
 
 				token->m_parent = m_prev_token;
 
-				// m_file->seek(start);
+				//m_file->seek(start);
 
-				return JSON_SUCCESS;
+				return;
 			}
 		}
 
-		if (c < 32 || c >= 127)
+		assert(c >= 32 || c < 127);
+	}
+}
+
+//--------------------------------------------------------------------------
+void JSONParser::parse_bool()
+{
+	JSONToken* token;
+
+	int start = m_file->position();
+
+	char c;
+
+	while (!m_file->end_of_file())
+	{
+		m_file->read(&c, 1);
+		m_pos = m_file->position();
+
+		switch (c)
 		{
-			m_pos = start;
-			return JSON_INV_CHAR;
+			case ' ':
+			case ',': 
+			case '}':
+			case ']':
+			{
+				token = allocate_token();
+
+				assert(token != NULL);
+				
+				fill_token(token, JSON_BOOL, start, m_pos);
+
+				token->m_parent = m_prev_token;
+
+				m_file->seek(start);
+
+				return;
+			}
 		}
-	}
+
+		assert(c >= 32 || c < 127);
+	}	
 }
 
 //--------------------------------------------------------------------------
@@ -338,18 +359,6 @@ void JSONParser::fill_token(JSONToken* token, JSONType type, int32_t start, int3
 	m_file->seek(cur_pos);
 }
 
-//--------------------------------------------------------------------------
-JSONToken* JSONParser::get_tokens()
-{
-	return m_tokens_list;
-}
-
-//--------------------------------------------------------------------------
-int32_t JSONParser::get_tokens_number()
-{
-	return m_next_token;
-}
-
 //--------------------------------------------------------------------------
 JSONParser&	JSONParser::get_object(const char* key)
 {
@@ -413,7 +422,7 @@ JSONParser& JSONParser::get_array(const char* key)
 			break;
 		}
 	}
-	// Incremente nodes count for the next token
+	// Increment nodes count for the next token
 	m_nodes_count++;
 
 	return *this;
@@ -448,34 +457,72 @@ JSONParser&	JSONParser::get_string(const char* key)
 			break;
 		}
 	}
-	// Incremente nodes count for the next token
+	// Increment nodes count for the next token
 	m_nodes_count++;
 
 	return *this;
 }
 
 //--------------------------------------------------------------------------
-JSONParser& JSONParser::get_float(const char* key)
+JSONParser& JSONParser::get_number(const char* key)
 {
+	int32_t begin = m_nodes_count != 0 ? m_nodes[m_nodes_count-1].m_id : 0;
 
-}
+	for (int i = begin; i < m_next_token; i++)
+	{
+		if ((string::strcmp(m_tokens[i].m_value, key) == 0)	&& m_tokens[i].m_type == JSON_STRING)
+		{
+			assert(m_tokens[i+1].m_type == JSON_NUMBER);
 
-//--------------------------------------------------------------------------
-JSONParser&	JSONParser::get_int(const char* key)
-{
+			m_nodes[m_nodes_count].m_id = m_tokens[i+1].m_id;	
+			m_nodes[m_nodes_count].m_type = JSON_NUMBER;
+			m_nodes[m_nodes_count].print();
+
+			if (m_tokens[i+1].has_parent())
+			{
+				assert(m_nodes_count && m_nodes[m_nodes_count-1].m_id == m_tokens[i+1].m_parent);
+			}
 
+			break;
+		}
+	}
+	m_nodes_count++;
+
+	return *this;
 }
 
 //--------------------------------------------------------------------------
 JSONParser& JSONParser::get_bool(const char* key)
 {
+	int32_t begin = m_nodes_count != 0 ? m_nodes[m_nodes_count-1].m_id : 0;
 
-}
+	for (int i = begin; i < m_next_token; i++)
+	{
+		if ((string::strcmp(m_tokens[i].m_value, key) == 0)	&& m_tokens[i].m_type == JSON_STRING)
+		{
+			assert(m_tokens[i+1].m_type == JSON_BOOL);
 
-const char* JSONParser::to_string()
-{
-	return m_tokens[m_nodes[m_nodes_count-1].m_id].m_value;
+			m_nodes[m_nodes_count].m_id = m_tokens[i+1].m_id;	
+			m_nodes[m_nodes_count].m_type = JSON_BOOL;
+			m_nodes[m_nodes_count].print();
+
+			if (m_tokens[i+1].has_parent())
+			{
+				assert(m_nodes_count && m_nodes[m_nodes_count-1].m_id == m_tokens[i+1].m_parent);
+			}
+
+			break;
+		}
+	}
+	m_nodes_count++;
+
+	return *this;
 }
 
+// const char* JSONParser::to_string()
+// {
+// 	return m_tokens[m_nodes[m_nodes_count-1].m_id].m_value;
+// }
+
 
 } //namespace crown

src/JSONParser.h

@@ -13,13 +13,11 @@ namespace crown
 /// JSON Token types
 enum JSONType
 {
-	JSON_PRIMITIVE 	= 0,	// Number, boolean or null
-	JSON_OBJECT 	= 1,	// Object
-	JSON_ARRAY 		= 2,	// Array
-	JSON_STRING 	= 3,
-	JSON_FLOAT		= 4,
-	JSON_INT		= 5,
-	JSON_BOOL 		= 6,
+	JSON_OBJECT 	= 0,	// Object
+	JSON_ARRAY 		= 1,	// Array
+	JSON_STRING 	= 2,	// String
+	JSON_NUMBER		= 3,	// Number
+	JSON_BOOL 		= 4		// Boolean
 
 };
 
@@ -94,9 +92,7 @@ public:
 
 	JSONParser& 	get_string(const char* key);
 
-	JSONParser&		get_float(const char* key);				// MUST BE IMPLEMENTED
-
-	JSONParser&		get_int(const char* key);				// MUST BE IMPLEMENTED
+	JSONParser&		get_number(const char* key);			// MUST BE IMPLEMENTED
 
 	JSONParser&		get_bool(const char* key);				// MUST BE IMPLEMENTED
 
@@ -111,20 +107,12 @@ public:
 private:
 	/// Parse JSON data and fill tokens
 	JSONError 		parse();
-	/// Get all tokens
-	JSONToken*		get_tokens();			// MUST BE REMOVED
-	/// Get next token
-	int32_t			get_tokens_number();	// MUST BE REMOVED
 	/// Parse string in JSON data
-	JSONError		parse_string();
-	/// Parse number or boolean in JSON data
-	JSONError		parse_primitive();	// MUST BE REMOVED
+	void			parse_string();
 	/// Parse boolean in JSON data
-	JSONError		parse_bool();	// MUST BE IMPLEMENTED
-	/// Parse integer in JSON data
-	JSONError		parse_int();	// MUST BE IMPLEMENTED
+	void			parse_bool();			// MUST BE IMPLEMENTED
 	/// Parse float in JSON data
-	JSONError		parse_float();	// MUST BE IMPLEMENTED
+	void			parse_number();			// MUST BE IMPLEMENTED
 	/// Allocate token node
 	JSONToken* 		allocate_token();
 	/// Fill token and set boundaries