bool node::operator<(const node& n) const { if(type() != n.type()) { return type_ < n.type(); } switch(type()) { case NODE_TYPE_NULL: return true; case NODE_TYPE_BOOL: return b_ < n.b_; case NODE_TYPE_INTEGER: return i_ < n.i_; case NODE_TYPE_FLOAT: return f_ < n.f_; case NODE_TYPE_STRING: return s_ < n.s_; case NODE_TYPE_MAP: return m_.size() < n.m_.size(); case NODE_TYPE_LIST: for(unsigned i = 0; i != l_.size() && i != n.l_.size(); ++i) { if(l_[i] < n.l_[i]) { return true; } else if(l_[i] > n.l_[i]) { return false; } } return l_.size() < n.l_.size(); case NODE_TYPE_FUNCTION: default: break; } ASSERT_LOG(false, "operator< unknown type: " << type_as_string()); return false; }
qt_tm_widget_rep::~qt_tm_widget_rep () { if (DEBUG_QT_WIDGETS) debug_widgets << "qt_tm_widget_rep::~qt_tm_widget_rep of widget " << type_as_string() << LF; // clear any residual waiting menu installation waiting_widgets = remove(waiting_widgets, this); }
bool node::has_key(const node& v) const { if(type() == NODE_TYPE_LIST) { return static_cast<size_t>(v.as_int()) < l_.size() ? true : false; } else if(type() == NODE_TYPE_MAP) { return m_.find(v) != m_.end() ? true : false; } else { ASSERT_LOG(false, "Tried to index a node that isn't a list or map: " << type_as_string()); } return false; }
std::vector<std::string> node::as_list_strings() const { std::vector<std::string> res; ASSERT_LOG(type() == NODE_TYPE_LIST, "as_list_strings() type conversion error from " << type_as_string() << " to list"); res.reserve(l_.size()); for(auto& n : l_) { ASSERT_LOG(n.is_string(), "type conversion error from " << type_as_string() << " to string"); res.emplace_back(n.as_string()); } return res; }
struct RecordInfo* createRecordInfo(const tree type_decl, const tree record_type) { struct RecordInfo* ri = (struct RecordInfo*) xcalloc(1, sizeof(struct RecordInfo)); ri->name = xstrdup(type_as_string(record_type, 0)); ri->fileName = xstrdup(DECL_SOURCE_FILE(type_decl)); ri->line = DECL_SOURCE_LINE(type_decl); ri->size = TREE_INT_CST_LOW(TYPE_SIZE(record_type)); ri->align = TYPE_ALIGN(record_type); ri->isInstance = CLASSTYPE_TEMPLATE_INSTANTIATION(record_type); ri->firstField = SIZE_MAX; ri->estMinSize = SIZE_MAX; size_t fieldCapacity = 4; ri->fields = (struct FieldInfo**)xmalloc(fieldCapacity * sizeof(struct FieldInfo*)); // Fields/variables/constants/functions are chained via TYPE_FIELDS of record for (tree field = TYPE_FIELDS(record_type); field; field = TREE_CHAIN(field)) { // We're intersted in fields only if (TREE_CODE(field) != FIELD_DECL) continue; struct FieldInfo* fi = createFieldInfo(field); ri->fieldCount++; // Allocate more storage for fields if needed if (ri->fieldCount > fieldCapacity) { fieldCapacity *= 2; ri->fields = (struct FieldInfo**)xrealloc(ri->fields, fieldCapacity * sizeof(struct FieldInfo*)); } ri->fields[ri->fieldCount - 1] = fi; // Mark record as containing bit-fields if (fi->isBitField) ri->hasBitFields = true; // Field is base/vptr if (fi->isSpecial) { // If we encounter special field somewhere after regular fields // it means class has virtual base. if (ri->firstField != SIZE_MAX) ri->hasVirtualBase = true; } else if (ri->firstField == SIZE_MAX) ri->firstField = ri->fieldCount - 1; } return ri; }
const node& node::operator[](const node& v) const { if(type() == NODE_TYPE_LIST) { return l_[size_t(v.as_int())]; } else if(type() == NODE_TYPE_MAP) { auto it = m_.find(v); ASSERT_LOG(it != m_.end(), "Couldn't find key in map"); return it->second; } else { ASSERT_LOG(false, "Tried to index a node that isn't a list or map: " << type_as_string()); } }
float node::as_float() const { switch(type()) { case NODE_TYPE_INTEGER: return float(i_); case NODE_TYPE_FLOAT: return f_; case NODE_TYPE_BOOL: return b_ ? 1.0f : 0.0f; default: break; } ASSERT_LOG(false, "as_float() type conversion error from " << type_as_string() << " to float"); return 0; }
int64_t node::as_int() const { switch(type()) { case NODE_TYPE_INTEGER: return i_; case NODE_TYPE_FLOAT: return static_cast<int64_t>(f_); case NODE_TYPE_BOOL: return b_ ? 1 : 0; default: break; } ASSERT_LOG(false, "as_int() type conversion error from " << type_as_string() << " to int"); return 0; }
void qt_tm_embedded_widget_rep::send (slot s, blackbox val) { switch (s) { case SLOT_INVALIDATE: case SLOT_INVALIDATE_ALL: case SLOT_EXTENTS: case SLOT_SCROLL_POSITION: case SLOT_ZOOM_FACTOR: case SLOT_MOUSE_GRAB: main_widget->send(s, val); return; /// FIXME: decide what to do with these for embedded widgets case SLOT_HEADER_VISIBILITY: case SLOT_MAIN_ICONS_VISIBILITY: case SLOT_MODE_ICONS_VISIBILITY: case SLOT_FOCUS_ICONS_VISIBILITY: case SLOT_USER_ICONS_VISIBILITY: case SLOT_FOOTER_VISIBILITY: case SLOT_SIDE_TOOLS_VISIBILITY: case SLOT_BOTTOM_TOOLS_VISIBILITY: case SLOT_LEFT_FOOTER: case SLOT_RIGHT_FOOTER: case SLOT_SCROLLBARS_VISIBILITY: case SLOT_INTERACTIVE_MODE: case SLOT_FILE: break; case SLOT_DESTROY: { ASSERT (is_nil (val), "type mismatch"); if (!is_nil (quit)) quit (); the_gui->need_update (); } break; default: qt_widget_rep::send (s, val); return; } if (DEBUG_QT_WIDGETS) debug_widgets << "qt_tm_embedded_widget_rep: sent " << slot_name (s) << "\t\tto widget\t" << type_as_string() << LF; }
void qt_popup_widget_rep::send (slot s, blackbox val) { switch (s) { case SLOT_SIZE: { check_type<coord2>(val, s); qwid->resize (to_qsize (open_box<coord2> (val))); } break; case SLOT_POSITION: { check_type<coord2>(val, s); qwid->move (to_qpoint (open_box<coord2> (val))); } break; case SLOT_VISIBILITY: { check_type<bool> (val, s); qwid->setVisible(open_box<bool> (val)); } break; //FIXME: what's this? case SLOT_MOUSE_GRAB: { check_type<bool> (val, s); bool flag = open_box<bool> (val); // true= get grab, false= release grab qwid->hide(); if (flag) qwid->setWindowModality(Qt::WindowModal); //ok? else qwid->setWindowModality(Qt::NonModal); //ok? qwid->show(); } break; default: qt_widget_rep::send(s, val); } if (DEBUG_QT_WIDGETS) debug_widgets << "qt_popup_widget_rep: sent " << slot_name (s) << "\t\tto widget\t" << type_as_string() << LF; }
widget qt_tm_embedded_widget_rep::read (slot s, blackbox index) { widget ret; switch (s) { case SLOT_CANVAS: check_type_void (index, s); ret = main_widget; break; default: return qt_widget_rep::read(s, index); } if (DEBUG_QT_WIDGETS) debug_widgets << "qt_tm_widget_rep::read " << slot_name (s) << "\t\tfor widget\t" << type_as_string() << LF; return ret; }
std::string node::as_string() const { switch(type()) { case NODE_TYPE_STRING: return s_; case NODE_TYPE_INTEGER: { std::stringstream s; s << i_; return s.str(); } case NODE_TYPE_FLOAT: { std::stringstream s; s << f_; return s.str(); } default: break; } ASSERT_LOG(false, "as_string() type conversion error from " << type_as_string() << " to string"); return ""; }
bool node::as_bool() const { switch(type()) { case NODE_TYPE_INTEGER: return i_ ? true : false; case NODE_TYPE_FLOAT: return f_ == 0.0f ? false : true; case NODE_TYPE_BOOL: return b_; case NODE_TYPE_STRING: return s_.empty() ? false : true; case NODE_TYPE_LIST: return l_.empty() ? false : true; case NODE_TYPE_MAP: return m_.empty() ? false : true; default: break; } ASSERT_LOG(false, "as_bool() type conversion error from " << type_as_string() << " to boolean"); return 0; }
node_map& node::as_mutable_map() { ASSERT_LOG(type() == NODE_TYPE_MAP, "as_mutable_map() type conversion error from " << type_as_string() << " to map"); return m_; }
bool node::has_key(const std::string& key) const { ASSERT_LOG(type() == NODE_TYPE_MAP, "Tried to index node that isn't a map, was: " << type_as_string()); return m_.find(node(key)) != m_.end() ? true : false; }
node node::operator()(node args) { ASSERT_LOG(type() == NODE_TYPE_FUNCTION, "Tried to execute node that wasn't a function, was: " << type_as_string()); return fn_(args); }
const node& node::operator[](const std::string& key) const { ASSERT_LOG(type() == NODE_TYPE_MAP, "Tried to index node that isn't a map, was: " << type_as_string()); auto it = m_.find(node(key)); ASSERT_LOG(it != m_.end(), "Couldn't find key(" << key << ") in map"); return it->second; }
const node& node::operator[](size_t n) const { ASSERT_LOG(type() == NODE_TYPE_LIST, "Tried to index node that isn't a list, was: " << type_as_string()); ASSERT_LOG(n < l_.size(), "Tried to index a list outside of list bounds: " << n << " >= " << l_.size()); return l_[n]; }
node_list& node::as_mutable_list() { ASSERT_LOG(type() == NODE_TYPE_LIST, "as_mutable_list() type conversion error from " << type_as_string() << " to list"); return l_; }
void cxx_print_type (FILE *file, tree node, int indent) { switch (TREE_CODE (node)) { case TEMPLATE_TYPE_PARM: case TEMPLATE_TEMPLATE_PARM: case BOUND_TEMPLATE_TEMPLATE_PARM: indent_to (file, indent + 3); fprintf (file, "index %d level %d orig_level %d", TEMPLATE_TYPE_IDX (node), TEMPLATE_TYPE_LEVEL (node), TEMPLATE_TYPE_ORIG_LEVEL (node)); return; case FUNCTION_TYPE: case METHOD_TYPE: if (TYPE_RAISES_EXCEPTIONS (node)) print_node (file, "throws", TYPE_RAISES_EXCEPTIONS (node), indent + 4); return; case RECORD_TYPE: case UNION_TYPE: break; case DECLTYPE_TYPE: print_node (file, "expr", DECLTYPE_TYPE_EXPR (node), indent + 4); return; case TYPENAME_TYPE: print_node (file, "fullname", TYPENAME_TYPE_FULLNAME (node), indent + 4); return; case TYPE_PACK_EXPANSION: print_node (file, "args", PACK_EXPANSION_EXTRA_ARGS (node), indent + 4); return; default: return; } if (TYPE_PTRMEMFUNC_P (node)) print_node (file, "ptrmemfunc fn type", TYPE_PTRMEMFUNC_FN_TYPE (node), indent + 4); if (! CLASS_TYPE_P (node)) return; indent_to (file, indent + 4); fprintf (file, "full-name \"%s\"", type_as_string (node, TFF_CLASS_KEY_OR_ENUM)); indent_to (file, indent + 3); if (TYPE_NEEDS_CONSTRUCTING (node)) fputs ( " needs-constructor", file); if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (node)) fputs (" needs-destructor", file); if (TYPE_HAS_DEFAULT_CONSTRUCTOR (node)) fputs (" X()", file); if (TYPE_HAS_CONVERSION (node)) fputs (" has-type-conversion", file); if (TYPE_HAS_COPY_CTOR (node)) { if (TYPE_HAS_CONST_COPY_CTOR (node)) fputs (" X(constX&)", file); else fputs (" X(X&)", file); } if (TYPE_HAS_NEW_OPERATOR (node)) fputs (" new", file); if (TYPE_HAS_ARRAY_NEW_OPERATOR (node)) fputs (" new[]", file); if (TYPE_GETS_DELETE (node) & 1) fputs (" delete", file); if (TYPE_GETS_DELETE (node) & 2) fputs (" delete[]", file); if (TYPE_HAS_COPY_ASSIGN (node)) fputs (" this=(X&)", file); if (CLASSTYPE_SORTED_FIELDS (node)) fprintf (file, " sorted-fields %p", (void *) CLASSTYPE_SORTED_FIELDS (node)); if (TREE_CODE (node) == RECORD_TYPE) { if (TYPE_BINFO (node)) fprintf (file, " n_parents=%d", BINFO_N_BASE_BINFOS (TYPE_BINFO (node))); else fprintf (file, " no-binfo"); fprintf (file, " use_template=%d", CLASSTYPE_USE_TEMPLATE (node)); if (CLASSTYPE_INTERFACE_ONLY (node)) fprintf (file, " interface-only"); if (CLASSTYPE_INTERFACE_UNKNOWN (node)) fprintf (file, " interface-unknown"); } }
void qt_tm_widget_rep::send (slot s, blackbox val) { switch (s) { case SLOT_INVALIDATE: case SLOT_INVALIDATE_ALL: case SLOT_EXTENTS: case SLOT_SCROLL_POSITION: case SLOT_ZOOM_FACTOR: case SLOT_MOUSE_GRAB: main_widget->send(s, val); return; case SLOT_KEYBOARD_FOCUS: { check_type<bool> (val, s); bool focus = open_box<bool> (val); if (focus && canvas() && !canvas()->hasFocus()) canvas()->setFocus (Qt::OtherFocusReason); } break; case SLOT_HEADER_VISIBILITY: { check_type<bool>(val, s); visibility[0] = open_box<bool> (val); update_visibility(); } break; case SLOT_MAIN_ICONS_VISIBILITY: { check_type<bool>(val, s); visibility[1] = open_box<bool> (val); update_visibility(); } break; case SLOT_MODE_ICONS_VISIBILITY: { check_type<bool>(val, s); visibility[2] = open_box<bool> (val); update_visibility(); } break; case SLOT_FOCUS_ICONS_VISIBILITY: { check_type<bool>(val, s); visibility[3] = open_box<bool> (val); update_visibility(); } break; case SLOT_USER_ICONS_VISIBILITY: { check_type<bool>(val, s); visibility[4] = open_box<bool> (val); update_visibility(); } break; case SLOT_FOOTER_VISIBILITY: { check_type<bool>(val, s); visibility[5] = open_box<bool> (val); update_visibility(); } break; case SLOT_SIDE_TOOLS_VISIBILITY: { check_type<bool>(val, s); visibility[6] = open_box<bool> (val); update_visibility(); } break; case SLOT_BOTTOM_TOOLS_VISIBILITY: { check_type<bool>(val, s); visibility[7] = open_box<bool> (val); update_visibility(); } break; case SLOT_LEFT_FOOTER: { check_type<string>(val, s); string msg = open_box<string> (val); leftLabel->setText (to_qstring (msg)); leftLabel->update (); } break; case SLOT_RIGHT_FOOTER: { check_type<string>(val, s); string msg= open_box<string> (val); rightLabel->setText (to_qstring (msg)); rightLabel->update (); } break; case SLOT_SCROLLBARS_VISIBILITY: // ignore this: qt handles scrollbars independently // send_int (THIS, "scrollbars", val); break; case SLOT_INTERACTIVE_MODE: { check_type<bool>(val, s); if (open_box<bool> (val) == true) { prompt = new QTMInteractivePrompt (int_prompt, int_input); mainwindow()->statusBar()->removeWidget (leftLabel); mainwindow()->statusBar()->removeWidget (rightLabel); mainwindow()->statusBar()->addWidget (prompt, 1); prompt->start(); } else { if (prompt) prompt->end(); mainwindow()->statusBar()->removeWidget (prompt); mainwindow()->statusBar()->addWidget (leftLabel); mainwindow()->statusBar()->addPermanentWidget (rightLabel); leftLabel->show(); rightLabel->show(); prompt->deleteLater(); prompt = NULL; } } break; case SLOT_FILE: { check_type<string>(val, s); string file = open_box<string> (val); if (DEBUG_QT_WIDGETS) debug_widgets << "\tFile: " << file << LF; #if (QT_VERSION >= 0x040400) mainwindow()->setWindowFilePath (utf8_to_qstring (file)); #endif } break; case SLOT_POSITION: { check_type<coord2>(val, s); coord2 p= open_box<coord2> (val); mainwindow()->move (to_qpoint (p)); } break; case SLOT_SIZE: { check_type<coord2>(val, s); coord2 p= open_box<coord2> (val); mainwindow()->resize (to_qsize (p)); } break; case SLOT_DESTROY: { ASSERT (is_nil (val), "type mismatch"); if (!is_nil (quit)) quit (); the_gui->need_update (); } break; case SLOT_FULL_SCREEN: { check_type<bool> (val, s); set_full_screen(open_box<bool> (val)); } break; default: qt_window_widget_rep::send (s, val); return; } if (DEBUG_QT_WIDGETS) debug_widgets << "qt_tm_widget_rep: sent " << slot_name (s) << "\t\tto widget\t" << type_as_string() << LF; }
blackbox qt_tm_widget_rep::query (slot s, int type_id) { if (DEBUG_QT_WIDGETS) debug_widgets << "qt_tm_widget_rep: queried " << slot_name(s) << "\t\tto widget\t" << type_as_string() << LF; switch (s) { case SLOT_SCROLL_POSITION: case SLOT_EXTENTS: case SLOT_VISIBLE_PART: case SLOT_ZOOM_FACTOR: return main_widget->query(s, type_id); case SLOT_HEADER_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[0]); case SLOT_MAIN_ICONS_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[1]); case SLOT_MODE_ICONS_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[2]); case SLOT_FOCUS_ICONS_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[3]); case SLOT_USER_ICONS_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[4]); case SLOT_FOOTER_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[5]); case SLOT_SIDE_TOOLS_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[6]); case SLOT_BOTTOM_TOOLS_VISIBILITY: check_type_id<bool> (type_id, s); return close_box<bool> (visibility[7]); case SLOT_INTERACTIVE_INPUT: { check_type_id<string> (type_id, s); qt_input_text_widget_rep* w = static_cast<qt_input_text_widget_rep*> (int_input.rep); if (w->ok) return close_box<string> (scm_quote (w->input)); else return close_box<string> ("#f"); } case SLOT_POSITION: { check_type_id<coord2> (type_id, s); return close_box<coord2> (from_qpoint (mainwindow()->pos())); } case SLOT_SIZE: { check_type_id<coord2> (type_id, s); return close_box<coord2> (from_qsize (mainwindow()->size())); } case SLOT_INTERACTIVE_MODE: check_type_id<bool> (type_id, s); return close_box<bool> (prompt && prompt->isActive()); default: return qt_window_widget_rep::query (s, type_id); } }
const node_fn node::as_function() const { ASSERT_LOG(type() == NODE_TYPE_FUNCTION, "as_function() type conversion error from " << type_as_string() << " to function"); return fn_; }
void serialize(Ar& ar) { std::string t = type_as_string(); ar & JUBA_NAMED_MEMBER("type", t) & JUBA_NAMED_MEMBER("bit_vector_length", bit_vector_length_); }
void attribute::set( const std::string& value ) { VmbErrorType status = VmbErrorSuccess; if( comma::verbose ) { std::cerr << "Setting \"" << name_ << "\" feature"; if( !value.empty() ) { std::cerr << " to " << type_as_string() << " value \"" << value << "\""; } std::cerr << std::endl; } switch( type_ ) { case VmbFeatureDataUnknown: // Unknown feature type COMMA_THROW( comma::exception, "unknown feature \"" << name_ << "\"" ); break; case VmbFeatureDataInt: // 64 bit integer feature status = feature_->SetValue( boost::lexical_cast< VmbInt64_t >( value )); break; case VmbFeatureDataFloat: // 64 bit floating point feature status = feature_->SetValue( boost::lexical_cast< double >( value )); break; case VmbFeatureDataEnum: // Enumeration feature case VmbFeatureDataString: // String feature status = feature_->SetValue( value.c_str() ); break; case VmbFeatureDataBool: // Boolean feature status = feature_->SetValue( boost::lexical_cast< bool >( value )); break; case VmbFeatureDataCommand: // Command feature status = feature_->RunCommand(); if( status == VmbErrorSuccess ) { bool is_command_done = false; do { status = feature_->IsCommandDone( is_command_done ); if( status != VmbErrorSuccess ) break; } while( !is_command_done ); } break; case VmbFeatureDataRaw: // Raw (direct register access) feature COMMA_THROW( comma::exception, "feature \"" << name_ << "\" is a direct register - setting this type is unsupported" ); break; case VmbFeatureDataNone: // Feature with no data COMMA_THROW( comma::exception, "feature \"" << name_ << "\" has no data" ); break; } if( status != VmbErrorSuccess ) { std::string allowed_error_msg; if( !allowed_values_.empty() ) { allowed_error_msg = "; allowed values: "; allowed_error_msg += allowed_values_as_string(); } COMMA_THROW( comma::exception , "failed to set feature \"" << name_ << " to " << value << ", Error: " << status << ": " << error_code_to_string( status ) << allowed_error_msg ); } }