JSONParser now use FileStream, fixed

samples/json/json.cpp

@@ -1,39 +1,65 @@
 #include <stdio.h>
 #include <string.h>
 #include "JSONParser.h"
+#include "Filesystem.h"
+#include "FileStream.h"
 
 using namespace crown;
 
 int main(int argc, char** argv)
 {
-	const char* src = "\"params1\": [1,2,3,4], \"params2\": [5,6,7,8]";
+	// const char* src = "\"test\":{\"params1\": [1,2,3,4], \"params2\": [5,6,7,8]}";
+	Filesystem conf_root("/home/mikymod/test");
 
+	if (!conf_root.exists("json.json"))
+	{
+		printf("Configuration file does not exists. Abort!\n");
+		return -1;
+	}
+	
 	char dst[10][256];
 
-	JSONParser* parser = new JSONParser();
+	FileStream* stream = (FileStream*)conf_root.open("json.json", SOM_READ);
+
+ 	JSONParser* parser = new JSONParser(stream);
+
 	json_error error;
 	JSONToken* tokens;
 
 	parser->init();
-	error = parser->parse(src);
+	error = parser->parse();
 	tokens = parser->get_tokens();
 
 	for (int i = 0; i < parser->get_tokens_number(); i++)
 	{
-		strncpy((char*)dst[i], &src[tokens[i].m_start], tokens[i].m_size);
-		dst[i][tokens[i].m_size] = '\0';
-
 		printf("token[%d]\n", i);
 		printf("type: %d\n", tokens[i].m_type);
 		printf("size: %d\n", tokens[i].m_size);
 		printf("start: %d\n",tokens[i].m_start);
 		printf("end: %d\n",tokens[i].m_end);
-		printf("parent: %d\n",tokens[i].m_parent);
-		printf("string: %s\n", dst[i]);
+		printf("parent token: %d\n",tokens[i].m_parent);
 		printf("\n");
 	}
 
+	// for (int i = 0; i < parser->get_tokens_number(); i++)
+	// {
+	// 	// strncpy((char*)dst[i], &src[tokens[i].m_start], tokens[i].m_size);
+	// 	dst[i][tokens[i].m_size] = '\0';
+
+	// 	printf("token[%d]\n", i);
+	// 	printf("type: %d\n", tokens[i].m_type);
+	// 	printf("size: %d\n", tokens[i].m_size);
+	// 	printf("start: %d\n",tokens[i].m_start);
+	// 	printf("end: %d\n",tokens[i].m_end);
+	// 	printf("parent token: %d\n",tokens[i].m_parent);
+	// 	printf("string: %s\n", dst[i]);
+	// 	printf("\n");
+	// }
+	// parser->shutdown();
+
 	printf("return: %d\n", error);
 
+	conf_root.close(stream);
+
 	return 0;
 }

src/JSONParser.cpp

@@ -1,10 +1,11 @@
 #include "JSONParser.h"
+#include "FileStream.h"
 
 namespace crown
 {
 
 //--------------------------------------------------------------------------
-JSONParser::JSONParser(size_t size)
+JSONParser::JSONParser(Stream* stream, size_t size)
 {
 	if (size > 1024)
 	{
@@ -16,38 +17,64 @@ JSONParser::JSONParser(size_t size)
 	}
 
 	m_size = size;
+
+	m_stream = stream;
 }
 
+//--------------------------------------------------------------------------
+JSONParser::~JSONParser()
+{
+	if (m_size > 1024)
+	{
+		delete m_tokens;
+	}
+	else
+	{
+		delete [] m_tokens_list;
+	}
+}
 //--------------------------------------------------------------------------
 void 
 JSONParser::init()
+{ 
+	m_pos = m_stream->position();
+	m_next_token = 0;
+	m_prev_token = -1;
+
+	is_init = true;
+}
+
+//--------------------------------------------------------------------------
+void
+JSONParser::shutdown()
 {
 	m_pos = 0;
 	m_next_token = 0;
 	m_prev_token = -1;
 
-	is_init = true;
+	is_init = false;
 }
 
 //--------------------------------------------------------------------------
 json_error 
-JSONParser::parse(const char* src)
+JSONParser::parse()
 {
-	json_error error;
-	JSONToken* token;
-
 	if (!is_init)
 	{
 		return JSON_NO_INIT; 
 	}
 
-	while(src[m_pos] != '\0')
+	json_error error;
+	JSONToken* token;
+
+	char c;
+
+	while(!m_stream->end_of_stream())
 	{
 		json_type type;
 
-		char c;
-
-		c = src[m_pos];
+		c = (char)m_stream->read_byte();
+		m_pos = m_stream->position();
 
 		switch(c)
 		{
@@ -106,11 +133,12 @@ JSONParser::parse(const char* src)
 				}
 
 				token->m_size = token->m_end - token->m_start;
+
 				break;
 			}
 			case '\"':
 			{
-				error = parse_string(src);
+				error = parse_string();
             	if (m_prev_token != -1)
             	{
             		m_tokens[m_prev_token].m_size++;
@@ -141,7 +169,7 @@ JSONParser::parse(const char* src)
             case 'f':
             case 'n':
             {
-            	error = parse_primitive(src);
+            	error = parse_primitive();
             	if (m_prev_token != -1)
             	{
             		m_tokens[m_prev_token].m_size++;
@@ -149,13 +177,14 @@ JSONParser::parse(const char* src)
             	break;
             }
 		}
-		m_pos++;
 	}
 
+	os::printf("PRE\n");
 	for (int i = m_next_token - 1; i >= 0; i--)
 	{
 		if (m_tokens[i].m_start != -1 && m_tokens[i].m_end == -1)
 		{
+			os::printf("DOH\n");
 			return JSON_INV_PART;
 		}
 	}
@@ -165,17 +194,18 @@ JSONParser::parse(const char* src)
 
 //--------------------------------------------------------------------------
 json_error
-JSONParser::parse_string(const char* src)
+JSONParser::parse_string()
 {
 	JSONToken* token;
 
 	int start = m_pos;
 
-	m_pos++;
+	char c; 
 
-	while(src[m_pos] != '\0')
+	while(!m_stream->end_of_stream())
 	{	
-		char c = src[m_pos];
+		c = (char) m_stream->read_byte();
+		m_pos = m_stream->position();
 
 		if (c == '\"' || c == '\'')
 		{
@@ -195,9 +225,10 @@ JSONParser::parse_string(const char* src)
 
 		if (c == '\\')
 		{
-			m_pos++;
+			c = (char)m_stream->read_byte();
+			m_pos = m_stream->position();
 
-			switch(src[m_pos])
+			switch(c)
 			{
 				case '\"': 
 				case '/' : 
@@ -207,23 +238,17 @@ JSONParser::parse_string(const char* src)
                 case 'r': 
                 case 'n': 
                 case 't':
+                case 'u':
                 {
                 	break;
                 }
-                case 'u' :
-                {
-                	// TODO
-                	break;
-                }
                 default:
                	{
                 	m_pos = start;
                 	return JSON_INV_CHAR;
-                	break;
                 }
 			}
 		}
-		m_pos++;
 	}
 	m_pos = start;
 	return JSON_INV_PART;
@@ -231,15 +256,18 @@ JSONParser::parse_string(const char* src)
 
 //--------------------------------------------------------------------------
 json_error
-JSONParser::parse_primitive(const char* src)
+JSONParser::parse_primitive()
 {
 	JSONToken* token;
 
-	int start = m_pos;
+	int start = m_stream->position();
 
-	while (src[m_pos] != '\0')
+	char c;
+
+	while (!m_stream->end_of_stream())
 	{
-		char c = src[m_pos];
+		c = (char)m_stream->read_byte();
+		m_pos = m_stream->position();
 
 		switch (c)
 		{
@@ -250,6 +278,7 @@ JSONParser::parse_primitive(const char* src)
 			case ']':
 			{
 				token = allocate_token();
+
 				if (token == NULL)
 				{
 					m_pos = start;
@@ -259,7 +288,8 @@ JSONParser::parse_primitive(const char* src)
 				fill_token(token, JSON_PRIMITIVE, start, m_pos);
 
 				token->m_parent = m_prev_token;
-				m_pos--;
+
+				m_stream->seek(start);
 
 				return JSON_SUCCESS;
 			}
@@ -270,8 +300,6 @@ JSONParser::parse_primitive(const char* src)
 			m_pos = start;
 			return JSON_INV_CHAR;
 		}
-
-		m_pos++;
 	}
 }
 

src/JSONParser.h

@@ -2,7 +2,7 @@
 
 #include "Types.h"
 #include "OS.h"
-
+#include "Stream.h"
 
 namespace crown
 {
@@ -48,15 +48,19 @@ class JSONParser
 {
 public:
 	/// Constructor
-					JSONParser(size_t size = 1024);
+					JSONParser(Stream* stream, size_t size = 1024);
+	/// Destructor
+					~JSONParser();
 	/// Init JSON parser, must be called for each different JSON string
 	void 			init();
+	/// Shutdown JSON parser
+	void			shutdown();
 	/// Parse JSON data
-	json_error 		parse(const char* src);
+	json_error 		parse();
 	/// Parse string in JSON data
-	json_error		parse_string(const char* src);
+	json_error		parse_string();
 	/// Parse number or boolean in JSON data
-	json_error		parse_primitive(const char* src);
+	json_error		parse_primitive();
 	/// Allocate token node
 	JSONToken* 		allocate_token();
 	/// Fill token and set boundaries
@@ -67,6 +71,8 @@ public:
 	int32_t			get_tokens_number();
 
 private:
+	/// JSON stream of data
+	Stream*			m_stream;
 	/// JSON string offset
 	uint32_t 		m_pos;
 	/// Next token to allocate