static unsigned char get_previous_byte (gf_font_t *font) { unsigned char b; move_relative (font, -1); b = get_byte (font); move_relative (font, -1); return b; }
static unsigned long get_previous_four (gf_font_t *font) { unsigned long b; move_relative (font, -4); b = get_four (font); move_relative (font, -4); return b; }
/* * Skip all specials, leaving the file pointer at the first non-special. * We do not save the specials, though. */ static void skip_specials (gf_font_t *font) { for (;;) { switch (get_byte (font)) { case XXX1: move_relative (font, get_byte (font)); continue; case XXX2: move_relative (font, get_two (font)); continue; case XXX3: move_relative (font, get_three (font)); continue; case YYY: (void) get_four (font); continue; default: move_relative (font, -1); return; } } }
// Moves the motor to an absolute step position. This function blocks. // If the motor was previously off, this function will turn it on. void Stepper::move_absolute(int step_number) { move_relative(step_number - _count); _count = step_number; }
void param_tree::generate_from_schema(schema::schema_node s, tree_t::node_descriptor node, param_accessor acc, schema::schema_provider_map_handle sch_mp) { /* if(acc.m_pt == this) { throw std::runtime_error{ "shouldn't happen!" }; } */ //acc.set_lock_on_failed_move(true); auto name = s["name"].as< std::string >(); /* if(acc && !acc.move_relative(name)) // todo: Maybe allow to push a non-valid state onto the location stack, // so we can put an accessor into invalid state and then revert later { // This node does not exist in the existing param tree, so for this subtree, use a null param_accessor // so that everything will be generated from defaults acc = param_accessor{}; } */ auto type = s["type"].as< ParamType >(); m_tree[node].type = type; m_tree[node].name = name; if(is_leaf_type(type)) { // For leaf types, if a node with matching name and type is found in the given accessor, just // copy across its value if(acc && acc.where().leaf().name() == name && acc.param_here().type == type) { m_tree[node].value = acc.value_here(); } else { // Not found, so use default value m_tree[node].value = generate_default_terminal(s); } } else switch(type) // Non-leaf types { case ParamType::List: { YAML::Node children = s["children"]; for(YAML::Node c : children) { auto child_acc = acc; // TODO: This test (and also the one below for repeats) is supposed to ensure that the // accessor is valid for the current location. It's not ideal, since nothing to stop // the same name occurring at multiple nodes in the tree. if(child_acc && child_acc.where().leaf().name() == name) { // Attempt to move the accessor to the newly created node. // Failure will lock the accessor ensuring that any copies of it in recursive calls // will not move it from its current position (which is the position furthest down the // existing param tree towards the current node which actually exists). child_acc.move_relative(c["name"].as< std::string >()); } auto c_node = m_tree.add_node(node).second; generate_from_schema(c, c_node, child_acc, sch_mp); } } break; case ParamType::Repeat: { auto contents_string = s["contents"].as< std::string >(); m_tree[node].extra = repeat_extra{ contents_string }; if(acc && acc.where().leaf().name() == name) { // Maintain any existing instances auto existing_instances = acc.children(); for(auto const& p : existing_instances) { add_repeat_instance(node, acc, sch_mp); } } // TODO: respect repeat min instance count } break; } }