FALCON_FUNC Dictionary_mfcomp ( ::Falcon::VMachine *vm )
{
Item* i_func = vm->param(0);
if ( i_func == 0 )
{
throw new ParamError( ErrorParam( e_inv_params, __LINE__ )
.extra( "C, ..." ) );
}
// Save the parameters as the stack may change greatly.
CoreDict* dict = vm->self().asDict();
StackFrame* current = vm->currentFrame();
Item i_check = *i_func;
// if this is a blessed dictionary, we must use the append method.
if ( dict->isBlessed() )
{
// this will throw if dict has not "append"
PoopSeq *seq = new PoopSeq( vm, dict );
vm->pushParam( new GarbagePointer( seq ) );
seq->comprehension_start( vm, dict, i_check );
}
else {
dict->items().comprehension_start( vm, dict, i_check );
}
for( uint32 i = 1; i < current->m_param_count; ++i )
{
vm->pushParam( current->m_params[i] );
}
}
FALCON_FUNC Dictionary_comp ( ::Falcon::VMachine *vm )
{
if ( vm->param(0) == 0 )
{
throw new ParamError( ErrorParam( e_inv_params, __LINE__ )
.extra( "R|A|C|Sequence, [C]" ) );
}
// Save the parameters as the stack may change greatly.
CoreDict* dict = vm->self().asDict();
Item i_gen = *vm->param(0);
Item i_check = vm->param(1) == 0 ? Item(): *vm->param(1);
// if this is a blessed dictionary, we must use the append method.
if ( dict->isBlessed() )
{
// this will throw if dict has not "append"
PoopSeq *seq = new PoopSeq( vm, dict );
vm->pushParam( new GarbagePointer( seq ) );
seq->comprehension_start( vm, dict, i_check );
}
else {
dict->items().comprehension_start( vm, dict, i_check );
}
vm->pushParam( i_gen );
}
FALCON_FUNC Dictionary_mcomp ( ::Falcon::VMachine *vm )
{
// Save the parameters as the stack may change greatly.
CoreDict* dict = vm->self().asDict();
StackFrame* current = vm->currentFrame();
// if this is a blessed dictionary, we must use the append method.
if ( dict->isBlessed() )
{
// this will throw if dict has not "append"
PoopSeq *seq = new PoopSeq( vm, dict );
vm->pushParam( new GarbagePointer( seq ) );
seq->comprehension_start( vm, dict, Item() );
}
else {
dict->items().comprehension_start( vm, dict, Item() );
}
for( uint32 i = 0; i < current->m_param_count; ++i )
{
vm->pushParam( current->m_params[i] );
}
}
static void describe_internal( VMachine *vm, String &tgt, const Item *elem, int32 level, int32 maxLevel, int32 maxSize )
{
uint32 count;
// return if we reached the maximum level.
if ( maxLevel >= 0 && level > maxLevel )
{
tgt += "...";
return;
}
switch( elem->type() )
{
case FLC_ITEM_NIL:
tgt += "Nil";
break;
case FLC_ITEM_UNB:
tgt += "_";
break;
case FLC_ITEM_BOOL:
tgt += elem->asBoolean() ? "true" : "false";
break;
case FLC_ITEM_INT:
tgt.writeNumber( elem->asInteger() );
break;
case FLC_ITEM_NUM:
tgt.writeNumber( elem->asNumeric(), "%g" );
break;
case FLC_ITEM_RANGE:
elem->toString(tgt);
break;
case FLC_ITEM_STRING:
tgt += "\"";
if ( maxSize < 0 || elem->asString()->length() < (uint32) maxSize )
{
tgt += *elem->asString();
tgt += "\"";
}
else {
tgt += elem->asString()->subString(0, maxSize );
tgt += " ... \"";
}
break;
case FLC_ITEM_LBIND:
tgt += "&";
tgt += *elem->asLBind();
if (elem->isFutureBind())
{
tgt +="|";
describe_internal( vm, tgt, &elem->asFutureBind(), level+1, maxLevel, maxSize );
}
break;
case FLC_ITEM_MEMBUF:
{
MemBuf *mb = elem->asMemBuf();
tgt += "MB(";
tgt.writeNumber( (int64) mb->length() );
tgt += ",";
tgt.writeNumber( (int64) mb->wordSize() );
tgt += ")";
tgt += " [";
String fmt;
int limit = 0;
switch ( mb->wordSize() )
{
case 1: fmt = "%02" LLFMT "X"; limit = 24; break;
case 2: fmt = "%04" LLFMT "X"; limit = 12; break;
case 3: fmt = "%06" LLFMT "X"; limit = 9; break;
case 4: fmt = "%08" LLFMT "X"; limit = 6; break;
}
uint32 max = maxSize < 0 || mb->length() < (uint32) maxSize ? mb->length() : (uint32) maxSize;
for( count = 0; count < max; count++ )
{
tgt.writeNumber( (int64) mb->get( count ), fmt );
tgt += " ";
}
if ( count == (uint32) maxSize )
tgt += " ...";
tgt += "]";
}
break;
case FLC_ITEM_ARRAY:
{
CoreArray *arr = elem->asArray();
tgt += "[";
if ( level == maxLevel )
{
tgt += "...]";
break;
}
for( count = 0; count < arr->length(); count++ ) {
if ( count == 0 ) tgt += " ";
describe_internal( vm, tgt, & ((*arr)[count]), level + 1, maxLevel, maxSize );
if ( count + 1 < arr->length() )
tgt += ", ";
}
tgt +="]";
}
break;
case FLC_ITEM_DICT:
{
CoreDict *dict = elem->asDict();
if( dict->isBlessed() )
tgt += "*";
tgt += "[";
if ( level == maxLevel )
{
tgt += "...=>...]";
break;
}
if ( dict->length() == 0 )
{
tgt += "=>]";
break;
}
Item key, value;
Iterator iter( &dict->items() );
// separate the first loop to be able to add ", "
describe_internal( vm, tgt, &iter.getCurrentKey(), level + 1, maxLevel, maxSize );
tgt += " => ";
describe_internal( vm, tgt, &iter.getCurrent(), level + 1, maxLevel, maxSize );
iter.next();
while( iter.hasCurrent() )
{
tgt += ", ";
describe_internal( vm, tgt, &iter.getCurrentKey(), level + 1, maxLevel, maxSize );
tgt += " => ";
describe_internal( vm, tgt, &iter.getCurrent(), level + 1, maxLevel, maxSize );
iter.next();
}
tgt += "]";
}
break;
case FLC_ITEM_OBJECT:
{
CoreObject *arr = elem->asObjectSafe();
tgt += arr->generator()->symbol()->name() + "(){ ";
if ( level == maxLevel )
{
tgt += "...}";
break;
}
const PropertyTable &pt = arr->generator()->properties();
for( count = 0; count < pt.added() ; count++ )
{
const String &propName = *pt.getKey( count );
// write only?
if ( pt.getEntry( count ).isWriteOnly() )
{
tgt.A( "(" ).A( propName ).A(")");
}
else
{
Item dummy;
arr->getProperty( propName, dummy );
// in describe skip methods.
if ( dummy.isFunction() || dummy.isMethod() )
continue;
tgt += propName + " = ";
describe_internal( vm, tgt, &dummy, level + 1, maxLevel, maxSize );
}
if (count+1 < pt.added())
{
tgt += ", ";
}
}
tgt += "}";
}
break;
case FLC_ITEM_CLASS:
tgt += "Class " + elem->asClass()->symbol()->name();
break;
case FLC_ITEM_METHOD:
{
tgt += "(";
Item itemp;
elem->getMethodItem( itemp );
describe_internal( vm, tgt, &itemp, level + 1, maxLevel, maxSize );
tgt += ").";
tgt += elem->asMethodFunc()->name() + "()";
}
break;
case FLC_ITEM_CLSMETHOD:
tgt += "Class ";
tgt += elem->asMethodClassOwner()->generator()->symbol()->name();
tgt += "." + elem->asMethodClass()->symbol()->name() + "()";
break;
case FLC_ITEM_FUNC:
{
const Symbol *funcSym = elem->asFunction()->symbol();
tgt += funcSym->name() + "()";
}
break;
case FLC_ITEM_REFERENCE:
tgt += "->";
describe_internal( vm, tgt, elem->dereference(), level + 1, maxLevel, maxSize );
break;
default:
tgt += "?";
}
}
Item::e_sercode Item::serialize( Stream *file, bool bLive ) const
{
if( file->bad() )
return sc_ferror;
switch( this->type() )
{
case FLC_ITEM_BOOL:
{
byte type = FLC_ITEM_BOOL;
file->write((byte *) &type, 1 );
byte bval = this->asBoolean() ? 1 : 0;
file->write( (byte *) &bval, sizeof( bval ) );
}
break;
case FLC_ITEM_INT:
{
byte type = FLC_ITEM_INT;
file->write((byte *) &type, 1 );
int64 val = endianInt64( this->asInteger() );
file->write( (byte *) &val, sizeof( val ) );
}
break;
case FLC_ITEM_RANGE:
{
byte type = FLC_ITEM_RANGE;
file->write((byte *) &type, 1 );
int64 val1 = endianInt64(this->asRangeStart());
int64 val2 = endianInt64(this->asRangeEnd());
int64 val3 = endianInt64(this->asRangeStep());
//byte isOpen = this->asRangeIsOpen() ? 1 : 0;
file->write( (byte *) &val1, sizeof( val1 ) );
file->write( (byte *) &val2, sizeof( val2 ) );
file->write( (byte *) &val3, sizeof( val3 ) );
//file->write( (byte *) &isOpen, sizeof( isOpen ) );
}
break;
case FLC_ITEM_NUM:
{
byte type = FLC_ITEM_NUM;
file->write((byte *) &type, 1 );
numeric val = endianNum( this->asNumeric() );
file->write( (byte *) &val, sizeof( val ) );
}
break;
case FLC_ITEM_STRING:
{
byte type = FLC_ITEM_STRING;
file->write((byte *) &type, 1 );
this->asString()->serialize( file );
}
break;
case FLC_ITEM_LBIND:
{
byte type = FLC_ITEM_LBIND;
file->write((byte *) &type, 1 );
// Future bindings are temporary items; as such, their future
// value is not to be serialized.
asLBind()->serialize( file );
}
break;
case FLC_ITEM_MEMBUF:
{
byte type = FLC_ITEM_MEMBUF;
if ( bLive )
{
type |= 0x80;
file->write( &type, 1 );
MemBuf* mb = asMemBuf();
file->write( &mb, sizeof(mb) );
}
else {
file->write( &type, 1 );
this->asMemBuf()->serialize( file, bLive );
}
}
break;
case FLC_ITEM_ARRAY:
{
byte type = FLC_ITEM_ARRAY;
file->write((byte *) &type, 1 );
CoreArray &array = *this->asArray();
int32 len = endianInt32( array.length() );
file->write( (byte *) &len, sizeof( len ) );
for( uint32 i = 0; i < array.length(); i ++ ) {
array[i].serialize( file, bLive );
if( ! file->good() )
return sc_ferror;
}
}
break;
case FLC_ITEM_DICT:
{
byte type = FLC_ITEM_DICT;
file->write( &type, 1 );
CoreDict *dict = this->asDict();
type = dict->isBlessed() ? 1:0;
file->write( &type, 1 );
int32 len = endianInt32( dict->length() );
file->write( (byte *) &len, sizeof( len ) );
Iterator iter( &dict->items() );
while( iter.hasCurrent() )
{
iter.getCurrentKey().serialize( file, bLive );
if( ! file->good() )
return sc_ferror;
iter.getCurrent().serialize( file, bLive );
if( ! file->good() )
return sc_ferror;
iter.next();
}
}
break;
case FLC_ITEM_FUNC:
serialize_function( file, this->asFunction(), bLive );
break;
case FLC_ITEM_METHOD:
{
byte type = FLC_ITEM_METHOD;
file->write( &type, 1 );
e_sercode sc = asMethodItem().serialize( file, bLive );
if( sc != sc_ok )
return sc;
CallPoint* cp = this->asMethodFunc();
if ( cp->isFunc() )
{
serialize_function( file, static_cast<CoreFunc*>(cp), bLive );
}
else
{
SafeItem arr( static_cast<CoreArray*>(cp) );
arr.serialize(file, bLive );
}
}
break;
case FLC_ITEM_OBJECT:
serialize_object( file, this->asObjectSafe(), bLive );
break;
case FLC_ITEM_REFERENCE:
asReference()->origin().serialize( file, bLive );
break;
case FLC_ITEM_CLASS:
serialize_class( file, this->asClass() );
break;
case FLC_ITEM_CLSMETHOD:
serialize_class( file, this->asMethodClass() );
serialize_function( file, this->asFunction(), bLive );
break;
case FLC_ITEM_UNB:
{
byte type = FLC_ITEM_UNB;
file->write((byte *) &type, 1 );
}
break;
default:
{
byte type = FLC_ITEM_NIL;
file->write((byte *) &type, 1 );
}
}
return file->bad() ? sc_ferror : sc_ok;
}
