s2 0.1.0

data/ext/s2/s2_parse/Scanner.h

@@ -0,0 +1,263 @@
+
+
+#if !defined(S2_COCO_SCANNER_H__)
+#define S2_COCO_SCANNER_H__
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+
+// io.h and fcntl are used to ensure binary read from streams on windows
+#if _MSC_VER >= 1300
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+#if _MSC_VER >= 1400
+#define coco_swprintf swprintf_s
+#elif _MSC_VER >= 1300
+#define coco_swprintf _snwprintf
+#elif defined __MINGW32__
+#define coco_swprintf _snwprintf
+#else
+// assume every other compiler knows swprintf
+#define coco_swprintf swprintf
+#endif
+
+#define COCO_WCHAR_MAX 65535
+#define COCO_MIN_BUFFER_LENGTH 1024
+#define COCO_MAX_BUFFER_LENGTH (64*COCO_MIN_BUFFER_LENGTH)
+#define COCO_HEAP_BLOCK_SIZE (64*1024)
+#define COCO_CPP_NAMESPACE_SEPARATOR L':'
+
+namespace S2 {
+
+
+// string handling, wide character
+wchar_t* coco_string_create(const wchar_t *value);
+wchar_t* coco_string_create(const wchar_t *value, int startIndex);
+wchar_t* coco_string_create(const wchar_t *value, int startIndex, int length);
+wchar_t* coco_string_create_upper(const wchar_t* data);
+wchar_t* coco_string_create_lower(const wchar_t* data);
+wchar_t* coco_string_create_lower(const wchar_t* data, int startIndex, int dataLen);
+wchar_t* coco_string_create_append(const wchar_t* data1, const wchar_t* data2);
+wchar_t* coco_string_create_append(const wchar_t* data, const wchar_t value);
+void  coco_string_delete(wchar_t* &data);
+int   coco_string_length(const wchar_t* data);
+bool  coco_string_endswith(const wchar_t* data, const wchar_t *value);
+int   coco_string_indexof(const wchar_t* data, const wchar_t value);
+int   coco_string_lastindexof(const wchar_t* data, const wchar_t value);
+void  coco_string_merge(wchar_t* &data, const wchar_t* value);
+bool  coco_string_equal(const wchar_t* data1, const wchar_t* data2);
+int   coco_string_compareto(const wchar_t* data1, const wchar_t* data2);
+int   coco_string_hash(const wchar_t* data);
+
+// string handling, ascii character
+wchar_t* coco_string_create(const char *value);
+char* coco_string_create_char(const wchar_t *value);
+void  coco_string_delete(char* &data);
+
+
+class Token  
+{
+public:
+	int kind;     // token kind
+	int pos;      // token position in bytes in the source text (starting at 0)
+	int charPos;  // token position in characters in the source text (starting at 0)
+	int col;      // token column (starting at 1)
+	int line;     // token line (starting at 1)
+	wchar_t* val; // token value
+	Token *next;  // ML 2005-03-11 Peek tokens are kept in linked list
+
+	Token();
+	~Token();
+};
+
+class Buffer {
+// This Buffer supports the following cases:
+// 1) seekable stream (file)
+//    a) whole stream in buffer
+//    b) part of stream in buffer
+// 2) non seekable stream (network, console)
+private:
+	char *buf; // input buffer
+	int bufCapacity;    // capacity of buf
+	int bufStart;       // position of first byte in buffer relative to input stream
+	int bufLen;         // length of buffer
+	int fileLen;        // length of input stream (may change if the stream is no file)
+	int bufPos;         // current position in buffer
+	FILE* stream;       // input stream (seekable)
+	bool isUserStream;  // was the stream opened by the user?
+	
+	int ReadNextStreamChunk();
+	bool CanSeek();     // true if stream can be seeked otherwise false
+	
+public:
+	static const int EoF = COCO_WCHAR_MAX + 1;
+
+	Buffer(FILE* s, bool isUserStream);
+	Buffer(const char* buf, size_t len);
+	Buffer(Buffer *b);
+	virtual ~Buffer();
+	
+	virtual void Close();
+	virtual int Read();
+	virtual int Peek();
+	virtual wchar_t* GetString(int beg, int end);
+	virtual int GetPos();
+	virtual void SetPos(int value);
+};
+
+class UTF8Buffer : public Buffer {
+public:
+	UTF8Buffer(Buffer *b) : Buffer(b) {};
+	virtual int Read();
+};
+
+//-----------------------------------------------------------------------------------
+// StartStates  -- maps characters to start states of tokens
+//-----------------------------------------------------------------------------------
+class StartStates {
+private:
+	class Elem {
+	public:
+		int key, val;
+		Elem *next;
+		Elem(int key, int val) { this->key = key; this->val = val; next = NULL; }
+	};
+
+	Elem **tab;
+
+public:
+	StartStates() { tab = new Elem*[128]; memset(tab, 0, 128 * sizeof(Elem*)); }
+	virtual ~StartStates() {
+		for (int i = 0; i < 128; ++i) {
+			Elem *e = tab[i];
+			while (e != NULL) {
+				Elem *next = e->next;
+				delete e;
+				e = next;
+			}
+		}
+		delete [] tab;
+	}
+
+	void set(int key, int val) {
+		Elem *e = new Elem(key, val);
+		int k = ((unsigned int) key) % 128;
+		e->next = tab[k]; tab[k] = e;
+	}
+
+	int state(int key) {
+		Elem *e = tab[((unsigned int) key) % 128];
+		while (e != NULL && e->key != key) e = e->next;
+		return e == NULL ? 0 : e->val;
+	}
+};
+
+//-------------------------------------------------------------------------------------------
+// KeywordMap  -- maps strings to integers (identifiers to keyword kinds)
+//-------------------------------------------------------------------------------------------
+class KeywordMap {
+private:
+	class Elem {
+	public:
+		wchar_t *key;
+		int val;
+		Elem *next;
+		Elem(const wchar_t *key, int val) { this->key = coco_string_create(key); this->val = val; next = NULL; }
+		virtual ~Elem() { coco_string_delete(key); }
+	};
+
+	Elem **tab;
+
+public:
+	KeywordMap() { tab = new Elem*[128]; memset(tab, 0, 128 * sizeof(Elem*)); }
+	virtual ~KeywordMap() {
+		for (int i = 0; i < 128; ++i) {
+			Elem *e = tab[i];
+			while (e != NULL) {
+				Elem *next = e->next;
+				delete e;
+				e = next;
+			}
+		}
+		delete [] tab;
+	}
+
+	void set(const wchar_t *key, int val) {
+		Elem *e = new Elem(key, val);
+		int k = coco_string_hash(key) % 128;
+		e->next = tab[k]; tab[k] = e;
+	}
+
+	int get(const wchar_t *key, int defaultVal) {
+		Elem *e = tab[coco_string_hash(key) % 128];
+		while (e != NULL && !coco_string_equal(e->key, key)) e = e->next;
+		return e == NULL ? defaultVal : e->val;
+	}
+};
+
+class Scanner {
+private:
+	void *firstHeap;
+	void *heap;
+	void *heapTop;
+	void **heapEnd;
+
+	unsigned char EOL;
+	int eofSym;
+	int noSym;
+	int maxT;
+	StartStates start;
+	KeywordMap keywords;
+
+	Token *t;         // current token
+	wchar_t *tval;    // text of current token
+	int tvalLength;   // length of text of current token
+	int tlen;         // length of current token
+
+	Token *tokens;    // list of tokens already peeked (first token is a dummy)
+	Token *pt;        // current peek token
+
+	int ch;           // current input character
+
+	int pos;          // byte position of current character
+	int charPos;      // position by unicode characters starting with 0
+	int line;         // line number of current character
+	int col;          // column number of current character
+	int oldEols;      // EOLs that appeared in a comment;
+
+	void CreateHeapBlock();
+	Token* CreateToken();
+	void AppendVal(Token *t);
+	void SetScannerBehindT();
+
+	void Init();
+	void NextCh();
+	void AddCh();
+	bool Comment0();
+	bool Comment1();
+
+	Token* NextToken();
+
+public:
+	Buffer *buffer;   // scanner buffer
+	
+	Scanner(const char* buf, size_t len);
+	Scanner(const wchar_t* fileName);
+	Scanner(FILE* s);
+	~Scanner();
+	Token* Scan();
+	Token* Peek();
+	void ResetPeek();
+
+}; // end Scanner
+
+} // namespace
+
+
+#endif
+

data/ext/s2/s2_parse/extconf.rb

@@ -0,0 +1,5 @@
+require "mkmf"
+
+have_library( 'stdc++' );
+$CXXFLAGS<< "-g -Wall -std=gnu++11"
+create_makefile( 's2_parse/s2_parse' );

data/ext/s2/s2_parse/parse_s2.cpp

@@ -0,0 +1,630 @@
+
+#include "parse_s2.hpp"
+
+/*
+	WARNING: This file is generated using ruco. Please modify the .ruco file if you wish to change anything
+	https://github.com/davidsiaw/ruco
+*/
+
+namespace S2
+{
+	S2Ptr Parse(std::string sourceFile)
+	{
+		std::shared_ptr<FILE> fp (fopen(sourceFile.c_str(), "r"), fclose);
+		if (!fp)
+		{
+			throw FileNotFoundException();
+		}
+		std::shared_ptr<Scanner> scanner (new Scanner(fp.get()));
+		std::shared_ptr<Parser> parser (new Parser(scanner.get()));
+		parser->Parse();
+
+		return parser->s2;
+	}
+
+	picojson::object CompileS2(S2Ptr pointer);
+	picojson::object CompileTypeVariable(TypeVariablePtr pointer);
+	picojson::object CompileStructName(StructNamePtr pointer);
+	picojson::object CompileMemberName(MemberNamePtr pointer);
+	picojson::object CompileNumberLiteral(NumberLiteralPtr pointer);
+	picojson::object CompileStringLiteral(StringLiteralPtr pointer);
+	picojson::object CompileTypeIdentifier(TypeIdentifierPtr pointer);
+	picojson::object CompileTypeExpression(TypeExpressionPtr pointer);
+	picojson::object CompileTypeParameterArguments(TypeParameterArgumentsPtr pointer);
+	picojson::object CompileTypeDeclaration(TypeDeclarationPtr pointer);
+	picojson::object CompileTypeParameters(TypeParametersPtr pointer);
+	picojson::object CompileNumberLit(NumberLitPtr pointer);
+	picojson::object CompileExpression(ExpressionPtr pointer);
+	picojson::object CompileAttributeParam(AttributeParamPtr pointer);
+	picojson::object CompileAttributeParamList(AttributeParamListPtr pointer);
+	picojson::object CompileAttribute(AttributePtr pointer);
+	picojson::object CompileMember(MemberPtr pointer);
+	picojson::object CompileStructure(StructurePtr pointer);
+	picojson::object CompileImport(ImportPtr pointer);
+	picojson::object CompileStatement(StatementPtr pointer);
+
+	picojson::object CompileS2(S2Ptr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"S2");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>3, :type=>:id}
+
+		picojson::array statements;
+
+		for(unsigned i=0; i<pointer->statements.size(); i++)
+		{
+			statements.push_back(picojson::value(CompileStatement(pointer->statements[i])));
+		}
+
+		object[L"statements"] = picojson::value(statements);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileTypeVariable(TypeVariablePtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"TypeVariable");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:token}
+		object[L"_token"] = picojson::value(pointer->content);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileStructName(StructNamePtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"StructName");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:token}
+		object[L"_token"] = picojson::value(pointer->content);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileMemberName(MemberNamePtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"MemberName");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:token}
+		object[L"_token"] = picojson::value(pointer->content);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileNumberLiteral(NumberLiteralPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"NumberLiteral");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:token}
+		object[L"_token"] = picojson::value(pointer->content);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileStringLiteral(StringLiteralPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"StringLiteral");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:token}
+		object[L"_token"] = picojson::value(pointer->content);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileTypeIdentifier(TypeIdentifierPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"TypeIdentifier");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:id}
+		if (pointer->structname)
+		{
+			picojson::object structname;
+
+			structname = CompileStructName(pointer->structname);
+
+			object[L"structname"] = picojson::value(structname);
+		}
+		// {:count=>1, :type=>:id}
+		if (pointer->typevariable)
+		{
+			picojson::object typevariable;
+
+			typevariable = CompileTypeVariable(pointer->typevariable);
+
+			object[L"typevariable"] = picojson::value(typevariable);
+		}
+		// {:count=>3, :type=>:id}
+
+		picojson::array typeparameterarguments;
+
+		for(unsigned i=0; i<pointer->typeparameterarguments.size(); i++)
+		{
+			typeparameterarguments.push_back(picojson::value(CompileTypeParameterArguments(pointer->typeparameterarguments[i])));
+		}
+
+		object[L"typeparameterarguments"] = picojson::value(typeparameterarguments);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileTypeExpression(TypeExpressionPtr pointer)
+	{
+		picojson::object object;
+
+		// variation
+		object[L"_type"] = picojson::value(L"TypeExpression");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		picojson::object content;
+		switch(pointer->get_typeexpression_type())
+		{
+			case TYPEIDENTIFIER_TYPEEXPRESSION:
+			{
+				content = CompileTypeIdentifier(std::dynamic_pointer_cast<TypeIdentifier>(pointer));
+				break;
+			}
+
+		}
+
+		object[L"_content"] = picojson::value(content);
+
+		return object;
+	}
+
+	picojson::object CompileTypeParameterArguments(TypeParameterArgumentsPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"TypeParameterArguments");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>3, :type=>:id}
+
+		picojson::array typeexpressions;
+
+		for(unsigned i=0; i<pointer->typeexpressions.size(); i++)
+		{
+			typeexpressions.push_back(picojson::value(CompileTypeExpression(pointer->typeexpressions[i])));
+		}
+
+		object[L"typeexpressions"] = picojson::value(typeexpressions);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileTypeDeclaration(TypeDeclarationPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"TypeDeclaration");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:id}
+		if (pointer->structname)
+		{
+			picojson::object structname;
+
+			structname = CompileStructName(pointer->structname);
+
+			object[L"structname"] = picojson::value(structname);
+		}
+		// {:count=>3, :type=>:id}
+
+		picojson::array typeparameters;
+
+		for(unsigned i=0; i<pointer->typeparameters.size(); i++)
+		{
+			typeparameters.push_back(picojson::value(CompileTypeParameters(pointer->typeparameters[i])));
+		}
+
+		object[L"typeparameters"] = picojson::value(typeparameters);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileTypeParameters(TypeParametersPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"TypeParameters");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>3, :type=>:id}
+
+		picojson::array typevariables;
+
+		for(unsigned i=0; i<pointer->typevariables.size(); i++)
+		{
+			typevariables.push_back(picojson::value(CompileTypeVariable(pointer->typevariables[i])));
+		}
+
+		object[L"typevariables"] = picojson::value(typevariables);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileNumberLit(NumberLitPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"NumberLit");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:id}
+		if (pointer->numberliteral)
+		{
+			picojson::object numberliteral;
+
+			numberliteral = CompileNumberLiteral(pointer->numberliteral);
+
+			object[L"numberliteral"] = picojson::value(numberliteral);
+		}
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileExpression(ExpressionPtr pointer)
+	{
+		picojson::object object;
+
+		// variation
+		object[L"_type"] = picojson::value(L"Expression");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		picojson::object content;
+		switch(pointer->get_expression_type())
+		{
+			case NUMBERLIT_EXPRESSION:
+			{
+				content = CompileNumberLit(std::dynamic_pointer_cast<NumberLit>(pointer));
+				break;
+			}
+
+		}
+
+		object[L"_content"] = picojson::value(content);
+
+		return object;
+	}
+
+	picojson::object CompileAttributeParam(AttributeParamPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"AttributeParam");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:id}
+		if (pointer->membername)
+		{
+			picojson::object membername;
+
+			membername = CompileMemberName(pointer->membername);
+
+			object[L"membername"] = picojson::value(membername);
+		}
+		// {:count=>1, :type=>:id}
+		if (pointer->expression)
+		{
+			picojson::object expression;
+
+			expression = CompileExpression(pointer->expression);
+
+			object[L"expression"] = picojson::value(expression);
+		}
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileAttributeParamList(AttributeParamListPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"AttributeParamList");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>3, :type=>:id}
+
+		picojson::array attributeparams;
+
+		for(unsigned i=0; i<pointer->attributeparams.size(); i++)
+		{
+			attributeparams.push_back(picojson::value(CompileAttributeParam(pointer->attributeparams[i])));
+		}
+
+		object[L"attributeparams"] = picojson::value(attributeparams);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileAttribute(AttributePtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"Attribute");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:id}
+		if (pointer->typeexpression)
+		{
+			picojson::object typeexpression;
+
+			typeexpression = CompileTypeExpression(pointer->typeexpression);
+
+			object[L"typeexpression"] = picojson::value(typeexpression);
+		}
+		// {:count=>3, :type=>:id}
+
+		picojson::array attributeparamlists;
+
+		for(unsigned i=0; i<pointer->attributeparamlists.size(); i++)
+		{
+			attributeparamlists.push_back(picojson::value(CompileAttributeParamList(pointer->attributeparamlists[i])));
+		}
+
+		object[L"attributeparamlists"] = picojson::value(attributeparamlists);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileMember(MemberPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"Member");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>3, :type=>:id}
+
+		picojson::array attributes;
+
+		for(unsigned i=0; i<pointer->attributes.size(); i++)
+		{
+			attributes.push_back(picojson::value(CompileAttribute(pointer->attributes[i])));
+		}
+
+		object[L"attributes"] = picojson::value(attributes);
+		// {:count=>1, :type=>:id}
+		if (pointer->typeidentifier)
+		{
+			picojson::object typeidentifier;
+
+			typeidentifier = CompileTypeIdentifier(pointer->typeidentifier);
+
+			object[L"typeidentifier"] = picojson::value(typeidentifier);
+		}
+		// {:count=>3, :type=>:id}
+
+		picojson::array membernames;
+
+		for(unsigned i=0; i<pointer->membernames.size(); i++)
+		{
+			membernames.push_back(picojson::value(CompileMemberName(pointer->membernames[i])));
+		}
+
+		object[L"membernames"] = picojson::value(membernames);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileStructure(StructurePtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"Structure");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>3, :type=>:id}
+
+		picojson::array attributes;
+
+		for(unsigned i=0; i<pointer->attributes.size(); i++)
+		{
+			attributes.push_back(picojson::value(CompileAttribute(pointer->attributes[i])));
+		}
+
+		object[L"attributes"] = picojson::value(attributes);
+		// {:count=>1, :type=>:id}
+		if (pointer->typedeclaration)
+		{
+			picojson::object typedeclaration;
+
+			typedeclaration = CompileTypeDeclaration(pointer->typedeclaration);
+
+			object[L"typedeclaration"] = picojson::value(typedeclaration);
+		}
+		// {:count=>4, :type=>:id}
+
+		picojson::array members;
+
+		for(unsigned i=0; i<pointer->members.size(); i++)
+		{
+			members.push_back(picojson::value(CompileMember(pointer->members[i])));
+		}
+
+		object[L"members"] = picojson::value(members);
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileImport(ImportPtr pointer)
+	{
+		picojson::object object;
+
+		// normal
+		object[L"_type"] = picojson::value(L"Import");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		
+
+		// {:count=>1, :type=>:id}
+		if (pointer->stringliteral)
+		{
+			picojson::object stringliteral;
+
+			stringliteral = CompileStringLiteral(pointer->stringliteral);
+
+			object[L"stringliteral"] = picojson::value(stringliteral);
+		}
+
+
+
+
+		return object;
+	}
+
+	picojson::object CompileStatement(StatementPtr pointer)
+	{
+		picojson::object object;
+
+		// variation
+		object[L"_type"] = picojson::value(L"Statement");
+		object[L"_col"] = picojson::value((double)pointer->_col);
+		object[L"_line"] = picojson::value((double)pointer->_line);
+		picojson::object content;
+		switch(pointer->get_statement_type())
+		{
+			case STRUCTURE_STATEMENT:
+			{
+				content = CompileStructure(std::dynamic_pointer_cast<Structure>(pointer));
+				break;
+			}
+			case IMPORT_STATEMENT:
+			{
+				content = CompileImport(std::dynamic_pointer_cast<Import>(pointer));
+				break;
+			}
+
+		}
+
+		object[L"_content"] = picojson::value(content);
+
+		return object;
+	}
+
+
+
+	picojson::value Jsonify(S2Ptr parseResult)
+	{
+		return picojson::value(CompileS2(parseResult));
+	}
+
+}
+