AbstractString * ZeroRankArray::write_to_string() { Thread * thread = current_thread(); bool print_readably = (thread->symbol_value(S_print_readably) != NIL); if (print_readably) { if (_element_type != T) signal_lisp_error(new PrintNotReadable(make_value(this))); } if (print_readably || thread->symbol_value(S_print_array) != NIL) { String * s = new String("#0A"); if (aref(0) == make_value(this) && thread->symbol_value(S_print_circle) != NIL) { StringOutputStream * stream = new StringOutputStream(S_character); thread->execute(the_symbol(S_output_object)->function(), aref(0), make_value(stream)); s->append(stream->get_string()); } else s->append(::write_to_string(aref(0))); return s; } else return unreadable_string(); }
Value Vector_UB32::nreverse() { INDEX len = length(); if (len > 0) { INDEX i = 0; INDEX j = len - 1; if (_data) { while (i < j) { unsigned int temp = _data[i]; _data[i] = _data[j]; _data[j] = temp; ++i; --j; } } else { // displaced while (i < j) { Value temp = aref(i);; aset(i, aref(j)); aset(j, temp); ++i; --j; } } } return make_value(this); }
static obj_t random_subtree(obj_t tree, unsigned levels) { while(tree != objNULL && levels > 0) { tree = aref(tree, rnd() % width); --levels; } return tree; }
///---------------------------------------------------------------------------- void coroutine_stackful_actor::run(yield_t yld) { yld_ = &yld; try { stat_ = on; actor<stackful> aref(*this); f_(aref); stop(exit_normal, "exit normal"); } catch (boost::coroutines::detail::forced_unwind const&) { stop(exit_except, "exit normal"); throw; } catch (std::exception& ex) { stop(exit_except, ex.what()); } catch (...) { stop(exit_except, "unexpected exception"); } }
void irq7_handler(interrupt_error_code n __attribute__((unused))) { eoi(IRQ_MASTER); irq_handler current_irq_handler; aref(irq_handler_table,7,current_irq_handler); (*current_irq_handler)(); }
// // Return object identifier of attribute. // pwr_sAttrRef wb_attribute::aref() const { check(); pwr_sAttrRef ar; aref( &ar); return ar; }
void GDSin::Gds2Ted::convert(GDSin::GdsStructure* src, laydata::tdtcell* dst) { //@FIXME!!! ged rid of this silly loop! GDS database is layer oriented now! for(int2b laynum = 1 ; laynum < GDS_MAX_LAYER ; laynum++) { if (src->allLay(laynum)) {// layers GDSin::GdsData *wd = src->fDataAt(laynum); while( wd ) { word tdtlaynum; if (_theLayMap.getTdtLay(tdtlaynum, laynum, wd->singleType()) ) { // convert only if layer/data type pair is defined laydata::tdtlayer* dwl = static_cast<laydata::tdtlayer*>(dst->securelayer(tdtlaynum)); switch( wd->gdsDataType() ) { case gds_BOX: box (static_cast<GDSin::GdsBox*>(wd) , dwl, laynum); break; case gds_BOUNDARY: poly(static_cast<GDSin::GdsPolygon*>(wd) , dwl, laynum); break; case gds_PATH: wire(static_cast<GDSin::GDSpath*>(wd) , dwl, laynum); break; case gds_TEXT: text(static_cast<GDSin::GdsText*>(wd) , dwl); break; default: assert(false); /*Error - unexpected type*/ } } //else //{ // // The message below could be noughty - so put it in place ONLY if the data type // // is different from default // std::ostringstream ost; // ost << "Layer: " << laynum << "; data type: " << wd->singleType() << // "; found in GDS database, but not in the conversion map."; // tell_log(console::MT_INFO,ost.str()); //} wd = wd->last(); } } } if (src->allLay(0)) {// references GDSin::GdsData *wd = src->fDataAt(0); while( wd ) { switch( wd->gdsDataType() ) { case gds_SREF: ref (static_cast<GDSin::GdsRef*>(wd) , dst); break; case gds_AREF: aref(static_cast<GDSin::GdsARef*>(wd) , dst); break; default: assert(false); /*Error - unexpected type*/ } wd = wd->last(); } } dst->resort(); }
/* Update tree to be identical tree but with nodes reallocated * with probability pupdate. This avoids writing to vector slots * if unecessary. */ static obj_t update_tree(mps_ap_t ap, obj_t oldtree, unsigned d) { obj_t tree; size_t i; if (oldtree == objNULL || d == 0) return oldtree; if (rnd_double() < pupdate) { tree = mkvector(ap, width); for (i = 0; i < width; ++i) { aset(tree, i, update_tree(ap, aref(oldtree, i), d - 1)); } } else { tree = oldtree; for (i = 0; i < width; ++i) { obj_t oldsubtree = aref(oldtree, i); obj_t subtree = update_tree(ap, oldsubtree, d - 1); if (subtree != oldsubtree) { aset(tree, i, subtree); } } } return tree; }
void GDSin::gds2ted::convert(GDSin::GDSstructure* src, laydata::tdtcell* dst) { GDSin::GDSdata *wd = src->Get_Fdata(); while( wd ){ switch( wd->GetGDSDatatype() ){ // case gds_BOX: box(static_cast<GDSin::GDSbox*>(wd), dst); break; case gds_BOX: case gds_BOUNDARY: polygon(static_cast<GDSin::GDSpolygon*>(wd), dst); break; case gds_PATH: path(static_cast<GDSin::GDSpath*>(wd), dst); break; case gds_SREF: ref(static_cast<GDSin::GDSref*>(wd), dst); break; case gds_AREF: aref(static_cast<GDSin::GDSaref*>(wd), dst); break; case gds_TEXT: text(static_cast<GDSin::GDStext*>(wd), dst); break; default: {/*Error - unexpected type*/} } wd = wd->GetLast(); } dst->resort(); // dst->secure_layprop(); }
Value Vector_UB32::subseq(INDEX start, INDEX end) const { assert(end >= start); const INDEX len = end - start; SimpleArray_UB32_1 * result = new_simple_array_ub32_1(len); INDEX i = start, j = 0; if (_data) { unsigned int * data = result->data(); while (i < end) data[j++] = _data[i++]; } else { // displaced while (i < end) result->aset(j++, aref(i++)); } return make_value(result); }