void ft_link(t_list **list, char *str)
{
t_list *it;
if (*list == NULL)
*list = new_link(str);
else
{
it = *list;
while (it->next != NULL)
it = it->next;
it->next = new_link(str);
}
}
static void default_args(t_args *args)
{
t_item *file;
file = new_link(".", NULL, args);
args->items = file;
}
void URDFProperty::addLink()
{
QString name = getValidName("link_", link_names_);
boost::shared_ptr<urdf::Link> new_link(new urdf::Link());
new_link->name = name.toStdString();
model_->links_.insert(std::make_pair(name.toStdString(), new_link));
addLinkProperty(new_link);
}
int main(void) {
int i;
link head, x;
// Population
head = new_link(0);
x = head;
for (i = 1; i < N; ++i) {
x = insert_after(x, new_link(i));
}
// Traversal
for (x = head; x != NULL; x = x->next) {
printf("%i\n", x->item);
}
return 0;
}
int main(int ac, char **av)
{
t_file *myfile;
t_file *next;
t_file *before;
DIR *directory;
char *dirname;
t_dir *dirstruct;
ssize_t ret;
int block;
block = 0;
before = init_list(before);
myfile = init_list(myfile);
myfile = myfile;
myfile->next = before;
dirname = ".";
if (ac > 1)
dirname = ft_strdup(av[1]);
directory = opendir(dirname);
if (errno != 0)
{
if (errno == ENOTDIR)
{
ft_putinfo(myfile, dirname, "", 0);
ft_printinfo(myfile);
}
else
ft_putstr_endl(strerror(errno));
return (-1);
}
if ((ret = readlink(av[1], dirname, 256)) != -1)
{
dirname[ret] = '\0';
return (0);
}
while ((dirstruct = readdir(directory)))
{
before = ft_putinfo(before, dirstruct->d_name, dirname, 0);
block += before->blocks;
//printf("%ld\n",before->laccess.tv_sec);
before = new_link(next, before);
}
printf("total %d\n", block);
myfile = myfile->next;
myfile = sort_time(myfile);
while (myfile->next != NULL)
{
ft_printinfo(myfile);
myfile = myfile->next;
}
closedir(directory);
return (0);
}
static void from_args(t_args *args, char *str)
{
t_item *file;
file = NULL;
file = new_link(str, NULL, args);
if (args->items)
add_link(&(args->items), file, args->options->U);
else
args->items = file;
}
void broadcast(int npc)
{
t_npc *p;
t_anim *a;
t_item *item;
t_list **anims;
p = g_env->npc + npc;
a = new_anim(0, T_BROADCAST * FPS / g_env->time, anim_rock);
item = new_item(g_env->lists[_init_talk], _mod_talk, a, display_any);
anims = &g_env->sq[p->x + p->y * g_env->mapw].anims;
*anims = new_link(*anims, item);
}
void ItemSetBuilder::build_successors(const ItemSet& set) {
// reset
for (auto& item : set.m_closure) item.complete = false;
for (auto& item : set.m_closure) {
if (item.complete) continue;
auto& production = m_grammar.get_production(item.production_id());
auto dot = item.dot();
// skip item whose dot is at right end
if (dot >= production.rhs_count()) {
item.complete = true;
continue;
}
auto& symbol = production[dot + 1]; // symbol after dot
// for each item which has 'symbol' after its dot
for (auto& item2 : set.m_closure) {
if (item2.complete) continue;
auto& production2 = m_grammar.get_production(item2.production_id());
auto dot2 = item2.dot();
if (dot2 >= production2.rhs_count()) {
// 'item2' has no successor
item2.complete = true;
continue;
}
auto& symbol2 = production2[dot2 + 1]; // symbol after dot
if (symbol == symbol2) {
// each item becomes complete after contibuting a successor
item2.complete = true;
auto& add = m_curr_item_set.add_kernel(production2, dot2 + 1);
add.lookaheads().resize(m_grammar.symbol_count());
// add backward propagation link
auto& new_node = new_link();
new_node->next = add.backward_plink();
add.backward_plink() = new_node;
new_node->item = &item2;
}
}
// build set from new kernels
auto& new_set = build_item_set();
if (symbol.type() == SymbolType::NONTERMINAL) {
auto& act = set.add_action(symbol, ActionType::GOTO, new_set.id());
}
else {
auto& act = set.add_action(symbol, ActionType::SHIFT, new_set.id());
assert(act.type != ActionType::SSCONFLICT);
}
}
}
void add_mob(int npc, int x, int y, enum e_dir direc)
{
static GLfloat dir[3] = {0.0, 0.0, 0.0};
static GLfloat vec[3] = {0.0, 0.0, 1.0};
GLfloat pos[3];
t_move *move;
t_rot *rot;
t_anim *anim;
t_square *sq;
t_mob *mob;
set_vecf(pos, (float)x * 2, 0.0, (float)y * 2);
anim = new_anim(rand() % 360, 360, anim_mob);
move = new_move(0, 0, pos, dir);
rot = new_rot(0, vec, 90 * direc, 0);
mob = new_mob(anim, move, rot, npc);
sq = g_env->sq + x + y * g_env->mapw;
g_env->npc[npc].sq = sq;
sq->mobs = new_link(sq->mobs, mob);
}
void AISUpdate::parseLink(const LLSD& link_map)
{
LLUUID item_id = link_map["item_id"].asUUID();
LLPointer<LLViewerInventoryItem> new_link(new LLViewerInventoryItem);
LLViewerInventoryItem *curr_link = gInventory.getItem(item_id);
if (curr_link)
{
// Default to current values where not provided.
new_link->copyViewerItem(curr_link);
}
BOOL rv = new_link->unpackMessage(link_map);
if (rv)
{
const LLUUID& parent_id = new_link->getParentUUID();
if (curr_link)
{
mItemsUpdated[item_id] = new_link;
// This statement is here to cause a new entry with 0
// delta to be created if it does not already exist;
// otherwise has no effect.
mCatDescendentDeltas[parent_id];
}
else
{
LLPermissions default_perms;
default_perms.init(gAgent.getID(),gAgent.getID(),LLUUID::null,LLUUID::null);
default_perms.initMasks(PERM_NONE,PERM_NONE,PERM_NONE,PERM_NONE,PERM_NONE);
new_link->setPermissions(default_perms);
LLSaleInfo default_sale_info;
new_link->setSaleInfo(default_sale_info);
//LL_DEBUGS("Inventory") << "creating link from llsd: " << ll_pretty_print_sd(link_map) << LL_ENDL;
mItemsCreated[item_id] = new_link;
mCatDescendentDeltas[parent_id]++;
}
}
else
{
// *TODO: Wow, harsh. Should we just complain and get out?
LL_ERRS() << "unpack failed" << LL_ENDL;
}
}
void ItemSetBuilder::fill_lookaheads() {
// convert all backward links into forward links
for (auto& set : m_item_sets) {
for (auto& item : set.m_closure) {
for (auto bpl = item.backward_plink(); bpl != nullptr; bpl = bpl->next) {
auto& fpl = bpl->item->forward_plink();
auto& new_node = new_link();
new_node->next = fpl;
fpl = new_node;
new_node->item = &item;
}
}
}
// reset
for (auto& set : m_item_sets) {
for (auto& item : set.m_closure) {
item.complete = false;
}
}
bool not_fin = false;
do {
not_fin = false;
for (auto& set : m_item_sets) {
for (auto& item : set.m_closure) {
if (item.complete) continue;
for (auto fpl = item.forward_plink(); fpl != nullptr; fpl = fpl->next) {
bool change = fpl->item->lookaheads().union_with(item.lookaheads());
if (change) {
fpl->item->complete = false;
not_fin = true;
}
}
item.complete = true;
}
}
} while (not_fin);
}
void start(char *line, char ***env)
{
int i;
t_line *tree;
char **split;
if (line && line[0])
{
i = 0;
split = ft_strsplit(line, ';');
while (split[i])
{
tree = new_link(0, NULL);
manage_line(split[i], tree, env);
free_postfix(tree);
i++;
}
free_tab_2d(&split);
}
if (line)
free(line);
}
int insert_in_list(t_list **list, void *data)
{
t_link *link;
t_link *tmp;
if ((*list) == NULL || data == NULL)
return (-1);
if ((link = new_link(data)) == NULL)
return (-1);
if ((*list)->first == NULL)
{
(*list)->first = link;
}
else
{
tmp = (*list)->first;
while (tmp->next != NULL)
{
tmp = tmp->next;
}
tmp->next = link;
}
return (0);
}
void
diy::detail::KDTreeSamplingPartition<Block,Point>::
update_links(Block* b, const diy::ReduceProxy& srp, int dim, int round, int rounds, bool wrap, const Bounds& domain) const
{
auto log = get_logger();
int gid = srp.gid();
int lid = srp.master()->lid(gid);
RCLink* link = static_cast<RCLink*>(srp.master()->link(lid));
// (gid, dir) -> i
std::map<std::pair<int,diy::Direction>, int> link_map;
for (int i = 0; i < link->size(); ++i)
link_map[std::make_pair(link->target(i).gid, link->direction(i))] = i;
// NB: srp.enqueue(..., ...) should match the link
std::vector<float> splits(link->size());
for (int i = 0; i < link->size(); ++i)
{
float split; diy::Direction dir;
int in_gid = link->target(i).gid;
while(srp.incoming(in_gid))
{
srp.dequeue(in_gid, split);
srp.dequeue(in_gid, dir);
// reverse dir
for (int j = 0; j < dim_; ++j)
dir[j] = -dir[j];
int k = link_map[std::make_pair(in_gid, dir)];
log->trace("{} {} {} -> {}", in_gid, dir, split, k);
splits[k] = split;
}
}
RCLink new_link(dim_, link->core(), link->core());
bool lower = !(gid & (1 << (rounds - 1 - round)));
// fill out the new link
for (int i = 0; i < link->size(); ++i)
{
diy::Direction dir = link->direction(i);
//diy::Direction wrap_dir = link->wrap(i); // we don't use existing wrap, but restore it from scratch
if (dir[dim] != 0)
{
if ((dir[dim] < 0 && lower) || (dir[dim] > 0 && !lower))
{
int nbr_gid = divide_gid(link->target(i).gid, !lower, round, rounds);
diy::BlockID nbr = { nbr_gid, srp.assigner().rank(nbr_gid) };
new_link.add_neighbor(nbr);
new_link.add_direction(dir);
Bounds bounds = link->bounds(i);
update_neighbor_bounds(bounds, splits[i], dim, !lower);
new_link.add_bounds(bounds);
if (wrap)
new_link.add_wrap(find_wrap(new_link.bounds(), bounds, domain));
else
new_link.add_wrap(diy::Direction());
}
} else // non-aligned side
{
for (int j = 0; j < 2; ++j)
{
int nbr_gid = divide_gid(link->target(i).gid, j == 0, round, rounds);
Bounds bounds = link->bounds(i);
update_neighbor_bounds(bounds, splits[i], dim, j == 0);
if (intersects(bounds, new_link.bounds(), dim, wrap, domain))
{
diy::BlockID nbr = { nbr_gid, srp.assigner().rank(nbr_gid) };
new_link.add_neighbor(nbr);
new_link.add_direction(dir);
new_link.add_bounds(bounds);
if (wrap)
new_link.add_wrap(find_wrap(new_link.bounds(), bounds, domain));
else
new_link.add_wrap(diy::Direction());
}
}
}
}
// add link to the dual block
int dual_gid = divide_gid(gid, !lower, round, rounds);
diy::BlockID dual = { dual_gid, srp.assigner().rank(dual_gid) };
new_link.add_neighbor(dual);
Bounds nbr_bounds = link->bounds(); // old block bounds
update_neighbor_bounds(nbr_bounds, find_split(new_link.bounds(), nbr_bounds), dim, !lower);
new_link.add_bounds(nbr_bounds);
new_link.add_wrap(diy::Direction()); // dual block cannot be wrapped
if (lower)
{
diy::Direction right;
right[dim] = 1;
new_link.add_direction(right);
} else
{
diy::Direction left;
left[dim] = -1;
new_link.add_direction(left);
}
// update the link; notice that this won't conflict with anything since
// reduce is using its own notion of the link constructed through the
// partners
link->swap(new_link);
}
void put_chars(struct part *p, unsigned char *c, int l)
{
static struct text_attrib_beginning ta_cache = { -1, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };
static int bg_cache;
static int fg_cache;
int bg, fg;
int i;
struct link *link;
struct point *pt;
if (l < 0) overalloc();
/*printf("%d-", p->cx);for (i=0; i<l; i++) printf("%c", c[i]); printf("-\n");sleep(1);*/
while (par_format.align != AL_NO && p->cx == -1 && l && *c == ' ') c++, l--;
if (!l) return;
if (c[0] != ' ' || (c[1] && c[1] != ' ')) {
last_tag_for_newline = (void *)&p->data->tags;
}
if (p->cx < par_format.leftmargin) p->cx = par_format.leftmargin;
if (last_link || last_image || last_form || format.link || format.image || format.form) goto process_link;
no_l:
/*printf("%d %d\n",p->cx, p->cy);*/
if (memcmp(&ta_cache, &format, sizeof(struct text_attrib_beginning))) goto format_change;
bg = bg_cache, fg = fg_cache;
end_format_change:
if (p->cx == par_format.leftmargin && *c == ' ' && par_format.align != AL_NO) c++, l--;
if (p->y < p->cy + 1) p->y = p->cy + 1;
if (nowrap && p->cx + l > rm(par_format)) return;
set_hline(p, p->cx, p->cy, l, c, (((fg&0x08)<<3)|(bg<<3)|(fg&0x07))<<8, 1);
p->cx += l;
nobreak = 0;
if (par_format.align != AL_NO)
while (p->cx > rm(par_format) && p->cx > par_format.leftmargin) {
int x;
/*if (p->cx > p->x) {
p->x = p->cx + par_format.rightmargin;
if (c[l - 1] == ' ') p->x--;
}*/
if (!(x = split_line(p))) break;
/*if (LEN(p->cy-1) > p->x) p->x = LEN(p->cy-1);*/
align_line(p, p->cy - 1);
nobreak = x - 1;
}
if ((p->xa += l) - (c[l-1] == ' ' && par_format.align != AL_NO) + par_format.leftmargin + par_format.rightmargin > p->xmax) p->xmax = p->xa - (c[l-1] == ' ' && par_format.align != AL_NO) + par_format.leftmargin + par_format.rightmargin;
return;
process_link:
if ((last_link /*|| last_target*/ || last_image || last_form) &&
!xstrcmp(format.link, last_link) && !xstrcmp(format.target, last_target) &&
!xstrcmp(format.image, last_image) && format.form == last_form) {
if (!p->data) goto x;
link = &p->data->links[p->data->nlinks - 1];
if (!p->data->nlinks) {
internal("no link");
goto no_l;
}
goto set_link;
x:;
} else {
if (last_link) mem_free(last_link); /* !!! FIXME: optimize */
if (last_target) mem_free(last_target);
if (last_image) mem_free(last_image);
last_link = last_target = last_image = NULL;
last_form = NULL;
if (!(format.link || format.image || format.form)) goto no_l;
if (d_opt->num_links) {
unsigned char s[64];
unsigned char *fl = format.link, *ft = format.target, *fi = format.image;
struct form_control *ff = format.form;
format.link = format.target = format.image = NULL;
format.form = NULL;
s[0] = '[';
snzprint(s + 1, 62, p->link_num);
strcat(s, "]");
put_chars(p, s, strlen(s));
if (ff && ff->type == FC_TEXTAREA) line_break(p);
if (p->cx == -1) p->cx = par_format.leftmargin;
format.link = fl, format.target = ft, format.image = fi;
format.form = ff;
}
p->link_num++;
last_link = stracpy(format.link);
last_target = stracpy(format.target);
last_image = stracpy(format.image);
last_form = format.form;
if (!p->data) goto no_l;
if (!(link = new_link(p->data))) goto no_l;
link->num = p->link_num - 1;
link->pos = DUMMY;
if (!last_form) {
link->type = L_LINK;
link->where = stracpy(last_link);
link->target = stracpy(last_target);
} else {
link->type = last_form->type == FC_TEXT || last_form->type == FC_PASSWORD || last_form->type == FC_FILE ? L_FIELD : last_form->type == FC_TEXTAREA ? L_AREA : last_form->type == FC_CHECKBOX || last_form->type == FC_RADIO ? L_CHECKBOX : last_form->type == FC_SELECT ? L_SELECT : L_BUTTON;
link->form = last_form;
link->target = stracpy(last_form->target);
}
link->where_img = stracpy(last_image);
if (link->type != L_FIELD && link->type != L_AREA) {
bg = find_nearest_color(&format.clink, 8);
fg = find_nearest_color(&format.bg, 8);
fg = fg_color(fg, bg);
} else {
fg = find_nearest_color(&format.fg, 8);
bg = find_nearest_color(&format.bg, 8);
fg = fg_color(fg, bg);
}
link->sel_color = ((fg & 8) << 3) | (fg & 7) | (bg << 3);
link->n = 0;
set_link:
if ((unsigned)link->n + (unsigned)l > MAXINT / sizeof(struct point)) overalloc();
pt = mem_realloc(link->pos, (link->n + l) * sizeof(struct point));
link->pos = pt;
for (i = 0; i < l; i++) pt[link->n + i].x = X(p->cx) + i,
pt[link->n + i].y = Y(p->cy);
link->n += l;
}
goto no_l;
format_change:
bg = find_nearest_color(&format.bg, 8);
fg = find_nearest_color(&format.fg, 16);
fg = fg_color(fg, bg);
if (format.attr & AT_ITALIC) fg = fg ^ 0x01;
if (format.attr & AT_UNDERLINE) fg = (fg ^ 0x04) | 0x08;
if (format.attr & AT_BOLD) fg = fg | 0x08;
fg = fg_color(fg, bg);
if (format.attr & AT_GRAPHICS) bg = bg | 0x10;
memcpy(&ta_cache, &format, sizeof(struct text_attrib_beginning));
fg_cache = fg; bg_cache = bg;
goto end_format_change;
}
void g_put_chars(struct g_part *p, unsigned char *s, int l)
{
struct g_object_text *t = NULL;
struct link *link;
if (putchars_link_ptr) {
link = NULL;
goto check_link;
}
while (par_format.align != AL_NO && p->cx == -1 && l && *s == ' ') s++, l--;
if (!l) return;
g_nobreak = 0;
if (p->cx < par_format.leftmargin * G_HTML_MARGIN) p->cx = par_format.leftmargin * G_HTML_MARGIN;
if (html_format_changed) {
if (memcmp(&ta_cache, &format, sizeof(struct text_attrib_beginning)) || xstrcmp(cached_font_face, format.fontface) || cached_font_face == to_je_ale_prasarna ||
xstrcmp(format.link, last_link) || xstrcmp(format.target, last_target) ||
xstrcmp(format.image, last_image) || format.form != last_form
|| ((format.js_event || last_js_event) && compare_js_event_spec(format.js_event, last_js_event)) ) {
/*if (!html_format_changed) internal("html_format_changed not set");*/
flush_pending_text_to_line(p);
if (xstrcmp(cached_font_face, format.fontface) || cached_font_face == to_je_ale_prasarna) {
if (cached_font_face && cached_font_face != to_je_ale_prasarna) mem_free(cached_font_face);
cached_font_face = stracpy(format.fontface);
}
memcpy(&ta_cache, &format, sizeof(struct text_attrib_beginning));
if (p->current_style) g_free_style(p->current_style);
p->current_style = get_style_by_ta(&format);
}
html_format_changed = 0;
}
/*if (p->cx <= par_format.leftmargin * G_HTML_MARGIN && *s == ' ' && par_format.align != AL_NO) s++, l--;*/
if (!p->text) {
link = NULL;
t = mem_calloc(sizeof(struct g_object_text) + ALLOC_GR);
t->mouse_event = g_text_mouse;
t->draw = g_text_draw;
t->destruct = g_text_destruct;
t->get_list = NULL;
/*t->style = get_style_by_ta(format);*/
t->style = g_clone_style(p->current_style);
t->bg = NULL; /* FIXME!!! */
t->yw = t->style->height;
/*t->xw = 0;
t->y = 0;*/
if (format.baseline) {
if (format.baseline < 0) t->y = -(t->style->height / 3);
if (format.baseline > 0) t->y = get_real_font_size(format.baseline) - (t->style->height / 2);
}
check_link:
if (last_link || last_image || last_form || format.link || format.image || format.form
|| format.js_event || last_js_event
) goto process_link;
back_link:
if (putchars_link_ptr) {
*putchars_link_ptr = link;
return;
}
if (!link) t->link_num = -1;
else {
t->link_num = link - p->data->links;
t->link_order = link->obj_order++;
}
t->text[0] = 0;
p->pending_text_len = 0;
p->text = t;
}
if (p->pending_text_len == -1) {
p->pending_text_len = strlen(p->text->text);
goto a1;
}
if ((p->pending_text_len & ~(ALLOC_GR - 1)) != ((p->pending_text_len + l) & ~(ALLOC_GR - 1))) a1:{
struct g_object_text *t;
if ((unsigned)l > MAXINT) overalloc();
if ((unsigned)p->pending_text_len + (unsigned)l > MAXINT - ALLOC_GR) overalloc();
t = mem_realloc(p->text, sizeof(struct g_object_text) + ((p->pending_text_len + l + ALLOC_GR) & ~(ALLOC_GR - 1)));
if (p->w.last_wrap >= p->text->text && p->w.last_wrap < p->text->text + p->pending_text_len) p->w.last_wrap += (unsigned char *)t - (unsigned char *)p->text;
if (p->w.last_wrap_obj == p->text) p->w.last_wrap_obj = t;
p->text = t;
}
memcpy(p->text->text + p->pending_text_len, s, l), p->text->text[p->pending_text_len += l] = 0;
p->text->xw += g_text_width(p->text->style, p->text->text + p->pending_text_len - l); /* !!! FIXME: move to g_wrap_text */
if (par_format.align != AL_NO) {
p->w.text = p->text->text + p->pending_text_len - l;
p->w.style = p->text->style;
p->w.obj = p->text;
p->w.width = rm(par_format) - par_format.leftmargin * G_HTML_MARGIN;
if (p->w.width < 0) p->w.width = 0;
if (!g_wrap_text(&p->w)) {
split_line_object(p, p->w.last_wrap_obj, p->w.last_wrap);
}
}
return;
/* !!! WARNING: THE FOLLOWING CODE IS SHADOWED IN HTML_R.C */
process_link:
if ((last_link /*|| last_target*/ || last_image || last_form) &&
!putchars_link_ptr &&
!xstrcmp(format.link, last_link) && !xstrcmp(format.target, last_target) &&
!xstrcmp(format.image, last_image) && format.form == last_form
&& ((!format.js_event && !last_js_event) || !compare_js_event_spec(format.js_event, last_js_event))) {
if (!p->data) goto back_link;
if (!p->data->nlinks) {
internal("no link");
goto back_link;
}
link = &p->data->links[p->data->nlinks - 1];
goto back_link;
} else {
if (last_link) mem_free(last_link);
if (last_target) mem_free(last_target);
if (last_image) mem_free(last_image);
free_js_event_spec(last_js_event);
last_link = last_target = last_image = NULL;
last_form = NULL;
last_js_event = NULL;
if (!(format.link || format.image || format.form || format.js_event)) goto back_link;
/*if (d_opt->num_links) {
unsigned char s[64];
unsigned char *fl = format.link, *ft = format.target, *fi = format.image;
struct form_control *ff = format.form;
struct js_event_spec *js = format.js_event;
format.link = format.target = format.image = NULL;
format.form = NULL;
format.js_event = NULL;
s[0] = '[';
snzprint(s + 1, 62, p->link_num);
strcat(s, "]");
g_put_chars(p, s, strlen(s));
if (ff && ff->type == FC_TEXTAREA) g_line_break(p);
if (p->cx < par_format.leftmargin * G_HTML_MARGIN) p->cx = par_format.leftmargin * G_HTML_MARGIN;
format.link = fl, format.target = ft, format.image = fi;
format.form = ff;
format.js_event = js;
}*/
p->link_num++;
last_link = stracpy(format.link);
last_target = stracpy(format.target);
last_image = stracpy(format.image);
last_form = format.form;
copy_js_event_spec(&last_js_event, format.js_event);
if (!p->data) goto back_link;
if (!(link = new_link(p->data))) goto back_link;
link->num = p->link_num - 1;
link->pos = DUMMY;
copy_js_event_spec(&link->js_event, format.js_event);
if (!last_form) {
link->type = L_LINK;
link->where = stracpy(last_link);
link->target = stracpy(last_target);
} else {
link->type = last_form->type == FC_TEXT || last_form->type == FC_PASSWORD || last_form->type == FC_FILE ? L_FIELD : last_form->type == FC_TEXTAREA ? L_AREA : last_form->type == FC_CHECKBOX || last_form->type == FC_RADIO ? L_CHECKBOX : last_form->type == FC_SELECT ? L_SELECT : L_BUTTON;
link->form = last_form;
link->target = stracpy(last_form->target);
}
link->where_img = stracpy(last_image);
link->sel_color = 0;
link->n = 0;
}
goto back_link;
}
void do_image(struct g_part *p, struct image_description *im)
{
struct g_object_image *io;
struct link *link;
link = NULL;
putchars_link_ptr = &link;
g_put_chars(p, NULL, 0);
putchars_link_ptr = NULL;
if (!link) im->link_num = -1;
else {
im->link_num = link - p->data->links;
im->link_order = link->obj_order++;
if (link->img_alt) mem_free(link->img_alt);
link->img_alt = stracpy(im->alt);
}
io = insert_image(p, im);
if (!io) goto ab;
io->ismap = im->ismap;
add_object(p, (struct g_object *)io);
if (im->usemap && p->data) {
unsigned char *tag = extract_position(im->usemap);
struct additional_file *af = request_additional_file(current_f_data, im->usemap);
af->need_reparse = 1;
if (af->rq && (af->rq->state == O_LOADING || af->rq->state == O_INCOMPLETE || af->rq->state == O_OK) && af->rq->ce) {
struct memory_list *ml;
struct menu_item *menu;
struct cache_entry *ce = af->rq->ce;
unsigned char *start, *end;
int i;
struct image_map *map;
get_file(af->rq, &start, &end);
if (start == end) goto ft;
if (get_image_map(ce->head, start, end, tag, &menu, &ml, format.href_base, format.target_base, 0, 0, 0, 1)) goto ft;
map = mem_alloc(sizeof(struct image_map));
map->n_areas = 0;
for (i = 0; menu[i].text; i++) {
struct link_def *ld = menu[i].data;
struct map_area *a;
struct link *link;
int shape = !ld->shape || !*ld->shape ? SHAPE_RECT : !strcasecmp(ld->shape, "default") ? SHAPE_DEFAULT : !strcasecmp(ld->shape, "rect") ? SHAPE_RECT : !strcasecmp(ld->shape, "circle") ? SHAPE_CIRCLE : !strcasecmp(ld->shape, "poly") || !strcasecmp(ld->shape, "polygon") ? SHAPE_POLY : -1;
if (shape == -1) continue;
if ((unsigned)map->n_areas > (MAXINT - sizeof(struct image_map)) / sizeof(struct map_area) - 1) overalloc();
map = mem_realloc(map, sizeof(struct image_map) + (map->n_areas + 1) * sizeof(struct map_area));
a = &map->area[map->n_areas++];
a->shape = shape;
a->coords = DUMMY;
a->ncoords = 0;
if (ld->coords) {
unsigned char *p = ld->coords;
int num;
next_coord:
num = 0;
while (*p && (*p < '0' || *p > '9')) p++;
if (!*p) goto noc;
while (*p >= '0' && *p <= '9' && num < 10000000) num = num * 10 + *p - '0', p++;
if (*p == '.') {
p++;
while (*p >= '0' && *p <= '9') p++;
}
if (*p == '%' && num < 1000) {
int m = io->xw < io->yw ? io->xw : io->yw;
num = num * m / 100;
p++;
} else num = num * d_opt->image_scale / 100;
if ((unsigned)a->ncoords > MAXINT / sizeof(int) - 1) overalloc();
a->coords = mem_realloc(a->coords, (a->ncoords + 1) * sizeof(int));
a->coords[a->ncoords++] = num;
goto next_coord;
}
noc:
if (!(link = new_link(p->data))) a->link_num = -1;
else {
link->pos = DUMMY;
link->type = L_LINK;
link->where = stracpy(ld->link);
link->target = stracpy(ld->target);
link->img_alt = stracpy(ld->label);
link->where_img = stracpy(im->url);
#ifdef JS
if (ld->onclick || ld->ondblclick || ld->onmousedown || ld->onmouseup || ld->onmouseover || ld->onmouseout || ld->onmousemove) {
create_js_event_spec(&link->js_event);
link->js_event->click_code = stracpy(ld->onclick);
link->js_event->dbl_code = stracpy(ld->ondblclick);
link->js_event->down_code = stracpy(ld->onmousedown);
link->js_event->up_code = stracpy(ld->onmouseup);
link->js_event->over_code = stracpy(ld->onmouseover);
link->js_event->out_code = stracpy(ld->onmouseout);
link->js_event->move_code = stracpy(ld->onmousemove);
}
#endif
a->link_num = link - p->data->links;
}
if (last_link) mem_free(last_link), last_link = NULL;
}
io->map = map;
freeml(ml);
ft:;
}
if (tag) mem_free(tag);
}
ab:
if (im->usemap) mem_free(im->usemap);
}
