GODOT IS OPEN SOURCE

3 files changed, 1218 insertions, 0 deletions

diff --git a/tools/doc/SCsub b/tools/doc/SCsub
new file mode 100644
index 0000000000..c8eaa596d1
--- /dev/null
+++ b/tools/doc/SCsub
@@ -0,0 +1,7 @@
+Import('env')
+
+env.add_source_files(env.tool_sources,"*.cpp")
+
+Export('env')
+
+
diff --git a/tools/doc/doc_data.cpp b/tools/doc/doc_data.cpp
new file mode 100644
index 0000000000..d3192735e6
--- /dev/null
+++ b/tools/doc/doc_data.cpp
@@ -0,0 +1,1112 @@
+/*************************************************************************/
+/*  doc_data.cpp                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "version.h"
+#include "doc_data.h"
+#include "io/xml_parser.h"
+#include "global_constants.h"
+#include "globals.h"
+#include "script_language.h"
+#include "io/marshalls.h"
+#include "io/compression.h"
+void DocData::merge_from(const DocData& p_data) {
+
+	for( Map<String,ClassDoc>::Element *E=class_list.front();E;E=E->next()) {
+
+
+		ClassDoc &c = E->get();
+
+		if (!p_data.class_list.has(c.name))
+			continue;
+
+		const ClassDoc &cf = p_data.class_list[c.name];
+
+		c.description=cf.description;
+		c.brief_description=cf.brief_description;
+
+		for(int i=0;i<c.methods.size();i++) {
+
+			MethodDoc &m = c.methods[i];
+
+			for(int j=0;j<cf.methods.size();j++) {
+
+				if (cf.methods[j].name!=m.name)
+					continue;
+				const MethodDoc &mf = cf.methods[j];
+
+				m.description=mf.description;
+				break;
+			}
+		}
+
+
+		for(int i=0;i<c.signals.size();i++) {
+
+			MethodDoc &m = c.signals[i];
+
+			for(int j=0;j<cf.signals.size();j++) {
+
+				if (cf.signals[j].name!=m.name)
+					continue;
+				const MethodDoc &mf = cf.signals[j];
+
+				m.description=mf.description;
+				break;
+			}
+		}
+
+		for(int i=0;i<c.constants.size();i++) {
+
+			ConstantDoc &m = c.constants[i];
+
+			for(int j=0;j<cf.constants.size();j++) {
+
+				if (cf.constants[j].name!=m.name)
+					continue;
+				const ConstantDoc &mf = cf.constants[j];
+
+				m.description=mf.description;
+				break;
+			}
+		}
+
+		for(int i=0;i<c.properties.size();i++) {
+
+			PropertyDoc &p = c.properties[i];
+
+			for(int j=0;j<cf.properties.size();j++) {
+
+				if (cf.properties[j].name!=p.name)
+					continue;
+				const PropertyDoc &pf = cf.properties[j];
+
+				p.description=pf.description;
+				break;
+			}
+		}
+
+	}
+
+}
+
+void DocData::generate(bool p_basic_types) {
+
+
+	List<String> classes;
+	ObjectTypeDB::get_type_list(&classes);
+	classes.sort();
+
+	while(classes.size()) {
+
+		String name=classes.front()->get();
+		String cname=name;
+		if (cname.begins_with("_")) //proxy class
+			cname=cname.substr(1,name.length());
+
+		class_list[cname]=ClassDoc();
+		ClassDoc& c = class_list[cname];
+		c.name=cname;
+		c.inherits=ObjectTypeDB::type_inherits_from(name);
+		c.category=ObjectTypeDB::get_category(name);
+
+		List<MethodInfo> method_list;
+		ObjectTypeDB::get_method_list(name,&method_list,true);
+		method_list.sort();
+
+
+		for(List<MethodInfo>::Element *E=method_list.front();E;E=E->next()) {
+
+			if (E->get().name=="" || (E->get().name[0]=='_' && !(E->get().flags&METHOD_FLAG_VIRTUAL)))
+				continue; //hiden, dont count
+
+			MethodDoc method;
+
+			method.name=E->get().name;
+
+			MethodBind *m = ObjectTypeDB::get_method(name,E->get().name);
+
+
+			if (E->get().flags&METHOD_FLAG_VIRTUAL)
+				method.qualifiers="virtual";
+			if (E->get().flags&METHOD_FLAG_CONST) {
+				if (method.qualifiers!="")
+					method.qualifiers+=" ";
+				method.qualifiers+="const";
+			}
+
+			for(int i=-1;i<E->get().arguments.size();i++) {
+
+				PropertyInfo arginfo;
+
+				if (i==-1) {
+
+
+					arginfo=E->get().return_val;
+					if (arginfo.type==Variant::NIL)
+						continue;
+
+					method.return_type=(arginfo.hint==PROPERTY_HINT_RESOURCE_TYPE)?arginfo.hint_string:Variant::get_type_name(arginfo.type);
+
+				} else {
+
+					ArgumentDoc argument;
+
+					arginfo=E->get().arguments[i];
+
+					String type_name;
+
+					if (arginfo.name.find(":")!=-1) {
+						type_name=arginfo.name.get_slice(":",1);
+						arginfo.name=arginfo.name.get_slice(":",0);
+
+					} else if (arginfo.hint==PROPERTY_HINT_RESOURCE_TYPE) {
+						type_name=arginfo.hint_string;
+					} else if (arginfo.type==Variant::NIL)
+						type_name="var";
+					else
+						type_name=Variant::get_type_name(arginfo.type);
+
+					if (arginfo.type==Variant::OBJECT) {
+
+						//print_line("validate: "+cname+"::"+method.name);
+					}
+
+					if (m && m->has_default_argument(i)) {
+						Variant default_arg=m->get_default_argument(i);
+						String default_arg_text=m->get_default_argument(i);
+
+						switch(default_arg.get_type()) {
+
+							case Variant::NIL:
+								default_arg_text="NULL";
+								break;
+							// atomic types
+							case Variant::BOOL:
+								if (bool(default_arg))
+									default_arg_text="true";
+								else
+									default_arg_text="false";
+								break;
+							case Variant::INT:
+							case Variant::REAL:
+								//keep it
+								break;
+							case Variant::STRING:		// 15
+							case Variant::NODE_PATH:		// 15
+								default_arg_text="\""+default_arg_text+"\"";
+								break;
+							case Variant::TRANSFORM:
+								if (default_arg.operator Transform()==Transform()) {
+									default_arg_text="";
+								}
+
+								default_arg_text=Variant::get_type_name(default_arg.get_type())+"("+default_arg_text+")";
+								break;
+
+							case Variant::VECTOR2:		// 5
+							case Variant::RECT2:
+							case Variant::VECTOR3:
+							case Variant::PLANE:
+							case Variant::QUAT:
+							case Variant::_AABB: //sorry naming convention fail :( not like it's used often // 10
+							case Variant::MATRIX3:
+							case Variant::COLOR:
+							case Variant::RAW_ARRAY:
+							case Variant::INT_ARRAY:
+							case Variant::REAL_ARRAY:
+							case Variant::STRING_ARRAY:	//25
+							case Variant::VECTOR3_ARRAY:
+							case Variant::COLOR_ARRAY:
+								default_arg_text=Variant::get_type_name(default_arg.get_type())+"("+default_arg_text+")";
+								break;
+							case Variant::OBJECT:
+							case Variant::INPUT_EVENT:
+							case Variant::DICTIONARY:		// 20
+							case Variant::ARRAY:
+							case Variant::_RID:
+							case Variant::IMAGE:
+							//case Variant::RESOURCE:
+
+								default_arg_text=Variant::get_type_name(default_arg.get_type())+"()";
+								break;
+							default: {}
+
+						}
+
+
+						argument.type=type_name;
+						argument.name=arginfo.name;
+						argument.default_value=default_arg_text;
+					} else {
+
+						argument.type=type_name;
+						argument.name=arginfo.name;
+					}
+
+					if (arginfo.type==Variant::OBJECT) {
+
+						//print_line("validate: "+cname+"::"+method.name);
+					}
+
+					method.arguments.push_back(argument);
+				}
+
+/*
+				String hint;
+				switch(arginfo.hint) {
+					case PROPERTY_HINT_DIR: hint="A directory."; break;
+					case PROPERTY_HINT_RANGE: hint="Range - min: "+arginfo.hint_string.get_slice(",",0)+" max: "+arginfo.hint_string.get_slice(",",1)+" step: "+arginfo.hint_string.get_slice(",",2); break;
+					case PROPERTY_HINT_ENUM: hint="Values: "; for(int j=0;j<arginfo.hint_string.get_slice_count(",");j++) { if (j>0) hint+=", "; hint+=arginfo.hint_string.get_slice(",",j)+"="+itos(j); } break;
+					case PROPERTY_HINT_LENGTH: hint="Length: "+arginfo.hint_string; break;
+					case PROPERTY_HINT_FLAGS: hint="Values: "; for(int j=0;j<arginfo.hint_string.get_slice_count(",");j++) { if (j>0) hint+=", "; hint+=arginfo.hint_string.get_slice(",",j)+"="+itos(1<<j); } break;
+					case PROPERTY_HINT_FILE: hint="A file:"; break;
+					//case PROPERTY_HINT_RESOURCE_TYPE: hint="Type: "+arginfo.hint_string; break;
+				};
+				if (hint!="")
+					_write_string(f,4,hint);
+*/
+
+
+			}
+
+			c.methods.push_back(method);
+		}
+
+		List<MethodInfo> signal_list;
+		ObjectTypeDB::get_signal_list(name,&signal_list,true);
+
+		if (signal_list.size()) {
+
+
+			for(List<MethodInfo>::Element *EV=signal_list.front();EV;EV=EV->next()) {
+
+				MethodDoc signal;
+				signal.name=EV->get().name;
+				for(int i=0;i<EV->get().arguments.size();i++) {
+
+					PropertyInfo arginfo=EV->get().arguments[i];
+					ArgumentDoc argument;
+					argument.name=arginfo.name;
+					argument.type=Variant::get_type_name(arginfo.type);
+					signal.arguments.push_back(argument);
+				}
+
+				c.signals.push_back(signal);
+			}
+
+
+		}
+
+		List<String> constant_list;
+		ObjectTypeDB::get_integer_constant_list(name, &constant_list, true);
+
+		for(List<String>::Element *E=constant_list.front();E;E=E->next()) {
+
+			ConstantDoc constant;
+			constant.name=E->get();
+			constant.value=itos(ObjectTypeDB::get_integer_constant(name, E->get()));
+			c.constants.push_back(constant);
+		}
+
+		classes.pop_front();
+	}
+
+
+	if (!p_basic_types)
+		return;
+
+	for (int i=0;i<Variant::VARIANT_MAX;i++) {
+
+		if (i==Variant::OBJECT)
+			continue; //use the core type instead
+
+		int loops=1;
+
+		if (i==Variant::INPUT_EVENT)
+			loops=InputEvent::TYPE_MAX;
+
+		for(int j=0;j<loops;j++) {
+
+			String cname=Variant::get_type_name(Variant::Type(i));
+
+			if (i==Variant::INPUT_EVENT) {
+				static const char* ie_type[InputEvent::TYPE_MAX]={
+					"","Key","MouseMotion","MouseButton","JoyMotion","JoyButton","ScreenTouch","ScreenDrag","Action"
+				};
+				cname+=ie_type[j];
+			}
+
+
+			class_list[cname]=ClassDoc();
+			ClassDoc& c = class_list[cname];
+			c.name=cname;
+			c.category="Built-In Types";
+
+			Variant::CallError cerror;
+			Variant v=Variant::construct(Variant::Type(i),NULL,0,cerror);
+
+			if (i==Variant::INPUT_EVENT) {
+				v.set("type",j);
+			}
+
+			List<MethodInfo> method_list;
+			v.get_method_list(&method_list);
+			method_list.sort();
+			Variant::get_constructor_list(Variant::Type(i),&method_list);
+
+
+			for(List<MethodInfo>::Element *E=method_list.front();E;E=E->next()) {
+
+				MethodInfo &mi=E->get();
+				MethodDoc method;
+
+				method.name=mi.name;
+
+				for(int i=0;i<mi.arguments.size();i++) {
+
+					ArgumentDoc arg;
+					PropertyInfo pi=mi.arguments[i];
+
+					arg.name=pi.name;
+					//print_line("arg name: "+arg.name);
+					if (pi.type==Variant::NIL)
+						arg.type="var";
+					else
+						arg.type=Variant::get_type_name(pi.type);
+					int defarg = mi.default_arguments.size() - mi.arguments.size() + i;
+					if (defarg >=0)
+						arg.default_value=mi.default_arguments[defarg];
+
+					method.arguments.push_back(arg);
+				}
+
+				if (mi.return_val.type==Variant::NIL) {
+					if (mi.return_val.name!="")
+					    method.return_type="var";
+
+				} else {
+					method.return_type=Variant::get_type_name(mi.return_val.type);
+				}
+
+				c.methods.push_back(method);
+			}
+
+
+			List<PropertyInfo> properties;
+			v.get_property_list(&properties);
+			for(List<PropertyInfo>::Element *E=properties.front();E;E=E->next()) {
+
+				PropertyInfo pi=E->get();
+				PropertyDoc property;
+				property.name=pi.name;
+				property.type=Variant::get_type_name(pi.type);
+
+				c.properties.push_back(property);
+			}
+
+			List<StringName> constants;
+			Variant::get_numeric_constants_for_type(Variant::Type(i),&constants);
+
+			for(List<StringName>::Element *E=constants.front();E;E=E->next()) {
+
+				ConstantDoc constant;
+				constant.name=E->get();
+				constant.value=itos(Variant::get_numeric_constant_value(Variant::Type(i),E->get()));
+				c.constants.push_back(constant);
+			}
+		}
+
+	}
+
+	//built in constants and functions
+
+	{
+
+		String cname="@Global Scope";
+		class_list[cname]=ClassDoc();
+		ClassDoc& c = class_list[cname];
+		c.name=cname;
+
+
+		for(int i=0;i<GlobalConstants::get_global_constant_count();i++) {
+
+			ConstantDoc cd;
+			cd.name=GlobalConstants::get_global_constant_name(i);
+			cd.value=itos(GlobalConstants::get_global_constant_value(i));
+			c.constants.push_back(cd);
+		}
+
+		List<Globals::Singleton> singletons;
+		Globals::get_singleton()->get_singletons(&singletons);
+
+		//servers (this is kind of hackish)
+		for(List<Globals::Singleton>::Element *E=singletons.front();E;E=E->next()) {
+
+			PropertyDoc pd;
+			Globals::Singleton &s=E->get();
+			pd.name=s.name;
+			pd.type=s.ptr->get_type();
+			while (ObjectTypeDB::type_inherits_from(pd.type)!="Object")
+				pd.type=ObjectTypeDB::type_inherits_from(pd.type);
+			if (pd.type.begins_with("_"))
+				pd.type=pd.type.substr(1,pd.type.length());
+			c.properties.push_back(pd);
+
+		}
+
+	}
+
+	//built in script reference
+
+	{
+
+
+		for(int i=0;i<ScriptServer::get_language_count();i++) {
+
+
+			ScriptLanguage *lang = ScriptServer::get_language(i);
+			String cname="@"+lang->get_name();
+			class_list[cname]=ClassDoc();
+			ClassDoc& c = class_list[cname];
+			c.name=cname;
+
+			List<MethodInfo> minfo;
+
+			lang->get_public_functions(&minfo);
+
+
+			for(List<MethodInfo>::Element *E=minfo.front();E;E=E->next()) {
+
+				MethodInfo &mi=E->get();
+				MethodDoc md;
+				md.name=mi.name;
+				if (mi.return_val.name!="")
+					md.return_type=mi.return_val.name;
+				else
+					md.return_type=Variant::get_type_name(mi.return_val.type);
+
+				for(int i=0;i<mi.arguments.size();i++) {
+
+					PropertyInfo &pi=mi.arguments[i];
+
+					ArgumentDoc ad;
+					ad.name=pi.name;
+
+					if (pi.type==Variant::NIL)
+						ad.type="var";
+					else
+						ad.type=Variant::get_type_name( pi.type );
+
+					md.arguments.push_back(ad);
+				}
+
+				c.methods.push_back(md);
+
+			}
+
+		}
+	}
+
+
+}
+
+
+static Error _parse_methods(Ref<XMLParser>& parser,Vector<DocData::MethodDoc>& methods) {
+
+	String section=parser->get_node_name();
+	String element=section.substr(0,section.length()-1);
+
+	while(parser->read()==OK) {
+
+		if (parser->get_node_type() == XMLParser::NODE_ELEMENT)	{
+
+			if (parser->get_node_name()==element) {
+
+				DocData::MethodDoc method;
+				ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
+				method.name=parser->get_attribute_value("name");
+				if (parser->has_attribute("qualifiers"))
+					method.qualifiers=parser->get_attribute_value("qualifiers");
+
+
+				while(parser->read()==OK) {
+
+					if (parser->get_node_type() == XMLParser::NODE_ELEMENT)	{
+
+						String name=parser->get_node_name();
+						if (name=="return") {
+
+							ERR_FAIL_COND_V(!parser->has_attribute("type"),ERR_FILE_CORRUPT);
+							method.return_type=parser->get_attribute_value("type");
+						} else if (name=="argument") {
+
+							DocData::ArgumentDoc argument;
+							ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
+							argument.name=parser->get_attribute_value("name");
+							ERR_FAIL_COND_V(!parser->has_attribute("type"),ERR_FILE_CORRUPT);
+							argument.type=parser->get_attribute_value("type");
+
+							method.arguments.push_back(argument);
+
+						} else if (name=="description") {
+
+							parser->read();
+							if (parser->get_node_type()==XMLParser::NODE_TEXT)
+								method.description=parser->get_node_data().strip_edges();
+						}
+
+					} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()==element)
+						break;
+				}
+
+				methods.push_back(method);
+
+			} else {
+				ERR_EXPLAIN("Invalid tag in doc file: "+parser->get_node_name());
+				ERR_FAIL_V(ERR_FILE_CORRUPT);
+			}
+
+		} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()==section)
+			break;
+	}
+
+	return OK;
+}
+
+Error DocData::load(const String& p_path) {
+
+	Ref<XMLParser> parser=memnew(XMLParser);
+
+	Error err = parser->open(p_path);
+	if (err)
+		return err;
+
+	while((err=parser->read())==OK) {
+
+		if (parser->get_node_type() == XMLParser::NODE_ELEMENT) {
+
+			if (parser->get_node_name() == "doc") {
+				break;
+			} else if (!parser->is_empty())
+				parser->skip_section();// unknown section, likely headers
+		}
+	}
+
+	if (parser->has_attribute("version"))
+		version=parser->get_attribute_value("version");
+
+
+	while((err=parser->read())==OK) {
+
+
+		if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="doc")
+			break; //end of <doc>
+
+		if (parser->get_node_type() != XMLParser::NODE_ELEMENT)
+			continue; //no idea what this may be, but skipping anyway
+
+		ERR_FAIL_COND_V( parser->get_node_name()!="class", ERR_FILE_CORRUPT );
+
+		ERR_FAIL_COND_V( !parser->has_attribute("name"), ERR_FILE_CORRUPT);
+		String name = parser->get_attribute_value("name");
+		class_list[name]=ClassDoc();
+		ClassDoc& c = class_list[name];
+
+		c.name=name;
+		if (parser->has_attribute("inherits"))
+			c.inherits = parser->get_attribute_value("inherits");
+		if (parser->has_attribute("category"))
+			c.category = parser->get_attribute_value("category");
+
+		while(parser->read()==OK) {
+
+			if (parser->get_node_type() == XMLParser::NODE_ELEMENT)	{
+
+				String name = parser->get_node_name();
+
+				if (name=="brief_description") {
+
+					parser->read();
+					if (parser->get_node_type()==XMLParser::NODE_TEXT)
+						c.brief_description=parser->get_node_data().strip_edges();
+
+				} else if (name=="description") {
+					parser->read();
+					if (parser->get_node_type()==XMLParser::NODE_TEXT)
+						c.description=parser->get_node_data().strip_edges();
+				} else if (name=="methods") {
+
+					Error err = _parse_methods(parser,c.methods);
+					ERR_FAIL_COND_V(err,err);
+
+				} else if (name=="signals") {
+
+					Error err = _parse_methods(parser,c.signals);
+					ERR_FAIL_COND_V(err,err);
+				} else if (name=="members") {
+
+					while(parser->read()==OK) {
+
+						if (parser->get_node_type() == XMLParser::NODE_ELEMENT)	{
+
+							String name = parser->get_node_name();
+
+							if (name=="member") {
+
+								PropertyDoc prop;
+
+								ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
+								prop.name=parser->get_attribute_value("name");
+								ERR_FAIL_COND_V(!parser->has_attribute("type"),ERR_FILE_CORRUPT);
+								prop.type=parser->get_attribute_value("type");
+								parser->read();
+								if (parser->get_node_type()==XMLParser::NODE_TEXT)
+									prop.description=parser->get_node_data().strip_edges();
+								c.properties.push_back(prop);
+							} else {
+								ERR_EXPLAIN("Invalid tag in doc file: "+name);
+								ERR_FAIL_V(ERR_FILE_CORRUPT);
+							}
+
+						} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="members")
+							break; //end of <constants>
+					}
+
+				} else if (name=="constants") {
+
+					while(parser->read()==OK) {
+
+						if (parser->get_node_type() == XMLParser::NODE_ELEMENT)	{
+
+							String name=parser->get_node_name();
+
+							if (name=="constant") {
+
+								ConstantDoc constant;
+								ERR_FAIL_COND_V(!parser->has_attribute("name"),ERR_FILE_CORRUPT);
+								constant.name=parser->get_attribute_value("name");
+								ERR_FAIL_COND_V(!parser->has_attribute("value"),ERR_FILE_CORRUPT);
+								constant.value=parser->get_attribute_value("value");
+								parser->read();
+								if (parser->get_node_type()==XMLParser::NODE_TEXT)
+									constant.description=parser->get_node_data().strip_edges();
+								c.constants.push_back(constant);
+							} else {
+								ERR_EXPLAIN("Invalid tag in doc file: "+name);
+								ERR_FAIL_V(ERR_FILE_CORRUPT);
+							}
+
+						} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="constants")
+							break; //end of <constants>
+					}
+
+				} else {
+
+					ERR_EXPLAIN("Invalid tag in doc file: "+name);
+					ERR_FAIL_V(ERR_FILE_CORRUPT);
+				}
+
+
+			} else if (parser->get_node_type() == XMLParser::NODE_ELEMENT_END && parser->get_node_name()=="class")
+				break; //end of <asset>
+		}
+
+
+	}
+
+	return OK;
+}
+
+
+static void _write_string(FileAccess *f,int p_tablevel,const String& p_string) {
+
+	String tab;
+	for(int i=0;i<p_tablevel;i++) tab+="\t";
+	f->store_string(tab+p_string+"\n");
+}
+
+Error DocData::save(const String& p_path) {
+
+	Error err;
+	FileAccess *f = FileAccess::open(p_path,FileAccess::WRITE,&err);
+
+	if (err) {
+		ERR_EXPLAIN("Can't write doc file: "+p_path);
+
+		ERR_FAIL_V(err);
+
+	}
+
+	_write_string(f,0,"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
+	_write_string(f,0,"<doc version=\""+String(VERSION_MKSTRING)+"\" name=\"Engine Types\">");
+
+	for( Map<String,ClassDoc>::Element *E=class_list.front();E;E=E->next()) {
+
+		ClassDoc &c=E->get();
+
+		String header="<class name=\""+c.name+"\"";
+		if (c.inherits!="")
+			header+=" inherits=\""+c.inherits+"\"";
+
+		String category=c.category;
+		if (c.category=="")
+			category="Core";
+		header+=" category=\""+category+"\"";
+		header+=">";
+		_write_string(f,0,header);
+		_write_string(f,1,"<brief_description>");
+		if (c.brief_description!="")
+			_write_string(f,1,c.brief_description.xml_escape());
+		_write_string(f,1,"</brief_description>");
+		_write_string(f,1,"<description>");
+		if (c.description!="")
+			_write_string(f,1,c.description.xml_escape());
+		_write_string(f,1,"</description>");
+		_write_string(f,1,"<methods>");
+
+		for(int i=0;i<c.methods.size();i++) {
+
+			MethodDoc &m=c.methods[i];
+
+			String qualifiers;
+			if (m.qualifiers!="")
+				qualifiers+="qualifiers=\""+m.qualifiers.xml_escape()+"\"";
+
+			_write_string(f,2,"<method name=\""+m.name+"\" "+qualifiers+" >");
+
+			if (m.return_type!="") {
+
+				_write_string(f,3,"<return type=\""+m.return_type+"\">");
+				_write_string(f,3,"</return>");
+			}
+
+			for(int j=0;j<m.arguments.size();j++) {
+
+				ArgumentDoc &a = m.arguments[j];
+				if (a.default_value!="")
+					_write_string(f,3,"<argument index=\""+itos(j)+"\" name=\""+a.name.xml_escape()+"\" type=\""+a.type.xml_escape()+"\" default=\""+a.default_value.xml_escape(true)+"\">");
+				else
+					_write_string(f,3,"<argument index=\""+itos(j)+"\" name=\""+a.name.xml_escape()+"\" type=\""+a.type.xml_escape()+"\">");
+
+				_write_string(f,3,"</argument>");
+
+			}
+
+			_write_string(f,3,"<description>");
+			if (m.description!="")
+				_write_string(f,3,m.description.xml_escape());
+			_write_string(f,3,"</description>");
+
+			_write_string(f,2,"</method>");
+
+		}
+
+		_write_string(f,1,"</methods>");
+
+		if (c.properties.size()) {
+			_write_string(f,1,"<members>");
+
+			for(int i=0;i<c.properties.size();i++) {
+
+
+				PropertyDoc &p=c.properties[i];
+				_write_string(f,2,"<member name=\""+p.name+"\" type=\""+p.type+"\">");
+				_write_string(f,2,"</member>");
+
+			}
+			_write_string(f,1,"</members>");
+		}
+
+		if (c.signals.size()) {
+
+			_write_string(f,1,"<signals>");
+			for(int i=0;i<c.signals.size();i++) {
+
+				MethodDoc &m=c.signals[i];
+				_write_string(f,2,"<signal name=\""+m.name+"\">");
+				for(int j=0;j<m.arguments.size();j++) {
+
+					ArgumentDoc &a = m.arguments[j];
+						_write_string(f,3,"<argument index=\""+itos(j)+"\" name=\""+a.name.xml_escape()+"\" type=\""+a.type.xml_escape()+"\">");
+						_write_string(f,3,"</argument>");
+
+				}
+
+				_write_string(f,3,"<description>");
+				if (m.description!="")
+					_write_string(f,3,m.description.xml_escape());
+				_write_string(f,3,"</description>");
+
+				_write_string(f,2,"</signal>");
+			}
+
+			_write_string(f,1,"</signals>");
+		}
+
+		_write_string(f,1,"<constants>");
+
+		for(int i=0;i<c.constants.size();i++) {
+
+			ConstantDoc &k=c.constants[i];
+			_write_string(f,2,"<constant name=\""+k.name+"\" value=\""+k.value+"\">");
+			if (k.description!="")
+				_write_string(f,3,k.description.xml_escape());
+			_write_string(f,2,"</constant>");
+		}
+
+		_write_string(f,1,"</constants>");
+		_write_string(f,0,"</class>");
+
+	}
+
+	_write_string(f,0,"</doc>");
+	f->close();
+	memdelete(f);
+
+	return OK;
+}
+
+static void add_to_arr(Vector<uint8_t>& p_arr,const Variant& p_var) {
+
+	int from = p_arr.size();
+	int len;
+	Error err =encode_variant(p_var,NULL,len);
+	ERR_FAIL_COND(err!=OK);
+	p_arr.resize(from+len);
+	encode_variant(p_var,&p_arr[from],len);
+}
+
+Error DocData::save_compressed_header(const String& p_path) {
+
+	Vector<uint8_t> data;
+	add_to_arr(data,version);
+	add_to_arr(data,class_list.size());
+	for (Map<String,ClassDoc>::Element *E=class_list.front();E;E=E->next()) {
+
+
+		ClassDoc &cd=E->get();
+		add_to_arr(data,cd.name);
+		add_to_arr(data,cd.inherits);
+		add_to_arr(data,cd.category);
+		add_to_arr(data,cd.brief_description);
+		add_to_arr(data,cd.description);
+		add_to_arr(data,cd.methods.size());
+		for(int i=0;i<cd.methods.size();i++) {
+
+			MethodDoc &md=cd.methods[i];
+			add_to_arr(data,md.name);
+			add_to_arr(data,md.return_type);
+			add_to_arr(data,md.qualifiers);
+			add_to_arr(data,md.description);
+			add_to_arr(data,md.arguments.size());
+			for(int j=0;j<md.arguments.size();j++) {
+				ArgumentDoc &ad=md.arguments[j];
+				add_to_arr(data,ad.name);
+				add_to_arr(data,ad.type);
+				add_to_arr(data,ad.default_value);
+			}
+		}
+
+		add_to_arr(data,cd.signals.size());
+		for(int i=0;i<cd.signals.size();i++) {
+
+			MethodDoc &md=cd.signals[i];
+			add_to_arr(data,md.name);
+			add_to_arr(data,md.return_type);
+			add_to_arr(data,md.qualifiers);
+			add_to_arr(data,md.description);
+			add_to_arr(data,md.arguments.size());
+			for(int j=0;j<md.arguments.size();j++) {
+				ArgumentDoc &ad=md.arguments[j];
+				add_to_arr(data,ad.name);
+				add_to_arr(data,ad.type);
+				add_to_arr(data,ad.default_value);
+			}
+		}
+
+		add_to_arr(data,cd.properties.size());
+		for(int i=0;i<cd.properties.size();i++) {
+
+			PropertyDoc &pd=cd.properties[i];
+			add_to_arr(data,pd.name);
+			add_to_arr(data,pd.type);
+			add_to_arr(data,pd.description);
+		}
+
+		add_to_arr(data,cd.constants.size());
+		for(int i=0;i<cd.constants.size();i++) {
+
+			ConstantDoc &kd=cd.constants[i];
+			add_to_arr(data,kd.name);
+			add_to_arr(data,kd.value);
+			add_to_arr(data,kd.description);
+		}
+
+
+	}
+
+
+	Vector<uint8_t> cdata;
+	cdata.resize( Compression::get_max_compressed_buffer_size(data.size()) );
+	int res = Compression::compress(cdata.ptr(),data.ptr(),data.size());
+
+	cdata.resize(res);
+
+	print_line("orig size: "+itos(data.size()));
+	print_line("comp size: "+itos(cdata.size()));
+
+	Error err;
+	FileAccess *f = FileAccess::open(p_path,FileAccess::WRITE,&err);
+	if (err!=OK) {
+
+		ERR_FAIL_COND_V(err,err);
+	}
+
+	f->store_line("/* This file is generated, do not edit */");
+	f->store_line("#ifndef DOC_DATA_COMPRESSED_H");
+	f->store_line("#define DOC_DATA_COMPRESSED_H");
+	f->store_line("");
+	f->store_line("static const int _doc_data_compressed_size="+itos(cdata.size())+";");
+	f->store_line("static const int _doc_data_uncompressed_size="+itos(data.size())+";");
+	f->store_line("static const unsigned char _doc_data_compressed[]={");
+	for(int i=0;i<cdata.size();i++)
+		f->store_line(itos(cdata[i])+",");
+	f->store_line("};");
+	f->store_line("");
+	f->store_line("#endif");
+
+	memdelete(f);
+
+	return OK;
+
+}
+
+static Variant get_data(int& ofs, const Vector<uint8_t>& p_array) {
+
+	int len;
+	Variant r;
+	decode_variant(r,&p_array[ofs],p_array.size()-ofs,&len);
+	ofs+=len;
+	return r;
+}
+
+Error DocData::load_compressed(const uint8_t *p_data, int p_compressed_size, int p_uncompressed_size) {
+
+	Vector<uint8_t> data;
+	data.resize(p_uncompressed_size);
+	Compression::decompress(data.ptr(),p_uncompressed_size,p_data,p_compressed_size);
+	class_list.clear();
+	int ofs=0;
+	version=get_data(ofs,data);
+	int ccount=get_data(ofs,data);
+
+	for(int i=0;i<ccount;i++) {
+
+
+		ClassDoc cd;
+		cd.name=get_data(ofs,data);
+		cd.inherits=get_data(ofs,data);
+		cd.category=get_data(ofs,data);
+		cd.brief_description=get_data(ofs,data);
+		cd.description=get_data(ofs,data);
+		int mc = get_data(ofs,data);
+
+
+		for(int j=0;j<mc;j++) {
+
+			MethodDoc md;
+			md.name=get_data(ofs,data);
+			md.return_type=get_data(ofs,data);
+			md.qualifiers=get_data(ofs,data);
+			md.description=get_data(ofs,data);
+			int ac=get_data(ofs,data);
+
+			for(int k=0;k<ac;k++) {
+				ArgumentDoc ad;
+				ad.name=get_data(ofs,data);
+				ad.type=get_data(ofs,data);
+				ad.default_value=get_data(ofs,data);
+				md.arguments.push_back(ad);
+			}
+
+			cd.methods.push_back(md);
+		}
+
+		int sc = get_data(ofs,data);
+
+		for(int j=0;j<sc;j++) {
+
+			MethodDoc md;
+			md.name=get_data(ofs,data);
+			md.return_type=get_data(ofs,data);
+			md.qualifiers=get_data(ofs,data);
+			md.description=get_data(ofs,data);
+			int ac=get_data(ofs,data);
+
+			for(int k=0;k<ac;k++) {
+				ArgumentDoc ad;
+				ad.name=get_data(ofs,data);
+				ad.type=get_data(ofs,data);
+				ad.default_value=get_data(ofs,data);
+				md.arguments.push_back(ad);
+			}
+
+			cd.signals.push_back(md);
+		}
+
+		int pc = get_data(ofs,data);
+
+		for(int j=0;j<pc;j++) {
+
+			PropertyDoc pd;
+			pd.name=get_data(ofs,data);
+			pd.type=get_data(ofs,data);
+			pd.description=get_data(ofs,data);
+			cd.properties.push_back(pd);
+		}
+
+		int kc = get_data(ofs,data);
+
+		for(int j=0;j<kc;j++) {
+
+			ConstantDoc kd;
+			kd.name=get_data(ofs,data);
+			kd.value=get_data(ofs,data);
+			kd.description=get_data(ofs,data);
+			cd.constants.push_back(kd);
+		}
+
+
+		class_list[cd.name]=cd;
+	}
+
+
+
+	return OK;
+
+}
diff --git a/tools/doc/doc_data.h b/tools/doc/doc_data.h
new file mode 100644
index 0000000000..8acf4d8f53
--- /dev/null
+++ b/tools/doc/doc_data.h
@@ -0,0 +1,99 @@
+/*************************************************************************/
+/*  doc_data.h                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef DOC_DATA_H
+#define DOC_DATA_H
+
+
+#include "variant.h"
+#include "map.h"
+
+class DocData  {
+public:
+	struct ArgumentDoc {
+
+		String name;
+		String type;
+		String default_value;
+	};
+
+	struct MethodDoc {
+
+		String name;
+		String return_type;
+		String qualifiers;
+		String description;
+		Vector<ArgumentDoc> arguments;
+	};
+
+	struct ConstantDoc {
+
+		String name;
+		String value;
+		String description;
+	};
+
+	struct PropertyDoc {
+
+		String name;
+		String type;
+		String description;
+	};
+
+	struct ClassDoc  {
+
+		String name;
+		String inherits;
+		String category;
+		String brief_description;
+		String description;
+		Vector<MethodDoc> methods;
+		Vector<MethodDoc> signals;
+		Vector<ConstantDoc> constants;
+		Vector<PropertyDoc> properties;
+
+	};
+
+	String version;
+
+	Map<String,ClassDoc> class_list;
+
+public:
+
+	void merge_from(const DocData& p_data);
+	void generate(bool p_basic_types=false);
+	Error load(const String& p_path);
+	Error save(const String& p_path);
+
+	Error save_compressed_header(const String& p_path);
+	Error load_compressed(const uint8_t *p_data, int p_compressed_size, int p_uncompressed_size);
+
+
+};
+
+#endif // DOC_DATA_H