asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #3894 from akien-mga/pr-revert-3814

Browse source 
Revert "Merge pull request #3814 from est31/iterators_for_for"
This commit is contained in:
Rémi Verschelde 2016-03-01 19:05:00 +01:00
commit d0c95ec191
7 changed files with 0 additions and 385 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

169
core/range_iterator.cpp
View file

@ -1,169 +0,0 @@
/*************************************************************************/
/* range_iterator.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "range_iterator.h"
#include "object_type_db.h"
void RangeIterator::_bind_methods() {
ObjectTypeDB::bind_method(_MD("_iter_init","arg"),&RangeIterator::_iter_init);
ObjectTypeDB::bind_method(_MD("_iter_next","arg"),&RangeIterator::_iter_next);
ObjectTypeDB::bind_method(_MD("_iter_get","arg"),&RangeIterator::_iter_get);
ObjectTypeDB::bind_method(_MD("is_finished"),&RangeIterator::is_finished);
ObjectTypeDB::bind_method(_MD("to_array"),&RangeIterator::to_array);
ObjectTypeDB::bind_method(_MD("set_range","arg1","arg2","arg3"),&RangeIterator::_set_range,DEFVAL(Variant()),DEFVAL(Variant()));
}
bool RangeIterator::_iter_init(Variant arg) {
return !is_finished();
}
bool RangeIterator::_iter_next(Variant arg) {
current += step;
return !is_finished();
}
Variant RangeIterator::_iter_get(Variant arg) {
return Variant(current);
}
bool RangeIterator::is_finished() {
if(step > 0)
{
return current >= stop;
}
else
{
return current <= stop;
}
}
Array RangeIterator::to_array() {
if (step==0) {
ERR_EXPLAIN("step is zero!");
ERR_FAIL_V(Array());
}
Array arr(true);
if (current >= stop && step > 0) {
return arr;
}
if (current <= stop && step < 0) {
return arr;
}
//calculate how many
int count=0;
if (step > 0) {
count=((stop-current-1)/step)+1;
} else {
count=((current-stop-1)/-step)+1;
}
arr.resize(count);
if (step > 0) {
int idx=0;
for(int i=current;i<stop;i+=step) {
arr[idx++]=i;
}
} else {
int idx=0;
for(int i=current;i>stop;i+=step) {
arr[idx++]=i;
}
}
return arr;
}
void RangeIterator::set_range(int stop) {
this->current = 0;
this->stop = stop;
this->step = (stop > 0)?(1):(-1);
}
void RangeIterator::set_range(int start, int stop) {
this->current = start;
this->stop = stop;
this->step = (stop > start)?(1):(-1);
}
void RangeIterator::set_range(int start, int stop, int step) {
if(step == 0)
{
ERR_EXPLAIN("step is zero!");
ERR_FAIL();
}
this->current = start;
this->stop = stop;
this->step = step;
}
Ref<RangeIterator> RangeIterator::_set_range(Variant arg1, Variant arg2, Variant arg3)
{
bool valid = true;
if(arg1.get_type() == Variant::INT)
{
if(arg2.get_type() == Variant::INT)
{
if(arg3.get_type() == Variant::INT) set_range((int)arg1, (int)arg2, (int)arg3); // (start, end, step)
else if(arg3.get_type() == Variant::NIL) set_range((int)arg1, (int)arg2); // (start, end)
else valid = false;
}
else if(arg2.get_type() == Variant::NIL) set_range((int)arg1); // (end)
else valid = false;
}
else valid = false;
if(!valid)
{
ERR_EXPLAIN("Invalid type in function 'set_range' in base 'RangeIterator'. Expected 1, 2, or 3 ints.");
ERR_FAIL_V(Ref<RangeIterator>());
}
return Ref<RangeIterator>(this);
}
RangeIterator::RangeIterator() {
current = 0;
stop = 0;
step = 0;
}
RangeIterator::RangeIterator(int stop) {
set_range(stop);
}
RangeIterator::RangeIterator(int start, int stop) {
set_range(start, stop);
}
RangeIterator::RangeIterator(int start, int stop, int step) {
set_range(start, stop, step);
}

72
core/range_iterator.h
View file

@ -1,72 +0,0 @@
/*************************************************************************/
/* range_iterator.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 RANGE_ITERATOR_H
#define RANGE_ITERATOR_H
#include "reference.h"
#include "variant.h"
#include "array.h"
class RangeIterator : public Reference
{
protected:
OBJ_TYPE( RangeIterator, Reference );
static void _bind_methods();
private:
int current;
int stop;
int step;
bool _iter_init(Variant arg);
bool _iter_next(Variant arg);
Variant _iter_get(Variant arg);
public:
bool is_finished();
Array to_array();
void set_range(int stop);
void set_range(int start, int stop);
void set_range(int start, int stop, int step);
Ref<RangeIterator> _set_range(Variant arg1, Variant arg2 = Variant(), Variant arg3 = Variant());
void _init(Variant arg1, Variant arg2, Variant arg3);
RangeIterator();
RangeIterator(int stop);
RangeIterator(int start, int stop);
RangeIterator(int start, int stop, int step);
};
#endif // RANGE_ITERATOR_H

3
core/register_core_types.cpp
View file

@ -52,7 +52,6 @@
#include "func_ref.h"
#include "input_map.h"
#include "undo_redo.h"
#include "range_iterator.h"
#ifdef XML_ENABLED
static ResourceFormatSaverXML *resource_saver_xml=NULL;
@ -131,8 +130,6 @@ void register_core_types() {
ObjectTypeDB::register_type<Translation>();
ObjectTypeDB::register_type<PHashTranslation>();
ObjectTypeDB::register_type<UndoRedo>();
ObjectTypeDB::register_type<RangeIterator>();
ObjectTypeDB::register_type<HTTPClient>();
ObjectTypeDB::register_virtual_type<ResourceInteractiveLoader>();

43
doc/base/classes.xml
View file

@ -556,15 +556,6 @@
Return an array with the given range. Range can be 1 argument N (0 to N-1), two arguments (initial, final-1) or three arguments (initial,final-1,increment).
</description>
</method>
<method name="xrange">
<return type="Object">
</return>
<argument index="0" name="..." type="Variant">
</argument>
<description>
Return an iterator over the given range. Range can be 1 argument N (0 to N-1), two arguments (initial, final-1) or three arguments (initial,final-1,increment).
</description>
</method>
<method name="load">
<return type="Resource">
</return>
@ -27612,40 +27603,6 @@ This method controls whether the position between two cached points is interpola
<constants>
</constants>
</class>
<class name="RangeIterator" inherits="Reference" category="Core">
<brief_description>
</brief_description>
<description>
</description>
<methods>
<method name="is_finished">
<return type="bool">
</return>
<description>
</description>
</method>
<method name="to_array">
<return type="Array">
</return>
<description>
</description>
</method>
<method name="set_range">
<return type="Object">
</return>
<argument index="0" name="arg1" type="Variant">
</argument>
<argument index="1" name="arg2" type="Variant" default="NULL">
</argument>
<argument index="2" name="arg3" type="Variant" default="NULL">
</argument>
<description>
</description>
</method>
</methods>
<constants>
</constants>
</class>
<class name="RawArray" category="Built-In Types">
<brief_description>
Raw byte array.

83
modules/gdscript/gd_functions.cpp
View file

@ -32,7 +32,6 @@
#include "reference.h"
#include "gd_script.h"
#include "func_ref.h"
#include "range_iterator.h"
#include "os/os.h"
#include "variant_parser.h"
#include "io/marshalls.h"
@ -99,7 +98,6 @@ const char *GDFunctions::get_func_name(Function p_func) {
"var2bytes",
"bytes2var",
"range",
"xrange",
"load",
"inst2dict",
"dict2inst",
@ -817,81 +815,6 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
} break;
}
} break;
case GEN_XRANGE: {
switch(p_arg_count) {
case 0: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument=1;
} break;
case 1: {
VALIDATE_ARG_NUM(0);
int count=*p_args[0];
Ref<RangeIterator> itr = Ref<RangeIterator>( memnew(RangeIterator) );
if (!*itr) {
ERR_EXPLAIN("Couldn't allocate iterator!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
ERR_FAIL();
}
(*itr)->set_range(count);
r_ret=Variant(itr);
return;
} break;
case 2: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
int from=*p_args[0];
int to=*p_args[1];
Ref<RangeIterator> itr = Ref<RangeIterator>( memnew(RangeIterator) );
if (!*itr) {
ERR_EXPLAIN("Couldn't allocate iterator!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
ERR_FAIL();
}
(*itr)->set_range(from, to);
r_ret=Variant(itr);
return;
} break;
case 3: {
VALIDATE_ARG_NUM(0);
VALIDATE_ARG_NUM(1);
VALIDATE_ARG_NUM(2);
int from=*p_args[0];
int to=*p_args[1];
int incr=*p_args[2];
if (incr==0) {
ERR_EXPLAIN("step argument is zero!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
ERR_FAIL();
}
Ref<RangeIterator> itr = Ref<RangeIterator>( memnew(RangeIterator) );
if (!*itr) {
ERR_EXPLAIN("Couldn't allocate iterator!");
r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
ERR_FAIL();
}
(*itr)->set_range(from, to, incr);
r_ret=Variant(itr);
return;
} break;
default: {
r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument=3;
} break;
}
} break;
case RESOURCE_LOAD: {
VALIDATE_ARG_COUNT(1);
@ -1510,12 +1433,6 @@ MethodInfo GDFunctions::get_info(Function p_func) {
mi.return_val.type=Variant::ARRAY;
return mi;
} break;
case GEN_XRANGE: {
MethodInfo mi("xrange",PropertyInfo(Variant::NIL,"..."));
mi.return_val.type=Variant::OBJECT;
return mi;
} break;
case RESOURCE_LOAD: {
MethodInfo mi("load",PropertyInfo(Variant::STRING,"path"));

1
modules/gdscript/gd_functions.h
View file

@ -92,7 +92,6 @@ public:
VAR_TO_BYTES,
BYTES_TO_VAR,
GEN_RANGE,
GEN_XRANGE,
RESOURCE_LOAD,
INST2DICT,
DICT2INST,

14
modules/gdscript/gd_parser.cpp
View file

@ -1779,20 +1779,6 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
return;
}
// Little optimisation for common usage "for i in range(...):":
// don't create and initialize a possibly huge array as range()
// would do, but instead create an iterator using xrange()
if (container->type == Node::TYPE_OPERATOR) {
OperatorNode *op = static_cast<OperatorNode *>(container);
if (op->arguments.size() > 0 &&
op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION) {
BuiltInFunctionNode *c = static_cast<BuiltInFunctionNode *>(op->arguments[0]);
if (c->function == GDFunctions::GEN_RANGE) {
c->function = GDFunctions::GEN_XRANGE;
}
}
}
ControlFlowNode *cf_for = alloc_node<ControlFlowNode>();
cf_for->cf_type=ControlFlowNode::CF_FOR;