bool install_(const std::string& key, const T& value) { std::string fpath; if(!create_full_path(key, fpath)) { return false; } bool f = false; utils::strings ss = split_text(fpath, "/"); std::string p; for(uint32_t i = 0; i < ss.size(); ++i) { p += '/'; p += ss[i]; unit_t u; u.value = value; u.set_id(serial_id_); std::pair<unit_map_it, bool> ret = unit_map_.insert(unit_pair(p, u)); if(ret.second) { ++serial_id_; auto prev = utils::get_file_path(p); if(p != prev) { unit_map_it it = unit_map_.find(prev); if(it != unit_map_.end()) { unit_t& t = it->second; t.install_child(utils::get_file_name(p)); } } f = true; } else { f = false; } } return f; }
size_t text_surface::height() const { if (h_ == -1) { if(chunks_.empty()) chunks_ = split_text(str_); measure(); } return h_; }
size_t text_surface::width() const { if (w_ == -1) { if(chunks_.empty()) chunks_ = split_text(str_); measure(); } return w_; }
bool CSSInlineLayoutAlignLine::node(CSSInlineGeneratedBox *cur) { cur->x += offset_x; cur->y = baseline_y - cur->ascent; if (cur->layout_node && (cur->layout_node->is_replaced() || cur->layout_node->get_element_node()->is_inline_block_level())) { cur->layout_node->set_root_block_position(cur->x, cur->y); } if (word_count != 0) { CSSBoxNode *node = cur->box_node; CSSBoxText *text = dynamic_cast<CSSBoxText*>(node); if (text) { for (size_t j = cur->text_start; j < cur->text_end; j++) { if (text->processed_text[j] == ' ') { prev_space = true; } else { if (prev_space && !start_of_line) { split_text(cur, j, graphics, resources); cur = cur->next_sibling; CSSActualValue v1 = extra_total * word_index / word_count; CSSActualValue v2 = extra_total * (word_index + 1) / word_count; CSSActualValue word_offset_x = v2-v1; word_index++; cur->x += word_offset_x; if (cur->parent) expand_box(cur->parent, word_offset_x); offset_x += word_offset_x; prev_space = false; start_of_line = false; break; } else { prev_space = false; start_of_line = false; } } } } } return true; }
void set_char_type(const char *type, char *ch) { assert(ch != 0); int st = lookup_spacing_type(type); int ft = lookup_font_type(type); if (st < 0 && ft < 0) { error("bad character type `%1'", type); a_delete ch; return; } box *b = split_text(ch); b->handle_char_type(st, ft); delete b; }
int send_as_sms(struct sms_msg *sms_messg, struct modem *mdm) { static char buf[MAX_SMS_LENGTH]; unsigned int buf_len; unsigned char len_array_1[256], len_array_2[256], *len_array; unsigned int nr_chunks_1, nr_chunks_2, nr_chunks; unsigned int use_nice; str text; char *p, *q; int ret_code; int i; text.s = sms_messg->text.s; text.len = sms_messg->text.len; nr_chunks_1 = split_text( &text, len_array_1, 0); nr_chunks_2 = split_text( &text, len_array_2, 1); if (nr_chunks_1==nr_chunks_2) { len_array = len_array_2; nr_chunks = nr_chunks_2; use_nice = 1; } else { len_array = len_array_1; nr_chunks = nr_chunks_1; use_nice = 0; } sms_messg->ref = 1; for(i=0,p=text.s ; i<nr_chunks&&i<max_sms_parts ; p+=len_array[i++]) { if (use_nice) { q = buf; if (nr_chunks>1 && i) { append_str(q,SMS_EDGE_PART,SMS_EDGE_PART_LEN); *(q-2)=nr_chunks+'0'; *(q-4)=i+1+'0'; } append_str(q,p,len_array[i]); if (nr_chunks>1 && !i) { append_str(q,SMS_EDGE_PART,SMS_EDGE_PART_LEN); *(q-2)=nr_chunks+'0'; *(q-4)=i+1+'0'; } buf_len = q-buf; } else { q = buf; append_str(q,p,len_array[i]); buf_len = len_array[i]; } if (i+1==max_sms_parts && i+1<nr_chunks) { /* simply override the end of the last allowed part */ buf_len += SMS_TRUNCATED_LEN+SMS_FOOTER_LEN; if (buf_len>MAX_SMS_LENGTH) buf_len = MAX_SMS_LENGTH; q = buf + (buf_len-SMS_TRUNCATED_LEN-SMS_FOOTER_LEN); append_str(q,SMS_TRUNCATED,SMS_TRUNCATED_LEN); append_str(q,SMS_FOOTER,SMS_FOOTER_LEN); p += buf_len-SMS_TRUNCATED_LEN-SMS_FOOTER_LEN-SMS_EDGE_PART_LEN; send_error(sms_messg, ERR_TRUNCATE_TEXT, ERR_TRUNCATE_TEXT_LEN, p, text.len-(p-text.s)-SMS_FOOTER_LEN); } LM_DBG("---%d--<%d><%d>--\n|%.*s|\n", i, len_array[i], buf_len, (int)buf_len, buf); sms_messg->text.s = buf; sms_messg->text.len = buf_len; if ( (ret_code=putsms(sms_messg,mdm))<0) goto error; if (sms_report_type!=NO_REPORT) add_sms_into_report_queue(ret_code,sms_messg, p-use_nice*(nr_chunks>1)*SMS_EDGE_PART_LEN,len_array[i]); } sms_messg->ref--; /* put back the pointer to the beginning of the message*/ sms_messg->text.s = text.s; sms_messg->text.len = text.len; /* remove the sms if nobody points to it */ if (!sms_messg->ref){ shm_free(sms_messg); } return 1; error: if (ret_code==-1) /* bad number */ send_error(sms_messg, sms_messg->to.s, sms_messg->to.len, ERR_NUMBER_TEXT, ERR_NUMBER_TEXT_LEN); else if (ret_code==-2) /* bad modem */ send_error(sms_messg, ERR_MODEM_TEXT, ERR_MODEM_TEXT_LEN, text.s+SMS_HDR_BF_ADDR_LEN+sms_messg->from.len+SMS_HDR_AF_ADDR_LEN, text.len-SMS_FOOTER_LEN-SMS_HDR_BF_ADDR_LEN-sms_messg->from.len- SMS_HDR_AF_ADDR_LEN ); if (!(--(sms_messg->ref))) shm_free(sms_messg); return -1; }
void scrawl_text(std::string txt, int alignment, VSFrameRef *frame, const VSAPI *vsapi) { const VSFormat *frame_format = vsapi->getFrameFormat(frame); int width = vsapi->getFrameWidth(frame, 0); int height = vsapi->getFrameHeight(frame, 0); const int margin_h = 16; const int margin_v = 16; sanitise_text(txt); stringlist lines = split_text(txt, width - margin_h*2, height - margin_v*2); int start_x = 0; int start_y = 0; switch (alignment) { case 7: case 8: case 9: start_y = margin_v; break; case 4: case 5: case 6: start_y = (height - static_cast<int>(lines.size())*character_height) / 2; break; case 1: case 2: case 3: start_y = height - static_cast<int>(lines.size())*character_height - margin_v; break; } for (const auto &iter : lines) { switch (alignment) { case 1: case 4: case 7: start_x = margin_h; break; case 2: case 5: case 8: start_x = (width - static_cast<int>(iter.size())*character_width) / 2; break; case 3: case 6: case 9: start_x = width - static_cast<int>(iter.size())*character_width - margin_h; break; } for (size_t i = 0; i < iter.size(); i++) { int dest_x = start_x + static_cast<int>(i)*character_width; int dest_y = start_y; if (frame_format->colorFamily == cmRGB) { for (int plane = 0; plane < frame_format->numPlanes; plane++) { uint8_t *image = vsapi->getWritePtr(frame, plane); int stride = vsapi->getStride(frame, plane); if (frame_format->sampleType == stInteger) { scrawl_character_int(iter[i], image, stride, dest_x, dest_y, frame_format->bitsPerSample); } else { scrawl_character_float(iter[i], image, stride, dest_x, dest_y); } } } else { for (int plane = 0; plane < frame_format->numPlanes; plane++) { uint8_t *image = vsapi->getWritePtr(frame, plane); int stride = vsapi->getStride(frame, plane); if (plane == 0) { if (frame_format->sampleType == stInteger) { scrawl_character_int(iter[i], image, stride, dest_x, dest_y, frame_format->bitsPerSample); } else { scrawl_character_float(iter[i], image, stride, dest_x, dest_y); } } else { int sub_w = character_width >> frame_format->subSamplingW; int sub_h = character_height >> frame_format->subSamplingH; int sub_dest_x = dest_x >> frame_format->subSamplingW; int sub_dest_y = dest_y >> frame_format->subSamplingH; int y; if (frame_format->bitsPerSample == 8) { for (y = 0; y < sub_h; y++) { memset(image + (y+sub_dest_y)*stride + sub_dest_x, 128, sub_w); } } else if (frame_format->bitsPerSample <= 16) { for (y = 0; y < sub_h; y++) { vs_memset16(reinterpret_cast<uint16_t *>(image) + (y+sub_dest_y)*stride/2 + sub_dest_x, 128 << (frame_format->bitsPerSample - 8), sub_w); } } else { for (y = 0; y < sub_h; y++) { vs_memset_float(reinterpret_cast<float *>(image) + (y+sub_dest_y)*stride/4 + sub_dest_x, 0.0f, sub_w); } } } // if plane } // for plane in planes } // if colorFamily } // for i in line start_y += character_height; } // for iter in lines }
void BinAsm::save(const std::string& filename) { uint32_t allocsize=0x10000; uint32_t filesize=0; int error_count=0; uint16_t* buff = new uint16_t[allocsize]; unsigned int lc = 0; uint16_t opcode = 0; std::vector<std::string> lines=split_text(_src); std::vector<std::string>::iterator lit = lines.begin(); for (;lit!=lines.end();lit++) { lc++; std::string err = std::string(); std::vector<std::string> w=split_line(*lit); if (!w.size()) continue; opcode = 0; if (filesize > allocsize - lit->size() - 3) { std::cerr << "fatal error: assembling file is too big"; std::cerr << "cannot be used on dcpu-16" << std::endl; break; } if (w[0].size() && (w[0][w[0].size()-1] == ':' || w[0][0] == ':')) { continue; } if ((opcode = get_op(w[0]))) { if (w.size() != 3) { err = "instruction " + w[0]; err += " need 2 arguments"; } else { uint16_t a_word=0, b_word=0; opcode |= ((get_b(w[1],b_word,err) & 0x1F) << 5); if (err.size()) { print_error(lc,false,err); error_count++; } opcode |= (get_a(w[2],a_word,err) << 10); buff[filesize]=opcode; filesize++; if (a_word) { buff[filesize]=a_word; filesize++; } if (b_word) { buff[filesize]=b_word; filesize++; } } } else if ((opcode=get_sop(w[0],err)) && !err.size()) { if (w.size() != 2) { err = "special instruction " + w[0]; err += " need 1 argument"; } else { uint16_t a_word=0; opcode = ((opcode & 0x1F) << 5); opcode |= (get_a(w[1],a_word,err) << 10); buff[filesize]=opcode; filesize++; if (a_word) { buff[filesize]=a_word; filesize++; } } } else { if (w[0]=="dat"||w[0]==".dat"||w[0]=="DAT"||w[0]==".DAT") err=""; filesize += get_data(*lit, &(buff[filesize]),err); } if (err.size()) { print_error(lc,false,err); error_count++; } } if (error_count) { std::cerr << "assembling terminated with " << error_count; std::cerr << " error(s)" << std::endl; } else { FILE* f = fopen(filename.c_str(), "wb"); if (!f) std::cerr << "error: cannot open output file " << filename << std::endl; fswitchendian(buff, filesize); fwrite(buff,2,filesize,f); fclose(f); std::cout << "assembling " << filename; std::cout << " terminated final size " << filesize*2; std::cout << " bytes" << std::endl; } delete buff; }
bool BinAsm::finds_labels() { unsigned int lc = 0; unsigned int errc = 0; unsigned int offset = 0; uint16_t opd = 0; std::string err = ""; std::vector<std::string> lines=split_text(_src); std::vector<std::string>::iterator lit = lines.begin(); for (;lit!=lines.end();lit++) { lc++; std::vector<std::string> w=split_line(*lit); if (!w.size()) continue; if (get_op(w[0])) { offset++; if (w.size() < 3) continue; opd=0; get_b(w[1],opd,err); if (opd) offset++; opd=0; get_a(w[2],opd,err); if (opd) offset++; } else if (get_sop(w[0],err) && !err.size()) { offset++; if (w.size() < 2) continue; opd=0; get_a(w[1],opd,err); if (opd) offset++; } else { std::vector<std::string>::iterator wit = w.begin(); Label l; l.line = lc; l.offset = offset; l.name = std::string(); for (;wit!=w.end();wit++) { if (wit->size() < 2) continue; if ((*wit)[wit->size()-1] == ':') { l.name = wit->substr(0,wit->size()-1); break; } else if ((*wit)[0] == ':') { l.name = wit->substr(1,wit->size()); break; } } if (_labels.find(l.name)!=_labels.end()) { err="label " + l.name + " redefined"; print_error(lc, false,err); errc++; } else if (l.name.size()) { _labels[l.name]=l; } } uint16_t* data = new uint16_t[lit->size()]; offset += get_data(*lit, data,err); delete data; } return !errc; }