/*
* NAME: parser->new()
* DESCRIPTION: create a new parser instance
*/
static parser *ps_new(frame *f, string *source, string *grammar)
{
parser *ps;
char *p;
ps = ALLOC(parser, 1);
ps->frame = f;
ps->data = f->data;
ps->data->parser = ps;
str_ref(ps->source = source);
str_ref(ps->grammar = grammar);
ps->fastr = (char *) NULL;
ps->lrstr = (char *) NULL;
ps->fa = dfa_new(source->text, grammar->text);
ps->lr = srp_new(grammar->text);
ps->pnc = (pnchunk *) NULL;
ps->list.snc = (snchunk *) NULL;
ps->list.first = ps->list.free = (snode *) NULL;
ps->strc = (strchunk *) NULL;
ps->arrc = (arrchunk *) NULL;
p = grammar->text;
ps->ntoken = ((UCHAR(p[5]) + UCHAR(p[9]) + UCHAR(p[11])) << 8) +
UCHAR(p[6]) + UCHAR(p[10]) + UCHAR(p[12]);
ps->nprod = (UCHAR(p[13]) << 8) + UCHAR(p[14]);
return ps;
}
str_ref t_torrent::select_peers(mutable_str_ref d, const Ctracker_input& ti) const
{
if (ti.m_event == Ctracker_input::e_stopped)
return str_ref();
std::vector<std::array<char, 6>> candidates;
candidates.reserve(peers.size());
for (auto& i : peers)
{
if (!ti.m_left && !i.second.left)
continue;
std::array<char, 6> v;
memcpy(&v[0], &i.first.host_, 4);
memcpy(&v[4], &i.second.port, 2);
candidates.push_back(v);
}
size_t c = d.size() / 6;
if (candidates.size() <= c)
{
memcpy(d.data(), candidates);
return d.substr(0, 6 * candidates.size());
}
const char* d0 = d.begin();
while (c--)
{
int i = rand() % candidates.size();
memcpy(d.data(), candidates[i]);
d.advance_begin(6);
candidates[i] = candidates.back();
candidates.pop_back();
}
return str_ref(d0, d.data());
}
Data *Data_new(const char *name, int age, bool mf)
{
Data *obj = obj_new(Data,Data_dispose);
obj->name = str_ref((char*)name);
obj->age = age;
obj->mf = mf;
return obj;
}
File *File_new(str_t name) {
File *res = obj_new(File,File_dispose);
if (! s_file_type) {
s_file_type = obj_type_index(res);
}
res->name = str_ref(name);
return res;
}
Propdef
dbpriv_new_propdef(const char *name)
{
Propdef newprop;
newprop.name = str_ref(name);
newprop.hash = str_hash(name);
return newprop;
}
static int
add_to_list(void *data, const char *verb_name)
{
struct verb_data *d = data;
d->i++;
d->r.v.list[d->i].type = TYPE_STR;
d->r.v.list[d->i].v.str = str_ref(verb_name);
return 0;
}
static void insert_str_tuple_field_to_dictionary (const Tuple * tuple, int
fieldn, GHashTable * dict, const char * key)
{
char * val = tuple_get_str (tuple, fieldn);
if (val && val[0])
g_hash_table_insert (dict, str_get (key), str_ref (val));
else
g_hash_table_remove (dict, key);
str_unref(val);
}
/*
* NAME: node->tostr()
* DESCRIPTION: convert node type to string constant
*/
void node_tostr(node *n, String *str)
{
str_ref(str);
if (n->type == N_STR) {
str_del(n->l.string);
} else if (n->type == N_TYPE && n->sclass != (String *) NULL) {
str_del(n->sclass);
}
n->type = N_STR;
n->flags = F_CONST;
n->l.string = str;
}
/*
* NAME: node->str()
* DESCRIPTION: create a string node
*/
node *node_str(String *str)
{
node *n;
n = node_new(tk_line());
n->type = N_STR;
n->flags = F_CONST;
n->mod = T_STRING;
str_ref(n->l.string = str);
n->r.right = (node *) NULL;
return n;
}
/*
* NAME: strchunk->add()
* DESCRIPTION: add a string to the current chunk
*/
static void sc_add(strchunk **c, string *str)
{
if (*c == (strchunk *) NULL || (*c)->chunksz == STRCHUNKSZ) {
strchunk *x;
x = ALLOC(strchunk, 1);
x->next = *c;
*c = x;
x->chunksz = 0;
}
str_ref((*c)->str[(*c)->chunksz++] = str);
}
/*
* NAME: node->type()
* DESCRIPTION: create a type node
*/
node *node_type(int type, String *tclass)
{
node *n;
n = node_new(tk_line());
n->type = N_TYPE;
n->mod = type;
n->sclass = tclass;
if (tclass != (String *) NULL) {
str_ref(tclass);
}
return n;
}
/* Make an immutable copy of s. If there's an intern table open,
possibly share storage. */
const char *
str_intern(const char *s)
{
struct intern_entry *e;
unsigned hash;
const char *r;
if (s == NULL || *s == '\0') {
/* str_dup already has a canonical empty string */
return str_dup(s);
}
if (intern_table == NULL) {
return str_dup(s);
}
hash = str_hash(s);
e = find_interned_string(s, hash);
if (e != NULL) {
intern_allocations_saved++;
intern_bytes_saved += memo_strlen(e->s);
return str_ref(e->s);
}
if (intern_table_count > intern_table_size) {
intern_rehash(intern_table_size * 2);
}
r = str_dup(s);
r = str_ref(r);
add_interned_string(r, hash);
return r;
}
/*
* NAME: path->include()
* DESCRIPTION: resolve an include path
*/
char *path_include(char *buf, char *from, char *file, string ***strs, int *nstr)
{
frame *f;
int i;
value *v;
string **str;
*strs = NULL;
*nstr = 0;
if (c_autodriver()) {
return path_from(buf, from, file);
}
f = cframe;
PUSH_STRVAL(f, str_new(from, strlen(from)));
PUSH_STRVAL(f, str_new(file, (long) strlen(file)));
if (!call_driver_object(f, "include_file", 2)) {
f->sp++;
return path_from(buf, from, file);
}
if (f->sp->type == T_STRING) {
/* simple path */
path_resolve(buf, f->sp->u.string->text);
str_del((f->sp++)->u.string);
return buf;
} else if (f->sp->type == T_ARRAY) {
/*
* Array of strings. Check that the array does indeed contain only
* strings, then return it.
*/
i = f->sp->u.array->size;
if (i != 0) {
v = d_get_elts(f->sp->u.array);
while ((v++)->type == T_STRING) {
if (--i == 0) {
*nstr = i = f->sp->u.array->size;
str = ALLOC(string*, i);
do {
str_ref(*str++ = (--v)->u.string);
} while (--i != 0);
*strs = str;
arr_del((f->sp++)->u.array);
/* return the untranslated path, as well */
return path_from(buf, from, file);
}
}
static void dr2dt (DiscoveredTopicQos *qp, const DiscoveredReaderData *info)
{
qp->durability = info->qos.durability;
qp->durability_service = qos_def_topic_qos.durability_service;
qp->deadline = info->qos.deadline;
qp->latency_budget = info->qos.latency_budget;
qp->liveliness = info->qos.liveliness;
qp->reliability = info->qos.reliability;
qp->transport_priority = qos_def_topic_qos.transport_priority;
qp->lifespan = qos_def_topic_qos.lifespan;
qp->destination_order = info->qos.destination_order;
qp->history = qos_def_topic_qos.history;
qp->resource_limits = qos_def_topic_qos.resource_limits;
qp->ownership = info->qos.ownership;
qp->topic_data = str_ref (info->qos.topic_data);
}
void test_lazy_string_empty()
{
#define CMP_STR_EMPTY (str_ref.empty() == str_test.empty())
std::string str_ref("");
lazy::lazy_string str_test("");
test("lazy_string empty() is valid on empty string", CMP_STR_EMPTY);
str_ref = "1";
str_test = "1";
test("lazy_string empty() is valid on 1 char string after assignment", CMP_STR_EMPTY);
str_ref = "12345";
str_test = "12345";
test("lazy_string empty() is valid on non-empty string after assignment", CMP_STR_EMPTY);
#undef CMP_STR_SIZES
}
static package
bf_verb_info(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, verb-desc) */
Objid oid = arglist.v.list[1].v.obj;
Var desc = arglist.v.list[2];
db_verb_handle h;
Var r;
unsigned flags;
char perms[5], *s;
enum error e;
if ((e = validate_verb_descriptor(desc)) != E_NONE
|| (e = E_INVARG, !valid(oid))) {
free_var(arglist);
return make_error_pack(e);
}
h = find_described_verb(oid, desc);
free_var(arglist);
if (!h.ptr)
return make_error_pack(E_VERBNF);
else if (!db_verb_allows(h, progr, VF_READ))
return make_error_pack(E_PERM);
r = new_list(3);
r.v.list[1].type = TYPE_OBJ;
r.v.list[1].v.obj = db_verb_owner(h);
r.v.list[2].type = TYPE_STR;
s = perms;
flags = db_verb_flags(h);
if (flags & VF_READ)
*s++ = 'r';
if (flags & VF_WRITE)
*s++ = 'w';
if (flags & VF_EXEC)
*s++ = 'x';
if (flags & VF_DEBUG)
*s++ = 'd';
*s = '\0';
r.v.list[2].v.str = str_dup(perms);
r.v.list[3].type = TYPE_STR;
r.v.list[3].v.str = str_ref(db_verb_names(h));
return make_var_pack(r);
}
static void get_lyrics_step_1(void)
{
if(!state.artist || !state.title)
{
update_lyrics_window(_("Error"), NULL, _("Missing song metadata"));
return;
}
char title_buf[strlen(state.title) * 3 + 1];
char artist_buf[strlen(state.artist) * 3 + 1];
str_encode_percent(state.title, -1, title_buf);
str_encode_percent(state.artist, -1, artist_buf);
str_unref(state.uri);
state.uri = str_printf("http://lyrics.wikia.com/api.php?action=lyrics&"
"artist=%s&song=%s&fmt=xml", artist_buf, title_buf);
update_lyrics_window(state.title, state.artist, _("Connecting to lyrics.wikia.com ..."));
vfs_async_file_get_contents(state.uri, get_lyrics_step_2, str_ref(state.uri));
}
void test_lazy_string_ix_operator()
{
std::string str_ref("test assignmnet operator using me");
lazy::lazy_string str_test(str_ref.c_str());
lazy::lazy_string str_test_lazy_cp(str_test);
test("[] operator get right value", str_ref[10] == str_test_lazy_cp[10]);
str_ref[10] = 'f';
str_test_lazy_cp[10] = 'f';
test("[] operator assigns value", str_ref[10] == str_test_lazy_cp[10]);
test("[] operator doesn't change original string",
str_test[10] != str_test_lazy_cp[10]);
auto str_test_5th_element = str_test[5];
test("proxy modifier casts to right value",
str_test_5th_element == str_test.get_at(5));
auto str_test_5th_element_copy = str_test_5th_element;
test("proxy modifier copy returns the same value",
str_test_5th_element == str_test_5th_element_copy);
}
void test_announce()
{
t_user* u = find_ptr(m_users, 1);
Ctracker_input i;
i.m_info_hash = "IHIHIHIHIHIHIHIHIHIH";
memcpy(i.m_peer_id.data(), str_ref("PIPIPIPIPIPIPIPIPIPI"));
i.m_ipa = htonl(0x7f000063);
i.m_port = 54321;
std::cout << srv_insert_peer(i, false, u) << std::endl;
write_db_torrents();
write_db_users();
m_time++;
i.m_uploaded = 1 << 30;
i.m_downloaded = 1 << 20;
std::cout << srv_insert_peer(i, false, u) << std::endl;
write_db_torrents();
write_db_users();
m_time += 3600;
clean_up();
write_db_torrents();
write_db_users();
}
void
yelp_document_give_contents (YelpDocument *document,
const gchar *page_id,
gchar *contents,
const gchar *mime)
{
g_return_if_fail (YELP_IS_DOCUMENT (document));
debug_print (DB_FUNCTION, "entering\n");
debug_print (DB_ARG, " page_id = \"%s\"\n", page_id);
g_mutex_lock (&document->priv->mutex);
hash_replace (document->priv->contents,
page_id,
(gpointer) str_ref (contents));
hash_replace (document->priv->mime_types,
page_id,
g_strdup (mime));
g_mutex_unlock (&document->priv->mutex);
}
static bool_t get_lyrics_step_2(void *buf, int64_t len, void *requri)
{
if (strcmp(state.uri, requri))
{
free(buf);
str_unref(requri);
return FALSE;
}
str_unref(requri);
if(!len)
{
SPRINTF(error, _("Unable to fetch %s"), state.uri);
update_lyrics_window(_("Error"), NULL, error);
free(buf);
return FALSE;
}
char *uri = scrape_uri_from_lyricwiki_search_result(buf, len);
if(!uri)
{
SPRINTF(error, _("Unable to parse %s"), state.uri);
update_lyrics_window(_("Error"), NULL, error);
free(buf);
return FALSE;
}
str_unref(state.uri);
state.uri = uri;
update_lyrics_window(state.title, state.artist, _("Looking for lyrics ..."));
vfs_async_file_get_contents(uri, get_lyrics_step_3, str_ref(state.uri));
free(buf);
return TRUE;
}
static const gchar *
document_read_contents (YelpDocument *document,
const gchar *page_id)
{
gchar *real, *str, **colors;
g_mutex_lock (&document->priv->mutex);
if (page_id != NULL && g_str_has_prefix (page_id, "search=")) {
gchar *tmp, *tmp2, *txt;
GVariant *value;
GVariantIter *iter;
gchar *url, *title, *desc, *icon; /* do not free */
gchar *index_title;
GString *ret = g_string_new ("<html><head><style type='text/css'>");
colors = yelp_settings_get_colors (yelp_settings_get_default ());
g_string_append_printf (ret,
"html { height: 100%%; } "
"body { margin: 0; padding: 0;"
" background-color: %s; color: %s;"
" direction: %s; } "
"div.header { margin-bottom: 1em; } "
"div.trails { "
" margin: 0; padding: 0.2em 12px 0 12px;"
" background-color: %s;"
" border-bottom: solid 1px %s; } "
"div.trail { text-indent: -1em;"
" margin: 0 1em 0.2em 1em; padding: 0; color: %s; } "
"div.body { margin: 0 12px 0 12px; padding: 0 0 12px 0; max-width: 60em; } "
"div, p { margin: 1em 0 0 0; padding: 0; } "
"div:first-child, p:first-child { margin-top: 0; } "
"h1 { margin: 0; padding: 0; color: %s; font-size: 1.44em; } "
"a { color: %s; text-decoration: none; } "
"a.linkdiv { display: block; } "
"div.linkdiv { margin: 0; padding: 0.5em; }"
"a:hover div.linkdiv {"
" outline: solid 1px %s;"
" background: -webkit-gradient(linear, left top, left 80, from(%s), to(%s)); } "
"div.title { margin-bottom: 0.2em; font-weight: bold; } "
"div.desc { margin: 0; color: %s; } "
"</style></head><body><div class='header'>",
colors[YELP_SETTINGS_COLOR_BASE],
colors[YELP_SETTINGS_COLOR_TEXT],
(gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL ? "rtl" : "ltr"),
colors[YELP_SETTINGS_COLOR_GRAY_BASE],
colors[YELP_SETTINGS_COLOR_GRAY_BORDER],
colors[YELP_SETTINGS_COLOR_TEXT_LIGHT],
colors[YELP_SETTINGS_COLOR_TEXT_LIGHT],
colors[YELP_SETTINGS_COLOR_LINK],
colors[YELP_SETTINGS_COLOR_BLUE_BASE],
colors[YELP_SETTINGS_COLOR_BLUE_BASE],
colors[YELP_SETTINGS_COLOR_BASE],
colors[YELP_SETTINGS_COLOR_TEXT_LIGHT]
);
index_title = yelp_storage_get_root_title (yelp_storage_get_default (),
document->priv->doc_uri);
if (index_title != NULL) {
tmp = g_markup_printf_escaped ("<div class='trails'><div class='trail'>"
"<a href='xref:'>%s</a> %s "
"</div></div>",
index_title,
(gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL ? "«" : "»")
);
g_string_append (ret, tmp);
g_free (tmp);
}
g_string_append (ret, "</div><div class='body'>");
g_strfreev (colors);
str = hash_lookup (document->priv->contents, real);
if (str) {
str_ref (str);
g_mutex_unlock (&document->priv->mutex);
return (const gchar *) str;
}
txt = g_uri_unescape_string (page_id + 7, NULL);
tmp2 = g_strdup_printf (_("Search results for “%s”"), txt);
tmp = g_markup_printf_escaped ("<h1>%s</h1>", tmp2);
g_string_append (ret, tmp);
g_free (tmp2);
g_free (tmp);
value = yelp_storage_search (yelp_storage_get_default (),
document->priv->doc_uri,
txt);
iter = g_variant_iter_new (value);
if (g_variant_iter_n_children (iter) == 0) {
if (index_title != NULL) {
gchar *t = g_strdup_printf (_("No matching help pages found in “%s”."), index_title);
tmp = g_markup_printf_escaped ("<p>%s</p>", t);
g_free (t);
}
else {
tmp = g_markup_printf_escaped ("<p>%s</p>",
_("No matching help pages found."));
}
g_string_append (ret, tmp);
g_free (tmp);
}
else {
while (g_variant_iter_loop (iter, "(&s&s&s&s)", &url, &title, &desc, &icon)) {
tmp = g_markup_printf_escaped ("<div><a class='linkdiv' href='%s'><div class='linkdiv'>"
"<div class='title'>%s</div>"
"<div class='desc'>%s</div>"
"</div></a></div>",
url, title, desc);
g_string_append (ret, tmp);
g_free (tmp);
}
}
g_variant_iter_free (iter);
g_variant_unref (value);
if (index_title != NULL)
g_free (index_title);
g_free (txt);
g_string_append (ret, "</div></body></html>");
hash_replace (document->priv->contents, page_id, g_string_free (ret, FALSE));
str = hash_lookup (document->priv->contents, page_id);
str_ref (str);
g_mutex_unlock (&document->priv->mutex);
return (const gchar *) str;
}
real = hash_lookup (document->priv->page_ids, page_id);
str = hash_lookup (document->priv->contents, real);
if (str)
str_ref (str);
g_mutex_unlock (&document->priv->mutex);
return (const gchar *) str;
}
DDS_ContentFilteredTopic DDS_DomainParticipant_create_contentfilteredtopic (
DDS_DomainParticipant dp,
const char *topic_name,
DDS_Topic related_topic,
const char *filter_expr,
DDS_StringSeq *expr_pars)
{
Topic_t *tp;
BCProgram bc_program;
FilteredTopic_t *ftp;
DDS_ReturnCode_t ret;
int error;
static const char ddssql [] = "DDSSQL";
ctrc_begind (DCPS_ID, DCPS_DP_C_FTOP, &dp, sizeof (dp));
ctrc_contd (topic_name, strlen (topic_name) + 1);
ctrc_contd (related_topic, sizeof (DDS_Topic));
ctrc_contd (filter_expr, strlen (filter_expr) + 1);
ctrc_contd (&expr_pars, sizeof (expr_pars));
ctrc_endd ();
prof_start (dcps_create_ftopic);
/* Check some required parameters. */
if (!filter_expr)
return (NULL);
/* Get Domain Participant. */
if (!domain_ptr (dp, 1, NULL)) {
log_printf (DCPS_ID, 0, "create_topic(%s): domain doesn't exist!\r\n", topic_name);
return (NULL);
}
/* Get Original Topic descriptor. */
tp = topic_ptr (related_topic, 1, &ret);
if (!tp || tp->domain != dp) {
lock_release (dp->lock);
return (NULL);
}
#ifdef DDS_SECURITY
/* Check if security policy allows this topic. */
if (check_create_topic (dp->participant.p_permissions, topic_name, NULL)) {
log_printf (DCPS_ID, 0, "create_topic(%s): topic create not allowed!\r\n", topic_name);
lock_release (dp->lock);
return (NULL);
}
#endif
/* Check filter validity. */
ret = sql_parse_filter (tp->type->type_support, filter_expr, &bc_program);
if (ret)
goto free_locks;
/* Check required # of parameters. */
if (expr_pars && DDS_SEQ_LENGTH (*expr_pars) < bc_program.npars)
goto free_program;
/* Create the content-filtered topic. */
ftp = filtered_topic_create (dp, tp, topic_name);
if (!ftp)
goto free_program;
/* Setup filtered topic data. */
ftp->data.filter.expression = str_new_cstr (filter_expr);
if (!ftp->data.filter.expression)
goto free_filtered_topic;
if (expr_pars) {
ftp->data.filter.expression_pars = dcps_new_str_pars (expr_pars, &error);
if (!ftp->data.filter.expression_pars && error)
goto pars_failed;
}
else
ftp->data.filter.expression_pars = NULL;
ftp->data.filter.name = str_ref (ftp->topic.name);
ftp->data.filter.related_name = str_ref (ftp->related->name);
ftp->data.filter.class_name = str_new_cstr (ddssql);
if (!ftp->data.filter.name || !ftp->data.filter.related_name || !ftp->data.filter.class_name)
goto pars_failed;
ftp->data.program = bc_program;
bc_cache_init (&ftp->data.cache);
lock_release (tp->lock);
lock_release (dp->lock);
prof_stop (dcps_create_ftopic, 1);
return (ftp);
pars_failed:
lock_release (tp->lock);
lock_release (dp->lock);
DDS_DomainParticipant_delete_contentfilteredtopic (dp, ftp);
return (NULL);
free_filtered_topic:
filtered_topic_delete (ftp);
free_program:
xfree (bc_program.buffer);
free_locks:
lock_release (tp->lock);
lock_release (dp->lock);
return (NULL);
}
/*
* NAME: parse_grammar()
* DESCRIPTION: check the grammar, return a pre-processed version
*/
string *parse_grammar(string *gram)
{
char buffer[STRINGSZ];
hashtab *ruletab, *strtab;
rschunk *rschunks;
rlchunk *rlchunks;
rule *rgxlist, *strlist, *estrlist, *prodlist, *tmplist, *rr, *rrl;
int token, ruleno, nrgx, nstr, nestr, nprod;
ssizet glen;
unsigned int buflen;
bool nomatch;
rulesym **rs;
rule *rl, **r;
long size;
unsigned int len;
# if MAX_STRLEN > 0xffffffL
if (gram->len > 0xffffffL) {
error("Grammar string too large");
}
# endif
/* initialize */
ruletab = ht_new(PARSERULTABSZ, PARSERULHASHSZ, FALSE);
strtab = ht_new(PARSERULTABSZ, PARSERULHASHSZ, FALSE);
rschunks = (rschunk *) NULL;
rlchunks = (rlchunk *) NULL;
rgxlist = strlist = estrlist = prodlist = tmplist = (rule *) NULL;
nrgx = nstr = nestr = nprod = 0;
size = 17 + 8; /* size of header + start rule */
glen = gram->len;
nomatch = FALSE;
token = gramtok(gram, &glen, buffer, &buflen);
for (ruleno = 1; ; ruleno++) {
switch (token) {
case TOK_TOKSYM:
/*
* token rule definition
*/
r = (rule **) ht_lookup(ruletab, buffer, TRUE);
if (*r != (rule *) NULL) {
if ((*r)->type == RULE_UNKNOWN) {
/* replace unknown rule */
rl = *r;
rl->type = RULE_REGEXP;
size += 4;
nrgx++;
if (rl->alt != (rule *) NULL) {
rl->alt->next = rl->next;
} else {
tmplist = rl->next;
}
if (rl->next != (rule *) NULL) {
rl->next->alt = rl->alt;
}
rl->alt = (rule *) NULL;
rl->next = rgxlist;
rgxlist = rl;
} else if ((*r)->type == RULE_REGEXP) {
/* new alternative regexp */
rl = rl_new(&rlchunks, RULE_REGEXP);
*((*r)->last) = rl;
(*r)->last = &rl->alt;
} else {
sprintf(buffer,
"Rule %d previously defined as production rule",
ruleno);
goto err;
}
} else {
/* new rule */
rl = rl_new(&rlchunks, RULE_REGEXP);
str_ref(rl->symb = str_new(buffer, (long) buflen));
rl->chain.name = rl->symb->text;
rl->chain.next = (hte *) *r;
*r = rl;
size += 4;
nrgx++;
rl->next = rgxlist;
rgxlist = rl;
}
switch (gramtok(gram, &glen, buffer, &buflen)) {
case TOK_REGEXP:
str_ref(rl->u.rgx = str_new(buffer, (long) buflen));
(*r)->num++;
(*r)->len += buflen;
size += buflen + 1;
break;
case TOK_BADREGEXP:
sprintf(buffer, "Rule %d: malformed regular expression",
ruleno);
goto err;
case TOK_TOOBIGRGX:
sprintf(buffer, "Rule %d: regular expression too large",
ruleno);
goto err;
case TOK_SYMBOL:
if (buflen == 7 && strcmp(buffer, "nomatch") == 0) {
if (nomatch) {
sprintf(buffer, "Rule %d: extra nomatch rule", ruleno);
goto err;
}
nomatch = TRUE;
rl->u.rgx = (string *) NULL;
break;
}
/* fall through */
default:
sprintf(buffer, "Rule %d: regular expression expected", ruleno);
goto err;
}
/* next token */
token = gramtok(gram, &glen, buffer, &buflen);
break;
case TOK_PRODSYM:
/*
* production rule definition
*/
r = (rule **) ht_lookup(ruletab, buffer, TRUE);
if (*r != (rule *) NULL) {
if ((*r)->type == RULE_UNKNOWN) {
/* replace unknown rule */
rl = *r;
rl->type = RULE_PROD;
size += 4;
nprod++;
if (rl->alt != (rule *) NULL) {
rl->alt->next = rl->next;
} else {
tmplist = rl->next;
}
if (rl->next != (rule *) NULL) {
rl->next->alt = rl->alt;
}
rl->alt = (rule *) NULL;
rl->next = prodlist;
prodlist = rl;
} else if ((*r)->type == RULE_PROD) {
/* new alternative production */
rl = rl_new(&rlchunks, RULE_PROD);
*((*r)->last) = rl;
(*r)->last = &rl->alt;
} else {
sprintf(buffer, "Rule %d previously defined as token rule",
ruleno);
goto err;
}
} else {
/* new rule */
rl = rl_new(&rlchunks, RULE_PROD);
str_ref(rl->symb = str_new(buffer, (long) buflen));
rl->chain.name = rl->symb->text;
rl->chain.next = (hte *) *r;
*r = rl;
size += 4;
nprod++;
rl->next = prodlist;
prodlist = rl;
}
rr = *r;
rrl = rl;
rs = &rl->u.syms;
len = 0;
for (;;) {
switch (token = gramtok(gram, &glen, buffer, &buflen)) {
case TOK_SYMBOL:
/*
* symbol
*/
r = (rule **) ht_lookup(ruletab, buffer, TRUE);
if (*r == (rule *) NULL) {
/* new unknown rule */
rl = rl_new(&rlchunks, RULE_UNKNOWN);
str_ref(rl->symb = str_new(buffer, (long) buflen));
rl->chain.name = rl->symb->text;
rl->chain.next = (hte *) *r;
*r = rl;
rl->next = tmplist;
if (tmplist != (rule *) NULL) {
tmplist->alt = rl;
}
tmplist = rl;
} else {
/* previously known rule */
rl = *r;
}
*rs = rs_new(&rschunks, rl);
rs = &(*rs)->next;
len += 2;
continue;
case TOK_STRING:
case TOK_ESTRING:
/*
* string
*/
r = (rule **) ht_lookup(strtab, buffer, FALSE);
while (*r != (rule *) NULL) {
if ((*r)->symb->len == buflen &&
memcmp((*r)->symb->text, buffer, buflen) == 0) {
break;
}
r = (rule **) &(*r)->chain.next;
}
if (*r == (rule *) NULL) {
/* new string rule */
rl = rl_new(&rlchunks, RULE_STRING);
str_ref(rl->symb = str_new(buffer, (long) buflen));
rl->chain.name = rl->symb->text;
rl->chain.next = (hte *) *r;
*r = rl;
if (token == TOK_STRING) {
size += 4;
nstr++;
rl->len = gram->len - glen - buflen - 1;
rl->next = strlist;
strlist = rl;
} else {
size += 3 + buflen;
nestr++;
rl->next = estrlist;
estrlist = rl;
}
} else {
/* existing string rule */
rl = *r;
}
*rs = rs_new(&rschunks, rl);
rs = &(*rs)->next;
len += 2;
continue;
case TOK_QUEST:
/*
* ? function
*/
if (gramtok(gram, &glen, buffer, &buflen) != TOK_SYMBOL) {
sprintf(buffer, "Rule %d: function name expected",
ruleno);
goto err;
}
str_ref(rrl->func = str_new(buffer, (long) buflen));
len += buflen + 1;
token = gramtok(gram, &glen, buffer, &buflen);
/* fall through */
default:
break;
}
break;
}
if (len > 255) {
sprintf(buffer, "Rule %d is too long", ruleno);
goto err;
}
rr->num++;
rr->len += len;
size += len + 2;
break;
case TOK_NULL:
/*
* end of grammar
*/
if (tmplist != (rule *) NULL) {
sprintf(buffer, "Undefined symbol %s", tmplist->symb->text);
goto err;
}
if (rgxlist == (rule *) NULL) {
strcpy(buffer, "No tokens");
goto err;
}
if (prodlist == (rule *) NULL) {
strcpy(buffer, "No starting rule");
goto err;
}
if (size > (long) USHRT_MAX) {
strcpy(buffer, "Grammar too large");
goto err;
}
gram = make_grammar(rgxlist, strlist, estrlist, prodlist, nrgx,
nstr, nestr, nprod, size);
rs_clear(rschunks);
rl_clear(rlchunks);
ht_del(strtab);
ht_del(ruletab);
return gram;
case TOK_ERROR:
sprintf(buffer, "Rule %d: bad token", ruleno);
goto err;
case TOK_BADREGEXP:
sprintf(buffer, "Rule %d: malformed regular expression", ruleno);
goto err;
case TOK_TOOBIGRGX:
sprintf(buffer, "Rule %d: regular expression too large", ruleno);
goto err;
case TOK_BADSTRING:
sprintf(buffer, "Rule %d: malformed string constant", ruleno);
goto err;
case TOK_TOOBIGSTR:
sprintf(buffer, "Rule %d: string too long", ruleno);
goto err;
case TOK_TOOBIGSYM:
sprintf(buffer, "Rule %d: symbol too long", ruleno);
goto err;
default:
sprintf(buffer, "Rule %d: unexpected token", ruleno);
goto err;
}
}
err:
rs_clear(rschunks);
rl_clear(rlchunks);
ht_del(strtab);
ht_del(ruletab);
error(buffer);
return NULL;
}
bb_t get_next(str_ref& s, str_ref& a0)
{
if (!s)
return bb_end;
if (s.front() != '[')
{
auto a = std::find(s.begin(), s.end(), '[');
if (a == s.end())
{
a0 = s;
s.clear();
}
else
{
a0 = str_ref(s.begin(), a);
s.set_begin(a);
}
return bb_literal;
}
auto a = std::find(s.begin(), s.end(), ']');
if (a == s.end())
{
a0 = s;
s.clear();
return bb_literal;
}
str_ref tag = { &s[1], a };
s.set_begin(a + 1);
a0.clear();
if (tag == "b")
return bb_bold;
if (tag == "/b")
return bb_bold_close;
if (tag == "center")
return bb_center;
if (tag == "/center")
return bb_center_close;
if (boost::starts_with(tag, "color="))
{
a0 = tag.substr(6);
return bb_color;
}
if (tag == "/color")
return bb_color_close;
if (boost::starts_with(tag, "font=") || tag == "/font")
return bb_none;
if (tag == "i" || tag == "/i")
return bb_none;
if (tag == "img" || tag == "IMG" || tag == "/img" || tag == "/IMG")
return bb_none;
if (boost::starts_with(tag, "img="))
{
a0 = tag.substr(4);
return bb_literal;
}
if (tag == "q" || tag == "quote")
return bb_quote;
if (boost::starts_with(tag, "quote="))
{
a0 = tag.substr(6);
return bb_quote;
}
if (tag == "/q" || tag == "/quote")
return bb_quote_close;
if (tag == "s")
return bb_strike;
if (tag == "/s")
return bb_strike_close;
if (boost::starts_with(tag, "size=") || tag == "/size")
return bb_none;
if (tag == "u")
return bb_underline;
if (tag == "/u")
return bb_underline_close;
if (boost::starts_with(tag, "url="))
{
a0 = tag.substr(4);
return bb_url;
}
if (tag == "/url")
return bb_none;
if (boost::starts_with(tag, "video="))
{
a0 = tag.substr(6);
return bb_video;
}
a0 = tag;
return bb_unknown;
}
void Cdlg_login::OnOK()
{
if (!UpdateData(true))
return;
int selected_game = m_game.GetItemData(m_game.GetCurSel());
int selected_nick = m_user.GetItemData(m_user.GetCurSel());
if (selected_game < 0 || selected_nick < 0)
return;
CWaitCursor wc;
const t_game& game = m_games[selected_game];
const t_nick& nick = m_nicks[selected_nick];
m_edit.Empty();
m_edit += "nick: ";
m_edit += nick.name.c_str();
m_edit += "\r\n";
if (0)
{
m_edit += "serial: ";
m_edit += game.serial.c_str();
m_edit += "\r\n";
}
string host;
int port = 0;
{
strstream msg;
msg << "whereto 0 0 " << (game.gsku << 8) << endl
<< "quit" << endl;
string d;
if (send_recv("servserv.westwood.com", 4005, str_ref(msg.str(), msg.pcount()), d))
{
m_edit += d.c_str();
UpdateData(false);
return;
}
Cmulti_line l0 = d;
while (!l0.empty())
{
Circ_params p = l0.get_next_line('\n');
if (p.p_int(0) != 605)
continue;
Cmulti_line l1 = p[2];
host = l1.get_next_line(' ');
port = l1.get_next_int(' ');
break;
}
}
{
strstream msg;
msg << "cvers 0 " << (game.gsku << 8) << endl
<< "nick " << nick.name << endl
<< "apgar " << nick.password << " 0" << endl;
msg << "serial " << game.serial << endl
<< "user" << endl
<< "privmsg c /names" << endl;
msg << "quit" << endl;
string d;
send_recv(host, port, str_ref(msg.str(), msg.pcount()), d);
m_edit += d.c_str();
}
UpdateData(false);
}
char * playback_get_filename (void)
{
g_return_val_if_fail (playing, NULL);
return str_ref (current_filename);
}
/*
* NAME: data->new_plane()
* DESCRIPTION: create a new dataplane
*/
void d_new_plane(dataspace *data, Int level)
{
dataplane *p;
Uint i;
p = ALLOC(dataplane, 1);
p->level = level;
p->flags = data->plane->flags;
p->schange = data->plane->schange;
p->achange = data->plane->achange;
p->imports = data->plane->imports;
/* copy value information from previous plane */
p->original = (value *) NULL;
p->alocal.arr = (array *) NULL;
p->alocal.plane = p;
p->alocal.data = data;
p->alocal.state = AR_CHANGED;
p->coptab = data->plane->coptab;
if (data->plane->arrays != (arrref *) NULL) {
arrref *a, *b;
p->arrays = ALLOC(arrref, i = data->narrays);
for (a = p->arrays, b = data->plane->arrays; i != 0; a++, b++, --i) {
if (b->arr != (array *) NULL) {
*a = *b;
a->arr->primary = a;
arr_ref(a->arr);
} else {
a->arr = (array *) NULL;
}
}
} else {
p->arrays = (arrref *) NULL;
}
p->achunk = (abchunk *) NULL;
if (data->plane->strings != (strref *) NULL) {
strref *s, *t;
p->strings = ALLOC(strref, i = data->nstrings);
for (s = p->strings, t = data->plane->strings; i != 0; s++, t++, --i) {
if (t->str != (string *) NULL) {
*s = *t;
s->str->primary = s;
str_ref(s->str);
} else {
s->str = (string *) NULL;
}
}
} else {
p->strings = (strref *) NULL;
}
p->prev = data->plane;
data->plane = p;
p->plist = plist;
plist = p;
}
