Added expression nodes to visual script, please test.

modules/visual_script/register_types.cpp

@@ -36,6 +36,7 @@
 #include "visual_script_builtin_funcs.h"
 #include "visual_script_flow_control.h"
 #include "visual_script_yield_nodes.h"
+#include "visual_script_expression.h"
 
 
 VisualScriptLanguage *visual_script_language=NULL;
@@ -98,11 +99,14 @@ void register_visual_script_types() {
 	ObjectTypeDB::register_type<VisualScriptBuiltinFunc>();
 
 
+	ObjectTypeDB::register_type<VisualScriptExpression>();
+
 	register_visual_script_nodes();
 	register_visual_script_func_nodes();
 	register_visual_script_builtin_func_node();
 	register_visual_script_flow_control_nodes();
 	register_visual_script_yield_nodes();
+	register_visual_script_expression_node();
 
 #ifdef TOOLS_ENABLED
 	VisualScriptEditor::register_editor();

modules/visual_script/visual_script.cpp

@@ -1909,17 +1909,21 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 
 		if (node && (r_error.error!=Variant::CallError::CALL_ERROR_INVALID_METHOD || error_str==String())) {
 
+			if (error_str!=String()) {
+				error_str+=" ";
+			}
+
 			if (r_error.error==Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
 				int errorarg=r_error.argument;
-				error_str="Cannot convert argument "+itos(errorarg+1)+" to "+Variant::get_type_name(r_error.expected)+".";
+				error_str+="Cannot convert argument "+itos(errorarg+1)+" to "+Variant::get_type_name(r_error.expected)+".";
 			} else if (r_error.error==Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
-				error_str="Expected "+itos(r_error.argument)+" arguments.";
+				error_str+="Expected "+itos(r_error.argument)+" arguments.";
 			} else if (r_error.error==Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
-				error_str="Expected "+itos(r_error.argument)+" arguments.";
+				error_str+="Expected "+itos(r_error.argument)+" arguments.";
 			} else if (r_error.error==Variant::CallError::CALL_ERROR_INVALID_METHOD) {
-				error_str="Invalid Call.";
+				error_str+="Invalid Call.";
 			} else if (r_error.error==Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
-				error_str="Instance is null";
+				error_str+="Base Instance is null";
 			}
 		}
 

modules/visual_script/visual_script_editor.cpp

@@ -3,6 +3,7 @@
 #include "visual_script_nodes.h"
 #include "visual_script_flow_control.h"
 #include "visual_script_func_nodes.h"
+#include "visual_script_expression.h"
 #include "os/input.h"
 #include "tools/editor/editor_resource_preview.h"
 #include "os/keyboard.h"
@@ -505,6 +506,9 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 		Label *text = memnew( Label );
 		text->set_text(node->get_text());
 		gnode->add_child(text);
+		if (node->cast_to<VisualScriptExpression>()) {
+			text->add_font_override("font",get_font("source","EditorFonts"));
+		}
 
 		if (node->cast_to<VisualScriptComment>()) {
 			Ref<VisualScriptComment> vsc=node;

modules/visual_script/visual_script_expression.cpp

@@ -0,0 +1,1440 @@
+#include "visual_script_expression.h"
+
+
+bool VisualScriptExpression::_set(const StringName& p_name, const Variant& p_value) {
+
+	if (String(p_name)=="expression") {
+		expression=p_value;
+		expression_dirty=true;
+		ports_changed_notify();
+		return true;
+	}
+
+	if (String(p_name)=="out_type") {
+		output_type=Variant::Type(int(p_value));
+		expression_dirty=true;
+		ports_changed_notify();
+		return true;
+	}
+	if (String(p_name)=="sequenced") {
+		sequenced=p_value;
+		ports_changed_notify();
+		return true;
+	}
+
+	if (String(p_name)=="input_count") {
+
+		int from=inputs.size();
+		inputs.resize(int(p_value));
+		for(int i=from;i<inputs.size();i++) {
+			inputs[i].name=String::chr('a'+i);
+			if (from==0) {
+				inputs[i].type=output_type;
+			} else {
+				inputs[i].type=inputs[from-1].type;
+			}
+		}
+		expression_dirty=true;
+		ports_changed_notify();
+		_change_notify();
+		return true;
+	}
+
+	if (String(p_name).begins_with("input/")) {
+
+		int idx=String(p_name).get_slice("/",1).to_int();
+		ERR_FAIL_INDEX_V(idx,inputs.size(),false);
+
+		String what=String(p_name).get_slice("/",2);
+
+		if (what=="type") {
+
+			inputs[idx].type=Variant::Type(int(p_value));
+		} else if (what=="name") {
+
+			inputs[idx].name=p_value;
+		} else {
+			return false;
+		}
+
+		expression_dirty=true;
+		ports_changed_notify();
+		return true;
+	}
+
+
+	return false;
+
+}
+
+bool VisualScriptExpression::_get(const StringName& p_name,Variant &r_ret) const {
+
+	if (String(p_name)=="expression") {
+		r_ret=expression;
+		return true;
+	}
+
+	if (String(p_name)=="out_type") {
+		r_ret=output_type;
+		return true;
+	}
+
+	if (String(p_name)=="sequenced") {
+		r_ret=sequenced;
+		return true;
+	}
+
+	if (String(p_name)=="input_count") {
+		r_ret=inputs.size();
+		return true;
+	}
+
+	if (String(p_name).begins_with("input/")) {
+
+		int idx=String(p_name).get_slice("/",1).to_int();
+		ERR_FAIL_INDEX_V(idx,inputs.size(),false);
+
+		String what=String(p_name).get_slice("/",2);
+
+		if (what=="type") {
+
+			r_ret=inputs[idx].type;
+		} else if (what=="name") {
+
+			r_ret=inputs[idx].name;
+		} else {
+			return false;
+		}
+
+		return true;
+	}
+
+
+	return false;
+}
+void VisualScriptExpression::_get_property_list( List<PropertyInfo> *p_list) const {
+
+
+	String argt="Any";
+	for(int i=1;i<Variant::VARIANT_MAX;i++) {
+		argt+=","+Variant::get_type_name(Variant::Type(i));
+	}
+
+	p_list->push_back(PropertyInfo(Variant::STRING,"expression"));
+	p_list->push_back(PropertyInfo(Variant::INT,"out_type",PROPERTY_HINT_ENUM,argt));
+	p_list->push_back(PropertyInfo(Variant::INT,"input_count",PROPERTY_HINT_RANGE,"0,64,1"));
+	p_list->push_back(PropertyInfo(Variant::BOOL,"sequenced"));
+
+	for(int i=0;i<inputs.size();i++) {
+
+		p_list->push_back(PropertyInfo(Variant::INT,"input/"+itos(i)+"/type",PROPERTY_HINT_ENUM,argt));
+		p_list->push_back(PropertyInfo(Variant::STRING,"input/"+itos(i)+"/name"));
+	}
+}
+
+int VisualScriptExpression::get_output_sequence_port_count() const {
+
+	return sequenced?1:0;
+}
+bool VisualScriptExpression::has_input_sequence_port() const{
+
+	return sequenced;
+}
+
+
+String VisualScriptExpression::get_output_sequence_port_text(int p_port) const{
+
+	return String();
+}
+
+
+int VisualScriptExpression::get_input_value_port_count() const{
+
+	return inputs.size();
+
+}
+int VisualScriptExpression::get_output_value_port_count() const{
+
+	return 1;
+}
+
+
+PropertyInfo VisualScriptExpression::get_input_value_port_info(int p_idx) const{
+
+	return PropertyInfo(inputs[p_idx].type,inputs[p_idx].name);
+}
+PropertyInfo VisualScriptExpression::get_output_value_port_info(int p_idx) const{
+
+	return PropertyInfo(output_type,"result");
+}
+
+String VisualScriptExpression::get_caption() const{
+
+	return "Expression";
+}
+String VisualScriptExpression::get_text() const{
+
+	return expression;
+}
+
+
+Error VisualScriptExpression::_get_token(Token& r_token) {
+
+	while (true) {
+#define GET_CHAR() (str_ofs>=expression.length()?0:expression[str_ofs++])
+
+		CharType cchar = GET_CHAR();
+		if (cchar==0) {
+			r_token.type=TK_EOF;
+			return OK;
+		}
+
+
+		switch(cchar) {
+
+			case 0: {
+				r_token.type=TK_EOF;
+				return OK;
+			} break;
+			case '{': {
+
+				r_token.type=TK_CURLY_BRACKET_OPEN;
+				return OK;
+			};
+			case '}': {
+
+				r_token.type=TK_CURLY_BRACKET_CLOSE;
+				return OK;
+			};
+			case '[': {
+
+				r_token.type=TK_BRACKET_OPEN;
+				return OK;
+			};
+			case ']': {
+
+				r_token.type=TK_BRACKET_CLOSE;
+				return OK;
+			};
+			case '(': {
+
+				r_token.type=TK_PARENTHESIS_OPEN;
+				return OK;
+			};
+			case ')': {
+
+				r_token.type=TK_PARENTHESIS_CLOSE;
+				return OK;
+			};
+			case ',': {
+
+				r_token.type=TK_COMMA;
+				return OK;
+			};
+			case ':': {
+
+				r_token.type=TK_COLON;
+				return OK;
+			};
+			case '.': {
+
+				r_token.type=TK_PERIOD;
+				return OK;
+			};
+			case '=': {
+
+				cchar=GET_CHAR();
+				if (cchar=='=') {
+					r_token.type=TK_OP_EQUAL;
+				} else {
+					_set_error("Expected '='");
+					r_token.type=TK_ERROR;
+					return ERR_PARSE_ERROR;
+				}
+				return OK;
+			};
+			case '!': {
+
+				if (expression[str_ofs]=='=') {
+					r_token.type=TK_OP_NOT_EQUAL;
+					str_ofs++;
+				} else {
+					r_token.type=TK_OP_NOT;
+				}
+				return OK;
+			};
+			case '>': {
+
+				if (expression[str_ofs]=='=') {
+					r_token.type=TK_OP_GREATER_EQUAL;
+					str_ofs++;
+				} else if (expression[str_ofs]=='>') {
+					r_token.type=TK_OP_SHIFT_RIGHT;
+					str_ofs++;
+				} else {
+					r_token.type=TK_OP_GREATER;
+				}
+				return OK;
+			};
+			case '<': {
+
+				if (expression[str_ofs]=='=') {
+					r_token.type=TK_OP_LESS_EQUAL;
+					str_ofs++;
+				} else if (expression[str_ofs]=='<') {
+					r_token.type=TK_OP_SHIFT_LEFT;
+					str_ofs++;
+				} else {
+					r_token.type=TK_OP_LESS;
+				}
+				return OK;
+			};
+			case '+': {
+				r_token.type=TK_OP_ADD;
+				return OK;
+			};
+			case '-': {
+				r_token.type=TK_OP_SUB;
+				return OK;
+			};
+			case '/': {
+				r_token.type=TK_OP_DIV;
+				return OK;
+			};
+			case '*': {
+				r_token.type=TK_OP_MUL;
+				return OK;
+			};
+			case '%': {
+				r_token.type=TK_OP_MOD;
+				return OK;
+			};
+			case '&': {
+
+				if (expression[str_ofs]=='&') {
+					r_token.type=TK_OP_AND;
+					str_ofs++;
+				} else {
+					r_token.type=TK_OP_BIT_AND;
+				}
+				return OK;
+			};
+			case '|': {
+
+				if (expression[str_ofs]=='|') {
+					r_token.type=TK_OP_OR;
+					str_ofs++;
+				} else {
+					r_token.type=TK_OP_BIT_OR;
+				}
+				return OK;
+			};
+			case '^': {
+
+				r_token.type=TK_OP_BIT_XOR;
+
+				return OK;
+			};
+			case '~': {
+
+				r_token.type=TK_OP_BIT_INVERT;
+
+				return OK;
+			};
+			case '"': {
+
+
+				String str;
+				while(true) {
+
+					CharType ch=GET_CHAR();
+
+					if (ch==0) {
+						_set_error("Unterminated String");
+						r_token.type=TK_ERROR;
+						return ERR_PARSE_ERROR;
+					} else if (ch=='"') {
+						break;
+					} else if (ch=='\\') {
+						//escaped characters...
+
+						CharType next = GET_CHAR();
+						if (next==0) {
+							_set_error("Unterminated String");
+							r_token.type=TK_ERROR;
+							return  ERR_PARSE_ERROR;
+						}
+						CharType res=0;
+
+						switch(next) {
+
+							case 'b': res=8; break;
+							case 't': res=9; break;
+							case 'n': res=10; break;
+							case 'f': res=12; break;
+							case 'r': res=13; break;
+							case 'u': {
+								//hexnumbarh - oct is deprecated
+
+
+								for(int j=0;j<4;j++) {
+									CharType c = GET_CHAR();
+
+									if (c==0) {
+										_set_error("Unterminated String");
+										r_token.type=TK_ERROR;
+										return ERR_PARSE_ERROR;
+									}
+									if (!((c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F'))) {
+
+										_set_error("Malformed hex constant in string");
+										r_token.type=TK_ERROR;
+										return ERR_PARSE_ERROR;
+									}
+									CharType v;
+									if (c>='0' && c<='9') {
+										v=c-'0';
+									} else if (c>='a' && c<='f') {
+										v=c-'a';
+										v+=10;
+									} else if (c>='A' && c<='F') {
+										v=c-'A';
+										v+=10;
+									} else {
+										ERR_PRINT("BUG");
+										v=0;
+									}
+
+									res<<=4;
+									res|=v;
+
+
+								}
+
+
+
+							} break;
+							//case '\"': res='\"'; break;
+							//case '\\': res='\\'; break;
+							//case '/': res='/'; break;
+							default: {
+								res = next;
+								//r_err_str="Invalid escape sequence";
+								//return ERR_PARSE_ERROR;
+							} break;
+						}
+
+						str+=res;
+
+					} else {
+						str+=ch;
+					}
+				}
+
+				r_token.type=TK_CONSTANT;
+				r_token.value=str;
+				return OK;
+
+			} break;
+			default: {
+
+				if (cchar<=32) {
+					break;
+				}
+
+				if (cchar=='-' || (cchar>='0' && cchar<='9')) {
+					//a number
+
+
+					String num;
+#define READING_SIGN 0
+#define READING_INT 1
+#define READING_DEC 2
+#define READING_EXP 3
+#define READING_DONE 4
+					int reading=READING_INT;
+
+					if (cchar=='-') {
+						num+='-';
+						cchar=GET_CHAR();
+
+					}
+
+
+
+					CharType c = cchar;
+					bool exp_sign=false;
+					bool exp_beg=false;
+					bool is_float=false;
+
+					while(true) {
+
+						switch(reading) {
+							case READING_INT: {
+
+								if (c>='0' && c<='9') {
+									//pass
+								} else if (c=='.') {
+									reading=READING_DEC;
+									is_float=true;
+								} else if (c=='e') {
+									reading=READING_EXP;
+								} else {
+									reading=READING_DONE;
+								}
+
+							 } break;
+							case READING_DEC: {
+
+								if (c>='0' && c<='9') {
+
+								} else if (c=='e') {
+									reading=READING_EXP;
+
+								} else {
+									reading=READING_DONE;
+								}
+
+							 } break;
+							case READING_EXP: {
+
+								if (c>='0' && c<='9') {
+									exp_beg=true;
+
+								} else if ((c=='-' || c=='+') && !exp_sign && !exp_beg) {
+									if (c=='-')
+										is_float=true;
+									exp_sign=true;
+
+								} else {
+									reading=READING_DONE;
+								}
+							 } break;
+						}
+
+						if (reading==READING_DONE)
+							break;
+						num+=String::chr(c);
+						c = GET_CHAR();
+
+
+					}
+
+					str_ofs--;
+
+					r_token.type=TK_CONSTANT;
+
+					if (is_float)
+						r_token.value=num.to_double();
+					else
+						r_token.value=num.to_int();
+					return OK;
+
+				} else if ((cchar>='A' && cchar<='Z') || (cchar>='a' && cchar<='z') || cchar=='_') {
+
+					String id;
+					bool first=true;
+
+					while((cchar>='A' && cchar<='Z') || (cchar>='a' && cchar<='z') || cchar=='_' || (!first && cchar>='0' && cchar<='9')) {
+
+						id+=String::chr(cchar);
+						cchar=GET_CHAR();
+						first=false;
+					}
+
+					str_ofs--; //go back one
+
+					if (id=="in") {
+						r_token.type=TK_OP_IN;
+					} else if (id=="null") {
+						r_token.type=TK_CONSTANT;
+						r_token.value=Variant();
+					} else if (id=="true") {
+						r_token.type=TK_CONSTANT;
+						r_token.value=true;
+					} else if (id=="false") {
+						r_token.type=TK_CONSTANT;
+						r_token.value=false;
+					} else if (id=="PI") {
+						r_token.type=TK_CONSTANT;
+						r_token.value=Math_PI;
+					} else if (id=="not") {
+						r_token.type=TK_OP_NOT;
+					} else if (id=="or") {
+						r_token.type=TK_OP_OR;
+					} else if (id=="and") {
+						r_token.type=TK_OP_AND;
+					} else if (id=="self") {
+						r_token.type=TK_SELF;
+					} else {
+
+						for(int i=0;i<Variant::VARIANT_MAX;i++) {
+							if (id==Variant::get_type_name(Variant::Type(i))) {
+								r_token.type=TK_BASIC_TYPE;
+								r_token.value=i;
+								return OK;
+								break;
+							}
+						}
+
+						r_token.type=TK_IDENTIFIER;
+						r_token.value=id;
+					}
+
+					return OK;
+				} else {
+					_set_error("Unexpected character.");
+					r_token.type=TK_ERROR;
+					return ERR_PARSE_ERROR;
+				}
+			}
+		}
+	}
+
+	r_token.type=TK_ERROR;
+	return ERR_PARSE_ERROR;
+}
+
+const char* VisualScriptExpression::token_name[TK_MAX]={
+"CURLY BRACKET OPEN",
+"CURLY BRACKET CLOSE",
+"BRACKET OPEN",
+"BRACKET CLOSE",
+"PARENTHESIS OPEN",
+"PARENTHESIS CLOSE",
+"IDENTIFIER",
+"SELF",
+"CONSTANT",
+"BASIC TYPE",
+"COLON",
+"COMMA",
+"PERIOD",
+"OP IN",
+"OP EQUAL",
+"OP NOT EQUAL",
+"OP LESS",
+"OP LESS EQUAL",
+"OP GREATER",
+"OP GREATER EQUAL",
+"OP AND",
+"OP OR",
+"OP NOT",
+"OP ADD",
+"OP SUB",
+"OP MUL",
+"OP DIV",
+"OP MOD",
+"OP SHIFT LEFT",
+"OP SHIFT RIGHT",
+"OP BIT AND",
+"OP BIT OR",
+"OP BIT XOR",
+"OP BIT INVERT",
+"EOF",
+"ERROR"
+};
+
+VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
+
+
+	Vector<Expression> expression;
+
+	while(true) {
+		//keep appending stuff to expression
+		ENode*expr=NULL;
+
+		Token tk;
+		_get_token(tk);
+		if (error_set)
+			return NULL;
+
+
+
+		switch(tk.type) {
+			case TK_CURLY_BRACKET_OPEN: {
+				//a dictionary
+				DictionaryNode *dn = alloc_node<DictionaryNode>();
+
+
+				while(true) {
+
+					int cofs=str_ofs;
+					_get_token(tk);
+					if (tk.type==TK_CURLY_BRACKET_CLOSE) {
+						break;
+					}
+					str_ofs=cofs; //revert
+					//parse an expression
+					ENode* expr=_parse_expression();
+					if (!expr)
+						return NULL;
+					dn->dict.push_back(expr);
+
+					_get_token(tk);
+					if (tk.type!=TK_COLON) {
+						_set_error("Expected ':'");
+						return NULL;
+					}
+
+					expr=_parse_expression();
+					if (!expr)
+						return NULL;
+
+					dn->dict.push_back(expr);
+
+					cofs=str_ofs;
+					_get_token(tk);
+					if (tk.type==TK_COMMA) {
+						//all good
+					} else if (tk.type==TK_CURLY_BRACKET_CLOSE) {
+						str_ofs=cofs;
+					} else {
+						_set_error("Expected ',' or '}'");
+					}
+				}
+
+				expr=dn;
+			} break;
+			case TK_BRACKET_OPEN: {
+				//an array
+
+				ArrayNode *an = alloc_node<ArrayNode>();
+
+
+				while(true) {
+
+					int cofs=str_ofs;
+					_get_token(tk);
+					if (tk.type==TK_BRACKET_CLOSE) {
+						break;
+					}
+					str_ofs=cofs; //revert
+					//parse an expression
+					ENode* expr=_parse_expression();
+					if (!expr)
+						return NULL;
+					an->array.push_back(expr);
+
+					cofs=str_ofs;
+					_get_token(tk);
+					if (tk.type==TK_COMMA) {
+						//all good
+					} else if (tk.type==TK_BRACKET_CLOSE) {
+						str_ofs=cofs;
+					} else {
+						_set_error("Expected ',' or ']'");
+					}
+				}
+
+				expr=an;
+			} break;
+			case TK_PARENTHESIS_OPEN: {
+				//a suexpression
+				ENode* e=_parse_expression();
+				if (error_set)
+					return NULL;
+				_get_token(tk);
+				if (tk.type!=TK_PARENTHESIS_CLOSE) {
+					_set_error("Expected ')'");
+					return NULL;
+				}
+
+				expr=e;
+
+			} break;
+			case TK_IDENTIFIER: {
+
+				String what = tk.value;
+				int index=-1;
+				for(int i=0;i<inputs.size();i++) {
+					if (what==inputs[i].name) {
+						index=i;
+						break;
+					}
+				}
+
+				if (index!=-1) {
+					InputNode *input = alloc_node<InputNode>();
+					input->index=index;
+					expr=input;
+				} else {
+					_set_error("Invalid input identifier '"+what+"'. For script variables, use self (locals are for inputs)."+what);
+					return NULL;
+				}
+			} break;
+			case TK_SELF: {
+
+				SelfNode *self = alloc_node<SelfNode>();
+				expr=self;
+			} break;
+			case TK_CONSTANT: {
+				ConstantNode *constant = alloc_node<ConstantNode>();
+				constant->value=tk.value;
+				expr=constant;
+			} break;
+			case TK_BASIC_TYPE: {
+				//constructor..
+
+				Variant::Type bt = Variant::Type(int(tk.value));
+				_get_token(tk);
+				if (tk.type!=TK_PARENTHESIS_OPEN) {
+					_set_error("Expected '('");
+					return NULL;
+				}
+
+				ConstructorNode *constructor = alloc_node<ConstructorNode>();
+				constructor->data_type=bt;
+
+				while(true) {
+
+					int cofs=str_ofs;
+					_get_token(tk);
+					if (tk.type==TK_PARENTHESIS_CLOSE) {
+						break;
+					}
+					str_ofs=cofs; //revert
+					//parse an expression
+					ENode* expr=_parse_expression();
+					if (!expr)
+						return NULL;
+
+					constructor->arguments.push_back(expr);
+
+					cofs=str_ofs;
+					_get_token(tk);
+					if (tk.type==TK_COMMA) {
+						//all good
+					} else if (tk.type==TK_PARENTHESIS_CLOSE) {
+						str_ofs=cofs;
+					} else {
+						_set_error("Expected ',' or ')'");
+					}
+				}
+
+				expr=constructor;
+
+			} break;
+			case TK_OP_SUB: {
+
+				Expression e;
+				e.is_op=true;
+				e.op=Variant::OP_NEGATE;
+				expression.push_back(e);
+				continue;
+			} break;
+			case TK_OP_NOT: {
+
+				Expression e;
+				e.is_op=true;
+				e.op=Variant::OP_NOT;
+				expression.push_back(e);
+				continue;
+			} break;
+
+			default: {
+				_set_error("Expected expression.");
+				return NULL;
+			} break;
+
+		}
+
+		//before going to operators, must check indexing!
+
+		while(true) {
+			int cofs2=str_ofs;
+			_get_token(tk);
+			if (error_set)
+				return NULL;
+
+			bool done=false;
+
+			switch(tk.type) {
+				case TK_BRACKET_OPEN: {
+					//value indexing
+
+					IndexNode *index = alloc_node<IndexNode>();
+					index->base=expr;
+
+					ENode* what=_parse_expression();
+					if (!what)
+						return NULL;
+
+					index->index=what;
+
+					_get_token(tk);
+					if (tk.type!=TK_BRACKET_CLOSE) {
+						_set_error("Expected ']' at end of index.");
+						return NULL;
+					}
+					expr=index;
+
+				} break;
+				case TK_PERIOD: {
+					//named indexing or function call
+					_get_token(tk);
+					if (tk.type!=TK_IDENTIFIER) {
+						_set_error("Expected identifier after '.'");
+						return NULL;
+					}
+
+					StringName identifier=tk.value;
+
+					int cofs=str_ofs;
+					_get_token(tk);
+					if (tk.type==TK_PARENTHESIS_OPEN) {
+						//function call
+						CallNode *func_call = alloc_node<CallNode>();
+						func_call->method=identifier;
+						func_call->base=expr;
+
+						while(true) {
+
+							int cofs=str_ofs;
+							_get_token(tk);
+							if (tk.type==TK_PARENTHESIS_CLOSE) {
+								break;
+							}
+							str_ofs=cofs; //revert
+							//parse an expression
+							ENode* expr=_parse_expression();
+							if (!expr)
+								return NULL;
+
+							func_call->arguments.push_back(expr);
+
+							cofs=str_ofs;
+							_get_token(tk);
+							if (tk.type==TK_COMMA) {
+								//all good
+							} else if (tk.type==TK_PARENTHESIS_CLOSE) {
+								str_ofs=cofs;
+							} else {
+								_set_error("Expected ',' or ')'");
+							}
+						}
+
+						expr=func_call;
+					} else {
+						//named indexing
+						str_ofs=cofs;
+
+						NamedIndexNode *index = alloc_node<NamedIndexNode>();
+						index->base=expr;
+						index->name=identifier;
+						expr=index;
+
+					}
+
+				} break;
+				default: {
+					str_ofs=cofs2;
+					done=true;
+				} break;
+			}
+
+			if (done)
+				break;
+		}
+
+		//push expression
+		{
+			Expression e;
+			e.is_op=false;
+			e.node=expr;
+			expression.push_back(e);
+		}
+
+		//ok finally look for an operator
+
+
+		int cofs=str_ofs;
+		_get_token(tk);
+		if (error_set)
+			return NULL;
+
+
+		Variant::Operator op = Variant::OP_MAX;
+
+		switch(tk.type) {
+			case TK_OP_IN: op=Variant::OP_IN; break;
+			case TK_OP_EQUAL: op=Variant::OP_EQUAL; break;
+			case TK_OP_NOT_EQUAL: op=Variant::OP_NOT_EQUAL; break;
+			case TK_OP_LESS: op=Variant::OP_LESS; break;
+			case TK_OP_LESS_EQUAL: op=Variant::OP_LESS_EQUAL; break;
+			case TK_OP_GREATER: op=Variant::OP_GREATER; break;
+			case TK_OP_GREATER_EQUAL: op=Variant::OP_GREATER_EQUAL; break;
+			case TK_OP_AND: op=Variant::OP_AND; break;
+			case TK_OP_OR: op=Variant::OP_OR; break;
+			case TK_OP_NOT: op=Variant::OP_NOT; break;
+			case TK_OP_ADD: op=Variant::OP_ADD; break;
+			case TK_OP_SUB: op=Variant::OP_SUBSTRACT; break;
+			case TK_OP_MUL: op=Variant::OP_MULTIPLY; break;
+			case TK_OP_DIV: op=Variant::OP_DIVIDE; break;
+			case TK_OP_MOD: op=Variant::OP_MODULE; break;
+			case TK_OP_SHIFT_LEFT: op=Variant::OP_SHIFT_LEFT; break;
+			case TK_OP_SHIFT_RIGHT: op=Variant::OP_SHIFT_RIGHT; break;
+			case TK_OP_BIT_AND: op=Variant::OP_BIT_AND; break;
+			case TK_OP_BIT_OR: op=Variant::OP_BIT_OR; break;
+			case TK_OP_BIT_XOR: op=Variant::OP_BIT_XOR; break;
+			case TK_OP_BIT_INVERT: op=Variant::OP_BIT_NEGATE; break;
+			default: {};
+		}
+
+		if (op==Variant::OP_MAX) { //stop appending stuff
+			str_ofs=cofs;
+			break;
+		}
+
+		//push operator and go on
+		{
+			Expression e;
+			e.is_op=true;
+			e.op=op;
+			expression.push_back(e);
+		}
+	}
+
+
+	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
+
+
+	while(expression.size()>1) {
+
+		int next_op=-1;
+		int min_priority=0xFFFFF;
+		bool is_unary=false;
+
+		for(int i=0;i<expression.size();i++) {
+
+
+
+			if (!expression[i].is_op) {
+
+				continue;
+			}
+
+			int priority;
+
+			bool unary=false;
+
+			switch(expression[i].op) {
+
+
+				case Variant::OP_BIT_NEGATE: priority=0; unary=true; break;
+				case Variant::OP_NEGATE: priority=1; unary=true; break;
+
+				case Variant::OP_MULTIPLY: priority=2; break;
+				case Variant::OP_DIVIDE: priority=2; break;
+				case Variant::OP_MODULE: priority=2; break;
+
+				case Variant::OP_ADD: priority=3; break;
+				case Variant::OP_SUBSTRACT: priority=3; break;
+
+				case Variant::OP_SHIFT_LEFT: priority=4; break;
+				case Variant::OP_SHIFT_RIGHT: priority=4; break;
+
+				case Variant::OP_BIT_AND: priority=5; break;
+				case Variant::OP_BIT_XOR: priority=6; break;
+				case Variant::OP_BIT_OR: priority=7; break;
+
+				case Variant::OP_LESS: priority=8; break;
+				case Variant::OP_LESS_EQUAL: priority=8; break;
+				case Variant::OP_GREATER: priority=8; break;
+				case Variant::OP_GREATER_EQUAL: priority=8; break;
+
+				case Variant::OP_EQUAL: priority=8; break;
+				case Variant::OP_NOT_EQUAL: priority=8; break;
+
+				case Variant::OP_IN: priority=10; break;
+
+				case Variant::OP_NOT: priority=11; unary=true; break;
+				case Variant::OP_AND: priority=12; break;
+				case Variant::OP_OR: priority=13; break;
+
+
+				default: {
+					_set_error("Parser bug, invalid operator in expression: "+itos(expression[i].op));
+					return NULL;
+				}
+
+			}
+
+			if (priority<min_priority) {
+				// < is used for left to right (default)
+				// <= is used for right to left
+
+				next_op=i;
+				min_priority=priority;
+				is_unary=unary;
+			}
+
+		}
+
+		if (next_op==-1) {
+
+
+			_set_error("Yet another parser bug....");
+			ERR_FAIL_COND_V(next_op==-1,NULL);
+		}
+
+
+		// OK! create operator..
+		if (is_unary) {
+
+			int expr_pos=next_op;
+			while(expression[expr_pos].is_op) {
+
+				expr_pos++;
+				if (expr_pos==expression.size()) {
+					//can happen..
+					_set_error("Unexpected end of expression..");
+					return NULL;
+				}
+			}
+
+			//consecutively do unary opeators
+			for(int i=expr_pos-1;i>=next_op;i--) {
+
+				OperatorNode *op = alloc_node<OperatorNode>();
+				op->op=expression[i].op;
+				op->nodes[0]=expression[i+1].node;
+				op->nodes[1]=NULL;
+				expression[i].is_op=false;
+				expression[i].node=op;
+				expression.remove(i+1);
+			}
+
+
+		} else {
+
+			if (next_op <1 || next_op>=(expression.size()-1)) {
+				_set_error("Parser bug..");
+				ERR_FAIL_V(NULL);
+			}
+
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op=expression[next_op].op;
+
+			if (expression[next_op-1].is_op) {
+
+				_set_error("Parser bug..");
+				ERR_FAIL_V(NULL);
+			}
+
+			if (expression[next_op+1].is_op) {
+				// this is not invalid and can really appear
+				// but it becomes invalid anyway because no binary op
+				// can be followed by an unary op in a valid combination,
+				// due to how precedence works, unaries will always dissapear first
+
+				_set_error("Unexpected two consecutive operators.");
+				return NULL;
+			}
+
+
+			op->nodes[0]=expression[next_op-1].node; //expression goes as left
+			op->nodes[1]=expression[next_op+1].node; //next expression goes as right
+
+			//replace all 3 nodes by this operator and make it an expression
+			expression[next_op-1].node=op;
+			expression.remove(next_op);
+			expression.remove(next_op);
+		}
+	}
+
+	return expression[0].node;
+}
+
+bool VisualScriptExpression::_compile_expression() {
+
+	if (!expression_dirty)
+		return error_set;
+
+	if (nodes) {
+		memdelete(nodes);
+		nodes=NULL;
+		root=NULL;
+
+	}
+
+	error_str=String();
+	error_set=false;
+	str_ofs=0;
+
+	root=_parse_expression();
+
+	if (error_set) {
+		root=NULL;
+		if (nodes) {
+			memdelete(nodes);
+		}
+		nodes=NULL;
+		return true;
+	}
+
+	expression_dirty=false;
+	return false;
+}
+
+
+class VisualScriptNodeInstanceExpression : public VisualScriptNodeInstance {
+public:
+
+	VisualScriptInstance* instance;
+	VisualScriptExpression *expression;
+
+	//virtual int get_working_memory_size() const { return 0; }
+	//execute by parsing the tree directly
+	virtual bool _execute(const Variant** p_inputs,VisualScriptExpression::ENode *p_node,Variant& r_ret,String& r_error_str,Variant::CallError &ce) {
+
+		switch(p_node->type) {
+			case VisualScriptExpression::ENode::TYPE_INPUT:  {
+
+				const VisualScriptExpression::InputNode *in = static_cast<const VisualScriptExpression::InputNode*>(p_node);
+				r_ret=*p_inputs[in->index];
+			} break;
+			case VisualScriptExpression::ENode::TYPE_CONSTANT:  {
+
+				const VisualScriptExpression::ConstantNode *c = static_cast<const VisualScriptExpression::ConstantNode*>(p_node);
+				r_ret=c->value;
+
+			} break;
+			case VisualScriptExpression::ENode::TYPE_SELF:  {
+
+				r_ret=instance->get_owner_ptr();
+			} break;
+			case VisualScriptExpression::ENode::TYPE_OPERATOR:  {
+
+
+				const VisualScriptExpression::OperatorNode *op = static_cast<const VisualScriptExpression::OperatorNode*>(p_node);
+
+				Variant a;
+				bool ret = _execute(p_inputs,op->nodes[0],a,r_error_str,ce);
+				if (ret)
+					return true;
+
+				Variant b;
+
+				if (op->nodes[1]) {
+					ret = _execute(p_inputs,op->nodes[1],b,r_error_str,ce);
+					if (ret)
+						return true;
+				}
+
+				bool valid=true;
+				Variant::evaluate(op->op,a,b,r_ret,valid);
+				if (!valid) {
+					r_error_str="Invalid operands to operator "+Variant::get_operator_name(op->op)+": "+Variant::get_type_name(a.get_type())+" and "+Variant::get_type_name(b.get_type())+".";
+					return true;
+				}
+
+			} break;
+			case VisualScriptExpression::ENode::TYPE_INDEX:  {
+
+				const VisualScriptExpression::IndexNode *index = static_cast<const VisualScriptExpression::IndexNode*>(p_node);
+
+				Variant base;
+				bool ret = _execute(p_inputs,index->base,base,r_error_str,ce);
+				if (ret)
+					return true;
+
+				Variant idx;
+
+				ret = _execute(p_inputs,index->index,idx,r_error_str,ce);
+				if (ret)
+					return true;
+
+				bool valid;
+				r_ret=base.get(idx,&valid);
+				if (!valid) {
+					r_error_str="Invalid index of type "+Variant::get_type_name(idx.get_type())+" for base of type "+Variant::get_type_name(base.get_type())+".";
+					return true;
+				}
+
+
+
+			} break;
+			case VisualScriptExpression::ENode::TYPE_NAMED_INDEX:  {
+
+				const VisualScriptExpression::NamedIndexNode *index = static_cast<const VisualScriptExpression::NamedIndexNode*>(p_node);
+
+				Variant base;
+				bool ret = _execute(p_inputs,index->base,base,r_error_str,ce);
+				if (ret)
+					return true;
+
+				bool valid;
+				r_ret=base.get_named(index->name,&valid);
+				if (!valid) {
+					r_error_str="Invalid index '"+String(index->name)+"' for base of type "+Variant::get_type_name(base.get_type())+".";
+					return true;
+				}
+
+			} break;
+			case VisualScriptExpression::ENode::TYPE_ARRAY:  {
+				const VisualScriptExpression::ArrayNode *array = static_cast<const VisualScriptExpression::ArrayNode*>(p_node);
+
+				Array arr;
+				arr.resize(array->array.size());
+				for (int i=0;i<array->array.size();i++) {
+
+					Variant value;
+					bool ret = _execute(p_inputs,array->array[i],value,r_error_str,ce);
+					if (ret)
+						return true;
+					arr[i]=value;
+				}
+
+				r_ret=arr;
+
+			} break;
+			case VisualScriptExpression::ENode::TYPE_DICTIONARY:  {
+				const VisualScriptExpression::DictionaryNode *dictionary = static_cast<const VisualScriptExpression::DictionaryNode*>(p_node);
+
+				Dictionary d;
+				for (int i=0;i<dictionary->dict.size();i+=2) {
+
+					Variant key;
+					bool ret = _execute(p_inputs,dictionary->dict[i+0],key,r_error_str,ce);
+					if (ret)
+						return true;
+
+					Variant value;
+					ret = _execute(p_inputs,dictionary->dict[i+1],value,r_error_str,ce);
+					if (ret)
+						return true;
+
+					d[key]=value;
+				}
+
+				r_ret=d;
+			} break;
+			case VisualScriptExpression::ENode::TYPE_CONSTRUCTOR:  {
+
+				const VisualScriptExpression::ConstructorNode *constructor = static_cast<const VisualScriptExpression::ConstructorNode*>(p_node);
+
+				Vector<Variant> arr;
+				Vector<const Variant*> argp;
+				arr.resize(constructor->arguments.size());
+				argp.resize(constructor->arguments.size());
+
+				for (int i=0;i<constructor->arguments.size();i++) {
+
+					Variant value;
+					bool ret = _execute(p_inputs,constructor->arguments[i],value,r_error_str,ce);
+					if (ret)
+						return true;
+					arr[i]=value;
+					argp[i]=&arr[i];
+				}
+
+
+				r_ret=Variant::construct(constructor->data_type,argp.ptr(),argp.size(),ce);
+
+				if (ce.error!=Variant::CallError::CALL_OK) {
+					r_error_str="Invalid arguments to construct '"+Variant::get_type_name(constructor->data_type)+"'.";
+					return true;
+				}
+
+
+			} break;
+			case VisualScriptExpression::ENode::TYPE_CALL:  {
+
+				const VisualScriptExpression::CallNode *call = static_cast<const VisualScriptExpression::CallNode*>(p_node);
+
+
+				Variant base;
+				bool ret = _execute(p_inputs,call->base,base,r_error_str,ce);
+				if (ret)
+					return true;
+
+				Vector<Variant> arr;
+				Vector<const Variant*> argp;
+				arr.resize(call->arguments.size());
+				argp.resize(call->arguments.size());
+
+				for (int i=0;i<call->arguments.size();i++) {
+
+					Variant value;
+					bool ret = _execute(p_inputs,call->arguments[i],value,r_error_str,ce);
+					if (ret)
+						return true;
+					arr[i]=value;
+					argp[i]=&arr[i];
+				}
+
+
+				r_ret=base.call(call->method,argp.ptr(),argp.size(),ce);
+
+				if (ce.error!=Variant::CallError::CALL_OK) {
+					r_error_str="On call to '"+String(call->method)+"':";
+					return true;
+				}
+
+			} break;
+		}
+		return false;
+	}
+
+	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+
+		if (!expression->root || expression->error_set) {
+			r_error_str=expression->error_str;
+			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			return 0;
+		}
+
+
+		bool error = _execute(p_inputs,expression->root,*p_outputs[0],r_error_str,r_error);
+		if (error && r_error.error==Variant::CallError::CALL_OK) {
+			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		}
+
+#ifdef DEBUG_ENABLED
+		if (!error && expression->output_type!=Variant::NIL && !Variant::can_convert_strict(p_outputs[0]->get_type(),expression->output_type)) {
+
+			r_error_str+="Can't convert expression result from "+Variant::get_type_name(p_outputs[0]->get_type())+" to "+Variant::get_type_name(expression->output_type)+".";
+			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+
+#endif
+		}
+
+		return 0;
+	}
+
+
+};
+
+VisualScriptNodeInstance* VisualScriptExpression::instance(VisualScriptInstance* p_instance){
+
+	_compile_expression();
+	VisualScriptNodeInstanceExpression *instance = memnew( VisualScriptNodeInstanceExpression );
+	instance->instance=p_instance;
+	instance->expression=this;
+	return instance;
+}
+
+
+VisualScriptExpression::VisualScriptExpression()
+{
+	output_type=Variant::NIL;
+	expression_dirty=true;
+	error_set=true;
+	root=NULL;
+	nodes=NULL;
+	sequenced=false;
+}
+
+VisualScriptExpression::~VisualScriptExpression() {
+
+	if (nodes) {
+		memdelete(nodes);
+	}
+}
+
+
+void register_visual_script_expression_node() {
+
+	VisualScriptLanguage::singleton->add_register_func("operators/expression",create_node_generic<VisualScriptExpression>);
+
+}

modules/visual_script/visual_script_expression.h

@@ -0,0 +1,269 @@
+#ifndef VISUALSCRIPTEXPRESSION_H
+#define VISUALSCRIPTEXPRESSION_H
+
+#include "visual_script.h"
+
+class VisualScriptExpression : public VisualScriptNode {
+
+	OBJ_TYPE(VisualScriptExpression,VisualScriptNode)
+friend class VisualScriptNodeInstanceExpression;
+
+	struct Input {
+
+		Variant::Type type;
+		String name;
+
+		Input() { type=Variant::NIL; }
+	};
+
+	Vector<Input> inputs;
+	Variant::Type output_type;
+
+	String expression;
+
+	bool sequenced;
+	int str_ofs;
+	bool expression_dirty;
+
+	bool _compile_expression();
+
+	enum TokenType {
+		TK_CURLY_BRACKET_OPEN,
+		TK_CURLY_BRACKET_CLOSE,
+		TK_BRACKET_OPEN,
+		TK_BRACKET_CLOSE,
+		TK_PARENTHESIS_OPEN,
+		TK_PARENTHESIS_CLOSE,
+		TK_IDENTIFIER,
+		TK_SELF,
+		TK_CONSTANT,
+		TK_BASIC_TYPE,
+		TK_COLON,
+		TK_COMMA,
+		TK_PERIOD,
+		TK_OP_IN,
+		TK_OP_EQUAL,
+		TK_OP_NOT_EQUAL,
+		TK_OP_LESS,
+		TK_OP_LESS_EQUAL,
+		TK_OP_GREATER,
+		TK_OP_GREATER_EQUAL,
+		TK_OP_AND,
+		TK_OP_OR,
+		TK_OP_NOT,
+		TK_OP_ADD,
+		TK_OP_SUB,
+		TK_OP_MUL,
+		TK_OP_DIV,
+		TK_OP_MOD,
+		TK_OP_SHIFT_LEFT,
+		TK_OP_SHIFT_RIGHT,
+		TK_OP_BIT_AND,
+		TK_OP_BIT_OR,
+		TK_OP_BIT_XOR,
+		TK_OP_BIT_INVERT,
+		TK_EOF,
+		TK_ERROR,
+		TK_MAX
+	};
+
+	static const char* token_name[TK_MAX];
+	struct Token {
+
+		TokenType type;
+		Variant value;
+	};
+
+
+	void _set_error(const String& p_err) {
+		if (error_set)
+			return;
+		error_str=p_err;
+		error_set=true;
+	}
+
+	Error _get_token(Token& r_token);
+
+	String error_str;
+	bool error_set;
+
+
+
+	struct ENode {
+
+		enum Type {
+			TYPE_INPUT,
+			TYPE_CONSTANT,
+			TYPE_SELF,
+			TYPE_OPERATOR,
+			TYPE_INDEX,
+			TYPE_NAMED_INDEX,
+			TYPE_ARRAY,
+			TYPE_DICTIONARY,
+			TYPE_CONSTRUCTOR,
+			TYPE_CALL
+		};
+
+		ENode *next;
+
+		Type type;
+
+		ENode() { next=NULL; }
+		virtual ~ENode() { if (next) { memdelete(next); } }
+	};
+
+	struct Expression {
+
+		bool is_op;
+		union {
+			Variant::Operator op;
+			ENode *node;
+		};
+	};
+
+	ENode* _parse_expression();
+
+	struct InputNode : public ENode {
+
+		int index;
+		InputNode() {
+			type=TYPE_INPUT;
+		}
+	};
+
+
+	struct ConstantNode : public ENode {
+
+		Variant value;
+		ConstantNode() {
+			type=TYPE_CONSTANT;
+		}
+	};
+
+	struct OperatorNode : public ENode {
+
+		Variant::Operator op;
+
+		ENode* nodes[2];
+
+		OperatorNode() {
+			type=TYPE_OPERATOR;
+		}
+	};
+
+	struct SelfNode : public ENode {
+
+
+		SelfNode() {
+			type=TYPE_SELF;
+		}
+	};
+
+	struct IndexNode : public ENode {
+		ENode*base;
+		ENode*index;
+
+		IndexNode() {
+			type=TYPE_INDEX;
+		}
+	};
+
+	struct NamedIndexNode : public ENode {
+		ENode*base;
+		StringName name;
+
+		NamedIndexNode() {
+			type=TYPE_NAMED_INDEX;
+		}
+
+	};
+
+	struct ConstructorNode : public ENode {
+		Variant::Type data_type;
+		Vector<ENode*> arguments;
+
+		ConstructorNode() {
+			type=TYPE_CONSTRUCTOR;
+		}
+	};
+
+	struct CallNode : public ENode {
+		ENode*base;
+		StringName method;
+		Vector<ENode*> arguments;
+
+		CallNode() {
+			type=TYPE_CALL;
+		}
+
+	};
+
+	struct ArrayNode : public ENode {
+		Vector<ENode*> array;
+		ArrayNode() {
+			type=TYPE_ARRAY;
+		}
+
+	};
+
+	struct DictionaryNode : public ENode {
+		Vector<ENode*> dict;
+		DictionaryNode() {
+			type=TYPE_DICTIONARY;
+		}
+
+	};
+
+	template<class T>
+	T* alloc_node() {
+		T* node = memnew(T);
+		node->next=nodes;
+		nodes=node;
+		return node;
+	}
+
+	ENode *root;
+	ENode *nodes;
+
+
+
+
+
+protected:
+
+	bool _set(const StringName& p_name, const Variant& p_value);
+	bool _get(const StringName& p_name,Variant &r_ret) const;
+	void _get_property_list( List<PropertyInfo> *p_list) const;
+
+public:
+
+
+	virtual int get_output_sequence_port_count() const;
+	virtual bool has_input_sequence_port() const;
+
+
+	virtual String get_output_sequence_port_text(int p_port) const;
+
+
+	virtual int get_input_value_port_count() const;
+	virtual int get_output_value_port_count() const;
+
+
+	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
+	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
+
+	virtual String get_caption() const;
+	virtual String get_text() const;
+	virtual String get_category() const { return "operators"; }
+
+	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+
+	VisualScriptExpression();
+	~VisualScriptExpression();
+};
+
+
+void register_visual_script_expression_node();
+
+
+#endif // VISUALSCRIPTEXPRESSION_H

modules/visual_script/visual_script_nodes.cpp

@@ -553,7 +553,7 @@ void VisualScriptOperator::_bind_methods() {
 		argt+=","+Variant::get_type_name(Variant::Type(i));
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"operator_value/type",PROPERTY_HINT_ENUM,types,PROPERTY_USAGE_NOEDITOR),_SCS("set_operator"),_SCS("get_operator"));
+	ADD_PROPERTY(PropertyInfo(Variant::INT,"operator_value/type",PROPERTY_HINT_ENUM,types),_SCS("set_operator"),_SCS("get_operator"));
 	ADD_PROPERTY(PropertyInfo(Variant::INT,"typed_value/typed",PROPERTY_HINT_ENUM,argt),_SCS("set_typed"),_SCS("get_typed"));
 
 }