void file_view(const datat &data) { std::ofstream out("file_view.html"); out << "<html>\n<head>\n"; out << "<title>" << html_escape(data.description) << "</title>\n"; out << "<style type=\"text/css\">\n"; out << "/* Source-code listing */\n"; out << "div.file { float: left; padding-right: 20px; }\n"; out << "div.listing { font-size: 3px; width: 150px; height: 400px; overflow-y: scroll; overflow-x: scroll; white-space: pre; }\n"; out << "div.filename { text-align: center; font-size: 14px; width: 150px; }\n"; out << "strong.alarm { font-style: normal; background-color: #ff6633; font-weight: normal; }\n"; out << "/* Description of sw under test */\n"; out << "div.description { float: center; font: 14px \"Trebuchet MS\", Verdana, Arial, Helvetica, sans-serif; width=100%; text-align: center; }\n"; out << "</style>\n"; out << "</head>\n"; out << "<body>\n"; out << "<center><img src=\"http://www.deltacheck.org/deltacheck_logo_small.png\"></center>\n"; out << "<div class=\"description\">\n"; out << html_escape(data.description) << "\n"; out << "</div>\n"; std::set<irep_idt> files; for(datat::propertiest::const_iterator e_it=data.properties.begin(); e_it!=data.properties.end(); e_it++) files.insert(e_it->file); for(std::set<irep_idt>::const_iterator f_it=files.begin(); f_it!=files.end(); f_it++) { if(has_prefix(id2string(*f_it), "/usr/include/")) continue; if(has_prefix(id2string(*f_it), "<builtin-library>")) continue; print_file(data, *f_it, out); } out << "</body>\n</html>\n"; }
void print_file(const datat &data, irep_idt file, std::ostream &out) { out << "<div class=\"file\" onclick=\"location.href='" << html_escape(id2string(file)+".html") << "';\" style=\"cursor:pointer;\">\n"; out << "<div class=\"filename\">" << html_escape(file) << "</div>\n"; out << "<div class=\"listing\">\n"; std::ifstream in(file.c_str()); if(!in) { } else { // line to property number std::map<unsigned, std::vector<unsigned> > line_map; for(datat::propertiest::const_iterator e_it=data.properties.begin(); e_it!=data.properties.end(); e_it++) if(e_it->file==file) { line_map[e_it->line].push_back(e_it-data.properties.begin()); } syntax_highlightingt syntax_highlighting(out); unsigned line_no=1; std::string line; while(std::getline(in, line)) { syntax_highlighting.strong_class=""; syntax_highlighting.line_no=line_no; std::vector<unsigned> &properties=line_map[line_no]; if(!properties.empty()) { syntax_highlighting.strong_class="alarm"; } syntax_highlighting(line); line_no++; } } out << "</div></div>\n\n"; }
static void report_section(std::ostringstream & out, const std::string & name, M & module, bool html) { if (html) { out << "<h1 id=\"" << html_escape(name) << "\">" << html_escape(name) << "</h1>"; } else { out << "# " << name << "\n"; } module.report(out, html); if (!html) { out << "\n"; } }
void TemplateTagAttr::render(std::string &buffer, expr::Scope &scope)const { std::vector<ObjectPtr> values; for (auto &expr : dynamic_values) { auto val = expr->eval(scope); add_attr_value(values, val); } if (static_values.empty() && values.empty()) return; if (static_values.empty() && values.size() == 1) { if (values[0] == TRUE_VALUE) { buffer += ' ' + attr; return; } else if (values[0] == FALSE_VALUE || values[0] == NIL_VALUE) return; } std::vector<std::string> strings = static_values; for (auto &v : values) strings.push_back(html_escape(v)); buffer += attr_str(attr, strings); }
std::string operator()(const lambda& value) const { template_type interpreted{value([this](const mstch::node& n) { return visit(render_node(ctx), n); })}; auto rendered = render_context::push(ctx).render(interpreted); return (m_flag == flag::escape_html) ? html_escape(rendered) : rendered; }
void GDBOutputWidget::newStdoutLine(const QString& line, bool internal) { QString s = html_escape(line); if (s.startsWith("(gdb)")) { s = colorify(s, "blue"); } allCommands_.append(s); allCommandsRaw_.append(line); trimList(allCommands_, maxLines_); trimList(allCommandsRaw_, maxLines_); if (!internal) { userCommands_.append(s); userCommandsRaw_.append(line); trimList(userCommands_, maxLines_); trimList(userCommandsRaw_, maxLines_); } if (!internal || showInternalCommands_) showLine(s); }
static int html_link( struct Blob *ob, struct Blob *link, struct Blob *title, struct Blob *content, void *opaque ){ BLOB_APPEND_LITERAL(ob, "<a href=\""); html_escape(ob, blob_buffer(link), blob_size(link)); if( title && blob_size(title)>0 ){ BLOB_APPEND_LITERAL(ob, "\" title=\""); html_escape(ob, blob_buffer(title), blob_size(title)); } BLOB_APPEND_LITERAL(ob, "\">"); BLOB_APPEND_BLOB(ob, content); BLOB_APPEND_LITERAL(ob, "</a>"); return 1; }
static int html_image( struct Blob *ob, struct Blob *link, struct Blob *title, struct Blob *alt, void *opaque ){ BLOB_APPEND_LITERAL(ob, "<img src=\""); html_escape(ob, blob_buffer(link), blob_size(link)); BLOB_APPEND_LITERAL(ob, "\" alt=\""); html_escape(ob, blob_buffer(alt), blob_size(alt)); if( title && blob_size(title)>0 ){ BLOB_APPEND_LITERAL(ob, "\" title=\""); html_escape(ob, blob_buffer(title), blob_size(title)); } BLOB_APPEND_LITERAL(ob, "\" />"); return 1; }
bool UatDialog::trySetErrorHintFromField(const QModelIndex &index) { const QVariant &data = uat_model_->data(index, Qt::UserRole + 1); if (!data.isNull()) { // use HTML instead of PlainText because that handles wordwrap properly ui->hintLabel->setText(html_escape(data.toString())); return true; } return false; }
void TemplateTagSplatAttrs::render(std::string &buffer, expr::Scope &scope)const { std::unordered_map<std::string, std::vector<Ptr<Object>>> attrs; //Determine all attributes for (auto &i : static_attrs) attrs[i.first].push_back(make_value(i.second)); for (auto &i : dynamic_attrs) { auto &attr = attrs[i.first]; auto val = i.second->eval(scope); add_attr_value(attr, val); } for (auto &splat : splat_attrs) { auto hash = coerce<Hash>(splat->eval(scope)); for (auto &i : *hash) { auto &attr = attrs[i.first->to_string()]; auto val = i.second; add_attr_value(attr, val); } } //Output attributes for (auto &i : attrs) { auto &name = html_escape(i.first); auto &values = i.second; if (values.empty()) continue; //empty / no value else if (values.size() == 1) { auto val = values[0]; if (val == TRUE_VALUE) //true boolean attr { buffer += ' '; buffer += name; } else if (val == FALSE_VALUE || val == NIL_VALUE) //false boolean attr { continue; } else buffer += attr_str(name, {val->to_string()}); } else { //array of values, e.g. "class" std::vector<std::string> strings; for (auto &j : values) strings.push_back(j->to_string()); buffer += attr_str(name, strings); } } }
static int html_autolink( struct Blob *ob, struct Blob *link, enum mkd_autolink type, void *opaque ){ if( !link || blob_size(link)<=0 ) return 0; BLOB_APPEND_LITERAL(ob, "<a href=\""); if( type==MKDA_IMPLICIT_EMAIL ) BLOB_APPEND_LITERAL(ob, "mailto:"); html_escape(ob, blob_buffer(link), blob_size(link)); BLOB_APPEND_LITERAL(ob, "\">"); if( type==MKDA_EXPLICIT_EMAIL && blob_size(link)>7 ){ /* remove "mailto:" from displayed text */ html_escape(ob, blob_buffer(link)+7, blob_size(link)-7); }else{ html_escape(ob, blob_buffer(link), blob_size(link)); } BLOB_APPEND_LITERAL(ob, "</a>"); return 1; }
void GDBOutputWidget::slotReceivedStderr(const char* line) { QString colored = colorify(html_escape(line), "red"); // Errors are shown inside user commands too. allCommands_.append(colored); trimList(allCommands_, maxLines_); userCommands_.append(colored); trimList(userCommands_, maxLines_); allCommandsRaw_.append(line); trimList(allCommandsRaw_, maxLines_); userCommandsRaw_.append(line); trimList(userCommandsRaw_, maxLines_); showLine(colored); }
void safe_print_string( char *str ) { char *safe_str ; if( str == 0 ) { printf("(null)"); return; } safe_str = html_escape( str ); if( safe_str == 0 ) { printf("(no memory)"); } else { printf("%s",safe_str ); free( safe_str ); } }
std::string AI::describe_unit(df::unit *u, bool html) { // Unknown Unit if (!u) { if (html) { return "<i>(unknown unit)</i>"; } return "(unknown unit)"; } // Name std::string s = describe_name(u->name); if (!s.empty()) { s += ", "; } // Curse Name if (!u->curse.name.empty()) { s += u->curse.name; s += " "; } // Profession Name s += Units::getProfessionName(u); if (html) { s = html_escape(s); if (u->hist_figure_id != -1) { s = stl_sprintf("<a href=\"fig-%d\">", u->hist_figure_id) + s + "</a>"; } } return s; }
static void show_breadcrump_field (const char *str, /* {{{ */ const char *field_name) { if ((str == NULL) || (str[0] == 0)) printf ("<em>none</em>"); else if (IS_ANY (str)) printf ("<em>any</em>"); else if (IS_ALL (str)) printf ("<em>all</em>"); else { char *str_html = html_escape (str); if (field_name != NULL) printf ("<a href=\"%s?action=search;q=%s:%s\">%s</a>", script_name (), field_name, str_html, str_html); else printf ("<a href=\"%s?action=search;q=%s\">%s</a>", script_name (), str_html, str_html); free (str_html); } } /* }}} void show_breadcrump_field */
/* set an attribute */ static void attrsetn_internal(attrlist_t al, const char *name, int safe_fl, const _char *value, size_t len) { attr_t *at; at=setup_access(al, name); /* a null value would delete the attribute */ if(value==NULL) { if(at) attrdel(al, at); /* delete if there is no value */ return; } /* discard the old attribute values */ free(at->value); at->value=NULL; /* set the attribute */ if(safe_fl) { at->len=html_escape_len(value, len); at->value=malloc(at->len+1); html_escape(at->value, at->len, value); } else { at->len=len; at->value=malloc(len+1); memcpy(at->value, value, at->len+1); } }
void TemplateOutputExpr::render(std::string & buffer, expr::Scope &scope) const { auto val = expression->eval(scope); buffer += html_escape(val); }
std::string html_escape(const dstring &src) { return html_escape(as_string(src)); }
/** * Writes the browse host data of the context ``ctx'' to the buffer * ``dest''. This must be called multiple times to retrieve the complete * data until zero is returned i.e., the end of file is reached. * * This routine deals with HTML data generation. * * @param ctx an initialized browse host context. * @param dest the destination buffer. * @param size the amount of bytes ``dest'' can hold. * * @return -1 on failure, zero at the end-of-file condition or if size * was zero. On success, the amount of bytes copied to ``dest'' * is returned. */ static ssize_t browse_host_read_html(struct special_upload *ctx, void *const dest, size_t size) { static const char header[] = "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\">\r\n" "<html>\r\n" "<head>\r\n" "<title>Browse Host</title>\r\n" "</head>\r\n" "<body>\r\n"; static const char trailer[] = "</ul>\r\n</body>\r\n</html>\r\n"; struct browse_host_upload *bh = cast_to_browse_host_upload(ctx); char *p = dest; g_assert(NULL != bh); g_assert(NULL != dest); g_assert(size <= INT_MAX); g_assert(UNSIGNED(bh->state) < NUM_BH_STATES); g_assert(bh->b_size <= INT_MAX); g_assert(bh->b_offset <= bh->b_size); do { switch (bh->state) { case BH_STATE_HEADER: if (!bh->b_data) { bh->b_data = header; bh->b_size = CONST_STRLEN(header); } p += browse_host_read_data(bh, p, &size); if (bh->b_size == bh->b_offset) browse_host_next_state(bh, BH_STATE_LIBRARY_INFO); break; case BH_STATE_LIBRARY_INFO: if (!bh->b_data) { bh->w_buf_size = w_concat_strings(&bh->w_buf, "<h1>", product_get_name(), "</h1>\r\n" "<h3>", version_get_string(), " sharing ", uint64_to_string(shared_files_scanned()), " file", shared_files_scanned() == 1 ? "" : "s", " ", short_kb_size(shared_kbytes_scanned(), GNET_PROPERTY(display_metric_units)), " total</h3>\r\n" "<ul>\r\n", (void *) 0); bh->b_data = bh->w_buf; bh->b_size = bh->w_buf_size - 1; /* minus trailing NUL */ bh->b_offset = 0; } p += browse_host_read_data(bh, p, &size); if (bh->b_size == bh->b_offset) browse_host_next_state(bh, BH_STATE_FILES); break; case BH_STATE_TRAILER: if (!bh->b_data) { bh->b_data = trailer; bh->b_size = CONST_STRLEN(trailer); } p += browse_host_read_data(bh, p, &size); if (bh->b_size == bh->b_offset) browse_host_next_state(bh, BH_STATE_EOF); break; case BH_STATE_FILES: if (bh->b_data && bh->b_size == bh->b_offset) { g_assert(bh->w_buf == bh->b_data); wfree(bh->w_buf, bh->w_buf_size); bh->w_buf = NULL; bh->w_buf_size = 0; bh->b_data = NULL; } if (!bh->b_data) { const shared_file_t *sf; bh->file_index++; sf = shared_file_sorted(bh->file_index); if (!sf) { if (bh->file_index > shared_files_scanned()) browse_host_next_state(bh, BH_STATE_TRAILER); /* Skip holes in the file_index table */ } else if (SHARE_REBUILDING == sf) { browse_host_next_state(bh, BH_STATE_REBUILDING); } else { const char * const name_nfc = shared_file_name_nfc(sf); const filesize_t file_size = shared_file_size(sf); size_t html_size; char *html_name; { const char *dir; char *name; dir = shared_file_relative_path(sf); if (dir) { name = h_strconcat(dir, "/", name_nfc, (void *) 0); } else { name = deconstify_char(name_nfc); } html_size = 1 + html_escape(name, NULL, 0); html_name = walloc(html_size); html_escape(name, html_name, html_size); if (name != name_nfc) { HFREE_NULL(name); } } if (sha1_hash_available(sf)) { const struct sha1 *sha1 = shared_file_sha1(sf); bh->w_buf_size = w_concat_strings(&bh->w_buf, "<li><a href=\"/uri-res/N2R?urn:sha1:", sha1_base32(sha1), "\">", html_name, "</a> [", short_html_size(file_size, GNET_PROPERTY(display_metric_units)), "]</li>\r\n", (void *) 0); } else { char *escaped; escaped = url_escape(name_nfc); bh->w_buf_size = w_concat_strings(&bh->w_buf, "<li><a href=\"/get/", uint32_to_string(shared_file_index(sf)), "/", escaped, "\">", html_name, "</a>" " [", short_html_size(file_size, GNET_PROPERTY(display_metric_units)), "]</li>\r\n", (void *) 0); if (escaped != name_nfc) { HFREE_NULL(escaped); } } wfree(html_name, html_size); bh->b_data = bh->w_buf; bh->b_size = bh->w_buf_size - 1; /* minus trailing NUL */ bh->b_offset = 0; } } if (bh->b_data) p += browse_host_read_data(bh, p, &size); break; case BH_STATE_REBUILDING: if (!bh->b_data) { static const char msg[] = "<li>" "<b>" "The library is currently being rebuild. Please, " "try again in a moment." "</b>" "</li>"; bh->b_data = msg; bh->b_size = CONST_STRLEN(msg); } p += browse_host_read_data(bh, p, &size); if (bh->b_size == bh->b_offset) browse_host_next_state(bh, BH_STATE_TRAILER); break; case BH_STATE_EOF: return p - cast_to_char_ptr(dest); case NUM_BH_STATES: g_assert_not_reached(); } } while (size > 0); return p - cast_to_char_ptr(dest); }
static int html_code_span(struct Blob *ob, struct Blob *text, void *opaque){ BLOB_APPEND_LITERAL(ob, "<code>"); html_escape(ob, blob_buffer(text), blob_size(text)); BLOB_APPEND_LITERAL(ob, "</code>"); return 1; }
static void html_blockcode(struct Blob *ob, struct Blob *text, void *opaque){ INTER_BLOCK(ob); BLOB_APPEND_LITERAL(ob, "<pre><code>"); html_escape(ob, blob_buffer(text), blob_size(text)); BLOB_APPEND_LITERAL(ob, "</code></pre>\n"); }
std::string operator()(const std::string& value) const { return (m_flag == flag::escape_html) ? html_escape(value) : value; }
static void html_normal_text(struct Blob *ob, struct Blob *text, void *opaque){ html_escape(ob, blob_buffer(text), blob_size(text)); }
/* Add a single preference to the QVBoxLayout of a preference page */ static guint pref_show(pref_t *pref, gpointer layout_ptr) { QVBoxLayout *vb = static_cast<QVBoxLayout *>(layout_ptr); if (!pref || !vb) return 0; // Convert the pref description from plain text to rich text. QString description = html_escape(prefs_get_description(pref)); description.replace('\n', "<br>"); QString tooltip = QString("<span>%1</span>").arg(description); switch (prefs_get_type(pref)) { case PREF_UINT: case PREF_DECODE_AS_UINT: { QHBoxLayout *hb = new QHBoxLayout(); QLabel *label = new QLabel(prefs_get_title(pref)); label->setToolTip(tooltip); hb->addWidget(label); QLineEdit *uint_le = new QLineEdit(); uint_le->setToolTip(tooltip); uint_le->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); uint_le->setMinimumWidth(uint_le->fontMetrics().height() * 8); hb->addWidget(uint_le); hb->addSpacerItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum)); vb->addLayout(hb); break; } case PREF_BOOL: { QCheckBox *bool_cb = new QCheckBox(title_to_shortcut(prefs_get_title(pref))); bool_cb->setToolTip(tooltip); bool_cb->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); vb->addWidget(bool_cb); break; } case PREF_ENUM: { const enum_val_t *ev; if (prefs_get_enumvals(pref) == NULL) return 0; if (prefs_get_enum_radiobuttons(pref)) { QLabel *label = new QLabel(prefs_get_title(pref)); label->setToolTip(tooltip); vb->addWidget(label); QButtonGroup *enum_bg = new QButtonGroup(vb); for (ev = prefs_get_enumvals(pref); ev && ev->description; ev++) { QRadioButton *enum_rb = new QRadioButton(title_to_shortcut(ev->description)); enum_rb->setToolTip(tooltip); QStyleOption style_opt; enum_rb->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); enum_rb->setStyleSheet(QString( "QRadioButton {" " margin-left: %1px;" "}" ) .arg(enum_rb->style()->subElementRect(QStyle::SE_CheckBoxContents, &style_opt).left())); enum_bg->addButton(enum_rb, ev->value); vb->addWidget(enum_rb); } } else { QHBoxLayout *hb = new QHBoxLayout(); QComboBox *enum_cb = new QComboBox(); enum_cb->setToolTip(tooltip); enum_cb->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); for (ev = prefs_get_enumvals(pref); ev && ev->description; ev++) { enum_cb->addItem(ev->description, QVariant(ev->value)); } hb->addWidget(new QLabel(prefs_get_title(pref))); hb->addWidget(enum_cb); hb->addSpacerItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum)); vb->addLayout(hb); } break; } case PREF_STRING: { QHBoxLayout *hb = new QHBoxLayout(); QLabel *label = new QLabel(prefs_get_title(pref)); label->setToolTip(tooltip); hb->addWidget(label); QLineEdit *string_le = new QLineEdit(); string_le->setToolTip(tooltip); string_le->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); string_le->setMinimumWidth(string_le->fontMetrics().height() * 20); hb->addWidget(string_le); hb->addSpacerItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum)); vb->addLayout(hb); break; } case PREF_DECODE_AS_RANGE: case PREF_RANGE: { QHBoxLayout *hb = new QHBoxLayout(); QLabel *label = new QLabel(prefs_get_title(pref)); label->setToolTip(tooltip); hb->addWidget(label); SyntaxLineEdit *range_se = new SyntaxLineEdit(); range_se->setToolTip(tooltip); range_se->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); range_se->setMinimumWidth(range_se->fontMetrics().height() * 20); hb->addWidget(range_se); hb->addSpacerItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum)); vb->addLayout(hb); break; } case PREF_STATIC_TEXT: { QLabel *label = new QLabel(prefs_get_title(pref)); label->setToolTip(tooltip); label->setWordWrap(true); vb->addWidget(label); break; } case PREF_UAT: { QHBoxLayout *hb = new QHBoxLayout(); QLabel *label = new QLabel(prefs_get_title(pref)); label->setToolTip(tooltip); hb->addWidget(label); QPushButton *uat_pb = new QPushButton(QObject::tr("Edit" UTF8_HORIZONTAL_ELLIPSIS)); uat_pb->setToolTip(tooltip); uat_pb->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); hb->addWidget(uat_pb); hb->addSpacerItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum)); vb->addLayout(hb); break; } case PREF_SAVE_FILENAME: case PREF_OPEN_FILENAME: case PREF_DIRNAME: { QLabel *label = new QLabel(prefs_get_title(pref)); label->setToolTip(tooltip); vb->addWidget(label); QHBoxLayout *hb = new QHBoxLayout(); QLineEdit *path_le = new QLineEdit(); path_le->setToolTip(tooltip); QStyleOption style_opt; path_le->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); path_le->setMinimumWidth(path_le->fontMetrics().height() * 20); path_le->setStyleSheet(QString( "QLineEdit {" " margin-left: %1px;" "}" ) .arg(path_le->style()->subElementRect(QStyle::SE_CheckBoxContents, &style_opt).left())); hb->addWidget(path_le); QPushButton *path_pb = new QPushButton(QObject::tr("Browse" UTF8_HORIZONTAL_ELLIPSIS)); path_pb->setProperty(pref_prop_, VariantPointer<pref_t>::asQVariant(pref)); hb->addWidget(path_pb); hb->addSpacerItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum)); vb->addLayout(hb); break; } case PREF_COLOR: { // XXX - Not needed yet. When it is needed we can add a label + QFrame which pops up a // color picker similar to the Font and Colors prefs. break; } default: break; } return 0; }
int notify_html_listeners(int descr, dbref who, dbref xprog, dbref obj, dbref room, const char *msg, int isprivate) { char buf[BUFFER_LEN], *nohbuf, *noabuf, buf2[BUFFER_LEN]; dbref ref; if (obj == NOTHING) return 0; nohbuf = html_escape(msg); noabuf = tct(buf2, nohbuf); if (tp_listeners && (tp_listeners_obj || Typeof(obj) == TYPE_ROOM)) { listenqueue(descr, who, room, obj, obj, xprog, "_listen", nohbuf, tp_listen_mlev, 1, 0); listenqueue(descr, who, room, obj, obj, xprog, "_olisten", nohbuf, tp_listen_mlev, 0, 0); listenqueue(descr, who, room, obj, obj, xprog, "~listen", nohbuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "~olisten", nohbuf, tp_listen_mlev, 0, 1); listenqueue(descr, who, room, obj, obj, xprog, "@listen", nohbuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "@olisten", nohbuf, tp_listen_mlev, 0, 1); listenqueue(descr, who, room, obj, obj, xprog, "_alisten", noabuf, tp_listen_mlev, 1, 0); listenqueue(descr, who, room, obj, obj, xprog, "_aolisten", noabuf, tp_listen_mlev, 0, 0); listenqueue(descr, who, room, obj, obj, xprog, "~alisten", noabuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "~aolisten", noabuf, tp_listen_mlev, 0, 1); listenqueue(descr, who, room, obj, obj, xprog, "@alisten", noabuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "@aolisten", noabuf, tp_listen_mlev, 0, 1); /* Loop up the environment only if tp_listeners_env is set and obj * is a room. Runs once otherwise. -brevantes */ if (tp_listeners_env && (Typeof(obj) == TYPE_ROOM) ) { obj = DBFETCH(obj)->location; for (;obj != NOTHING;obj = DBFETCH(obj)->location) { listenqueue(descr, who, room, obj, obj, xprog, "_listen", nohbuf, tp_listen_mlev, 1, 0); listenqueue(descr, who, room, obj, obj, xprog, "_olisten", nohbuf, tp_listen_mlev, 0, 0); listenqueue(descr, who, room, obj, obj, xprog, "~listen", nohbuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "~olisten", nohbuf, tp_listen_mlev, 0, 1); listenqueue(descr, who, room, obj, obj, xprog, "@listen", nohbuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "@olisten", nohbuf, tp_listen_mlev, 0, 1); listenqueue(descr, who, room, obj, obj, xprog, "_alisten", noabuf, tp_listen_mlev, 1, 0); listenqueue(descr, who, room, obj, obj, xprog, "_aolisten", noabuf, tp_listen_mlev, 0, 0); listenqueue(descr, who, room, obj, obj, xprog, "~alisten", noabuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "~aolisten", noabuf, tp_listen_mlev, 0, 1); listenqueue(descr, who, room, obj, obj, xprog, "@alisten", noabuf, tp_listen_mlev, 1, 1); listenqueue(descr, who, room, obj, obj, xprog, "@aolisten", noabuf, tp_listen_mlev, 0, 1); } return 0; } } if (tp_zombies && (Typeof(obj) == TYPE_THING) && !isprivate && !(FLAGS(obj) & QUELL)) { if (FLAGS(obj) & VEHICLE) { if (getloc(who) == getloc(obj)) { char pbuf[BUFFER_LEN]; const char *prefix; prefix = GETOECHO(obj); if (prefix && *prefix) { prefix = do_parse_mesg(-1, who, obj, prefix, "(@Oecho)", pbuf, MPI_ISPRIVATE); } if (!prefix || !*prefix) prefix = "Outside>"; sprintf(buf, "%s %.*s", prefix, (int) (BUFFER_LEN - 2 - strlen(prefix)), msg); ref = DBFETCH(obj)->contents; while (ref != NOTHING) { #ifdef IGNORE_SUPPORT if (!ignorance(who, ref)) #endif /* IGNORE_SUPPORT */ notify_html_nolisten(ref, buf, isprivate); ref = DBFETCH(ref)->next; } } } } if (Typeof(obj) == TYPE_PLAYER || Typeof(obj) == TYPE_THING) { #ifdef IGNORE_SUPPORT if (ignorance(who, obj)) return 0; #endif if ( !isprivate && Typeof(obj) == TYPE_THING && FLAGS(obj) & ZOMBIE && LOCATION(obj) == LOCATION(OWNER(obj)) ) return 0; return notify_html_nolisten(obj, msg, isprivate); } else { return 0; } }
void bcp_implementation::scan_license(const fs::path& p, const fileview& v) { std::pair<const license_info*, int> licenses = get_licenses(); // // scan file for all the licenses in the list: // int license_count = 0; int author_count = 0; int nonbsl_author_count = 0; bool has_non_bsl_license = false; fileview::const_iterator start_of_license = v.begin(), end_of_license = v.end(); bool start_in_middle_of_line = false; for(int i = 0; i < licenses.second; ++i) { boost::match_results<fileview::const_iterator> m; if(boost::regex_search(v.begin(), v.end(), m, licenses.first[i].license_signature)) { start_of_license = m[0].first; end_of_license = m[0].second; if (is_non_bsl_license(i) && i < licenses.second - 1) has_non_bsl_license = true; // add this license to the list: m_license_data[i].files.insert(p); ++license_count; // // scan for the associated copyright declarations: // boost::regex_iterator<const char*> cpy(v.begin(), v.end(), licenses.first[i].copyright_signature); boost::regex_iterator<const char*> ecpy; while(cpy != ecpy) { #if 0 // Not dealing with copyrights because we don't have the years if ((*cpy)[0].first < start_of_license) start_of_license = (*cpy)[0].first; if ((*cpy)[0].second > end_of_license) end_of_license = (*cpy)[0].second; #endif // extract the copy holders as a list: std::string author_list = cpy->format(licenses.first[i].copyright_formatter, boost::format_all); // now enumerate that list for all the names: static const boost::regex author_separator("(?:\\s*,(?!\\s*(?:inc|ltd)\\b)\\s*|\\s+(,\\s*)?(and|&)\\s+)|by\\s+", boost::regex::perl | boost::regex::icase); boost::regex_token_iterator<std::string::const_iterator> atr(author_list.begin(), author_list.end(), author_separator, -1); boost::regex_token_iterator<std::string::const_iterator> eatr; while(atr != eatr) { // get the reformatted authors name: std::string name = format_authors_name(*atr); // add to list of authors for this file: if(name.size() && name[0] != '-') { m_license_data[i].authors.insert(name); // add file to author index: m_author_data[name].insert(p); ++author_count; // If this is not the Boost Software License (license 0), and the author hasn't given // blanket permission, note this for the report. if (has_non_bsl_license && m_bsl_authors.find(name) == m_bsl_authors.end()) { ++nonbsl_author_count; m_authors_for_bsl_migration.insert(name); } } ++atr; } ++cpy; } while (start_of_license != v.begin() && *start_of_license != '\r' && *start_of_license != '\n' && *start_of_license != '.') --start_of_license; if (start_of_license != v.begin()) { if (*start_of_license == '.') start_in_middle_of_line = true; ++start_of_license; } while (end_of_license != v.end() && *end_of_license != '\r' && *end_of_license != '\n') ++end_of_license; } } if(license_count == 0) m_unknown_licenses.insert(p); if(license_count && !author_count) m_unknown_authors.insert(p); if (has_non_bsl_license) { bool converted = false; if (nonbsl_author_count == 0 && license_count == 1) { // Grab a few lines of context fileview::const_iterator context_start = context_before_license(v, start_of_license); fileview::const_iterator context_end = context_after_license(v, end_of_license); // TBD: For files that aren't C++ code, this will have to // change. std::string prefix = find_prefix(v, start_of_license); // Create enough information to permit manual verification of // the correctness of the transformation std::string before_conversion = html_escape(context_start, start_of_license); before_conversion += "<b>"; before_conversion += html_escape(start_of_license, end_of_license); before_conversion += "</b>"; before_conversion += html_escape(end_of_license, context_end); std::string after_conversion = html_escape(context_start, start_of_license); if (start_in_middle_of_line) after_conversion += '\n'; after_conversion += "<b>"; for (int i = 0; i < boost_license_lines; ++i) { if (i > 0) after_conversion += '\n'; after_conversion += prefix + boost_license_text[i]; } after_conversion += "</b>"; after_conversion += html_escape(end_of_license, context_end); m_converted_to_bsl[p] = std::make_pair(before_conversion, after_conversion); // Perform the actual conversion if (m_bsl_convert_mode) { try{ std::ofstream out((m_boost_path / p).string().c_str()); if (!out) { std::string msg("Cannot open file for license conversion: "); msg += p.string(); std::runtime_error e(msg); boost::throw_exception(e); } out << std::string(v.begin(), start_of_license); if (start_in_middle_of_line) out << std::endl; for (int j = 0; j < boost_license_lines; ++j) { if (j > 0) out << std::endl; out << prefix << boost_license_text[j]; } out << std::string(end_of_license, v.end()); converted = true; } catch(const std::exception& e) { std::cerr << e.what() << std::endl; } } } if (!converted) { if (nonbsl_author_count > 0) m_cannot_migrate_to_bsl.insert(p); else m_can_migrate_to_bsl.insert(p); } } }
int crad_get_status_xml(struct _crad_t *p_crad, char *xml_str, int max_size) { /*! sanity check - null ptr */ if(p_crad == 0) { return CRAD_INVALID_PARAM; } /*! sanity check - initialization */ if(!p_crad->is_initialized) { return CRAD_INVALID_CALL; } /*! write XML header */ strncpy(xml_str, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>", max_size); int status1 = QND_ReadReg(STATUS1); int strength = QND_ReadReg(RSSISIG); int step = QND_ReadReg(CH_STEP); struct rds_data data_copy; int radio_station = get_radio_station(p_crad); // If the RDS thread isn't running, make the RDS string be empty. // Otherwise, fill it in. if(!p_crad->rds_thread_running) { rds_string[0] = '\0'; } else { pthread_mutex_lock(&p_crad->rds_mutex); data_copy = p_crad->rds_data; html_escape(psnescaped, sizeof(psnescaped), data_copy.program_service_name), html_escape(ptcescaped, sizeof(ptcescaped), data_copy.program_type_code), html_escape(rt0escaped, sizeof(rt0escaped), data_copy.radiotext_filled[0]), html_escape(rt1escaped, sizeof(rt1escaped), data_copy.radiotext_filled[1]), pthread_mutex_unlock(&p_crad->rds_mutex); snprintf(rds_string, sizeof(rds_string), "callsign='%s' " "programservice='%s' " "ptycode='%s' " "radiotext0='%s' " "radiotext1='%s' " "juliandate='%d' " "hour='%d' " "minute='%d' " "localtime='%d:%02d' " , data_copy.callsign, psnescaped, ptcescaped, rt0escaped, rt1escaped, data_copy.julian_date, data_copy.hour_code, data_copy.minute, data_copy.localtime_hours, data_copy.localtime_minutes ); } snprintf(xml_str, max_size, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<radio found='1' tuned='%c' station='%d.%d' stereo='%c' " "signal='%d' signal_max='256' " "seek_threshold='%d' seek_threshold_max='255' " "spacing='%d' " "start='%d.%02d' stop='%d.%02d' " "band='%s' " "%s" ">\n" "%s" "</radio>\n" , // tuned in or not? (strength>85?'1':'0'), // Current station frequency radio_station/100, radio_station-(100*(radio_station/100)), // Whether we're in stereo or not. (Inverted bit, 0 = stereo.) (status1&1?'0':'1'), // Signal strength (in mysterious moon-units?) (strength), // Seek threshold (?) (0), // Channel spacing steparray[QND_CH_STEP]*10, // Start and stop frequencies QND_CH_START/100, QND_CH_START%100, QND_CH_STOP/100, QND_CH_STOP%100, // Current band setting (qnd_Country==COUNTRY_CHINA?"China": (qnd_Country==COUNTRY_USA?"US": (qnd_Country==COUNTRY_JAPAN?"Japan":"Europe"))), // If we're monitoring RDS data, copy that over. rds_string, // Append the list of stations we've found. get_radio_stations(p_crad) ); /*! if we didn't have room for a null terminator, we should just * fail instead of risking corrupting the XML with one */ if(xml_str[max_size-1] != '\0') { return CRAD_FAIL; } return CRAD_OK; }
QByteArray TapParameterDialog::getTreeAsString(st_format_type format) { QByteArray ba; QTreeWidgetItemIterator it(ui->statsTreeWidget, QTreeWidgetItemIterator::NotHidden); QList<int> col_widths; QByteArray footer; // Title + header switch (format) { case ST_FORMAT_PLAIN: { // Iterating over trees. QTreeWidgetItemIterator width_it(it); QString plain_header; while (*width_it) { // Iterating over items within this tree. for (int col=0; col < ui->statsTreeWidget->columnCount(); col++) { if (col_widths.size() <= col) { col_widths.append(ui->statsTreeWidget->headerItem()->text(col).length()); } QVariant var = ui->statsTreeWidget->headerItem()->data(col, Qt::DisplayRole); if (var.type() == QVariant::String) { col_widths[col] = qMax(col_widths[col], itemDataToPlain(var).length()); } } ++width_it; } QStringList ph_parts; for (int col = 0; col < ui->statsTreeWidget->columnCount() && col < col_widths.length(); col++) { ph_parts << ui->statsTreeWidget->headerItem()->text(col); } plain_header = ph_parts.join(plain_sep_); QByteArray top_separator; top_separator.fill('=', plain_header.length()); top_separator.append('\n'); QString file_header = QString("%1 - %2:\n").arg(windowSubtitle(), cap_file_.fileDisplayName()); footer.fill('-', plain_header.length()); footer.append('\n'); plain_header.append('\n'); ba.append(top_separator); ba.append(file_header); ba.append(plain_header); ba.append(footer); break; } case ST_FORMAT_CSV: { QString csv_header; QStringList ch_parts; for (int col = 0; col < ui->statsTreeWidget->columnCount(); col++) { ch_parts << QString("\"%1\"").arg(ui->statsTreeWidget->headerItem()->text(col)); } csv_header = ch_parts.join(","); csv_header.append('\n'); ba.append(csv_header.toUtf8().constData()); break; } case ST_FORMAT_XML: { // XXX What's a useful format? This mostly conforms to DocBook. ba.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); QString title = html_escape(windowSubtitle()); QString xml_header = QString("<table>\n<title>%1</title>\n").arg(title); ba.append(xml_header.toUtf8()); ba.append("<thead>\n<row>\n"); for (int col = 0; col < ui->statsTreeWidget->columnCount(); col++) { title = html_escape(ui->statsTreeWidget->headerItem()->text(col)); title = QString(" <entry>%1</entry>\n").arg(title); ba.append(title.toUtf8()); } ba.append("</row>\n</thead>\n"); ba.append("<tbody>\n"); footer = "</tbody>\n</table>\n"; break; } case ST_FORMAT_YAML: { QString yaml_header; ba.append("---\n"); yaml_header = QString("Description: \"%1\"\nFile: \"%2\"\nItems:\n").arg(windowSubtitle()).arg(cap_file_.fileDisplayName()); ba.append(yaml_header.toUtf8()); break; } default: break; } // Data while (*it) { QList<QVariant> tid = treeItemData((*it)); if (tid.length() < 1) { ++it; continue; } if (tid.length() < ui->statsTreeWidget->columnCount()) { // Assume we have a header } // Assume var length == columnCount QString line; QStringList parts; switch (format) { case ST_FORMAT_PLAIN: { int i = 0; foreach (QVariant var, tid) { parts << itemDataToPlain(var, col_widths[i]); i++; } line = parts.join(plain_sep_); line.append('\n'); break; } case ST_FORMAT_CSV: foreach (QVariant var, tid) { if (var.type() == QVariant::String) { parts << QString("\"%1\"").arg(var.toString()); } else { parts << var.toString(); } } line = parts.join(","); line.append('\n'); break; case ST_FORMAT_XML: { line = "<row>\n"; foreach (QVariant var, tid) { QString entry = html_escape(var.toString()); line.append(QString(" <entry>%1</entry>\n").arg(entry)); } line.append("</row>\n"); break; } case ST_FORMAT_YAML: { int col = 0; QString indent = "-"; foreach (QVariant var, tid) { QString entry; if (var.type() == QVariant::String) { entry = QString("\"%1\"").arg(var.toString()); } else { entry = var.toString(); } line.append(QString(" %1 %2: %3\n").arg(indent).arg(ui->statsTreeWidget->headerItem()->text(col), entry)); indent = " "; col++; } break; }