/* 2106 */
int
abort_empty_line (ELEMENT **current_inout, char *additional_text)
{
ELEMENT *current = *current_inout;
int retval;
ELEMENT *last_child = last_contents_child (current);
if (!additional_text)
additional_text = "";
if (last_child
&& (last_child->type == ET_empty_line
|| last_child->type == ET_empty_line_after_command
|| last_child->type == ET_empty_spaces_before_argument
|| last_child->type == ET_empty_spaces_after_close_brace))
{
debug ("ABORT EMPTY additional text |%s| "
"current |%s|",
additional_text,
last_child->text.text);
text_append (&last_child->text, additional_text);
// FIXME: How and when is this condition exactly met?
if (last_child->text.end == 0) //2121
{
// 'extra' stuff
destroy_element (pop_element_from_contents (current));
}
else if (last_child->type == ET_empty_line) //2132
{
if (begin_paragraph_p (current))
last_child->type = ET_empty_spaces_before_paragraph;
else
destroy_element (pop_element_from_contents (current));
}
else if (last_child->type == ET_empty_line_after_command)
{
last_child->type = ET_empty_spaces_after_command;
}
retval = 1;
}
else
retval = 0;
*current_inout = current;
return retval;
}
void qt_dictionary_destroy(qt_hash h)
{
assert(h);
assert(h->spines);
for (size_t i = 0; i < BASE_SPINE_LENGTH; ++i) {
if (h->base[i].e != NULL) {
if (SPINE_PTR_TEST(h->base[i])) { // spine
destroy_spine(h, SPINE_PTR(h, h->base[i]), h->op_cleanup);
} else { // element
destroy_element(h->base[i].e, h->op_cleanup);
}
}
}
if (h->numspines > 0) {
for (size_t i = 0; i < h->maxspines; ++i) {
if (h->spines[i] != NULL) {
h->numspines--;
qt_free((void *)(h->spines[i])); // XXX should be into a memory pool
if (h->numspines == 0) { break; }
}
}
}
FREE(h->spines, h->maxspines * sizeof(spine_element_t *));
FREE(h, sizeof(qt_dictionary));
}
void node_destroy( mxml_node * n )
{
if ( n != NULL )
{
mxml_node * temp = NULL;
mxml_node * child = n->first_child;
while ( child )
{
temp = child->next;
node_destroy( child );
child = temp;
}
if ( n->extend != NULL && n->type != type_node )
{
switch( n->type )
{
case type_element : destroy_element ( (mxml_element *)n->extend ); break;
case type_attribute : destroy_attribute ( (mxml_attribute *)n->extend ); break;
case type_declaration : destroy_declaration( (mxml_declaration *)n->extend ); break;
case type_document : destroy_document ( (mxml_document *)n->extend ); break;
}
}
free_str( &n->value );
free( n );
}
}
/*! \pre This thread block shall be converged.
*/
__device__
~collective_ptr()
{
destroy_element();
barrier();
destroy_owner();
}
void destroy_list(void) {
struct check_list_element * tmp;
struct check_list_element * del;
if(head){
tmp = head->first;
while(tmp){
del = tmp;
tmp = tmp->next;
destroy_element(del);
}
lock_destroy(&head->list_lock);
shm_free(head);
}
return;
}
static void destroy_spine(qt_dictionary *h,
spine_t *spine,
qt_dict_cleanup_f f)
{
assert(spine);
for (size_t i = 0; i < SPINE_LENGTH; ++i) {
if (spine->elements[i].e != NULL) {
if (SPINE_PTR_TEST(spine->elements[i])) { // spine
destroy_spine(h, SPINE_PTR(h, spine->elements[i]), f);
} else {
destroy_element(spine->elements[i].e, f);
}
}
}
}
void destroy_hash_table(hash_table_t ** hash ,int size)
{
int i = size-1;
hash_table_t * hash_table = *hash;
for (;i>=0;i--) {
int j = hash_table->list[i].curIndex-1;
for (;j>=0;j--) {
destroy_element(*hash_table,i,j);
}
free(hash_table->list[i].elems);
}
free(hash_table->list);
free(hash_table);
*hash = NULL;
}
void
chk_context_close(struct chk_context *ctx)
{
assert(ctx != NULL);
if (iconv_close(ctx->cd) == -1)
warn("iconv_close");
while (ctx->regexlist != NULL) {
struct regex *r = ctx->regexlist->payload;
regfree(r->regex);
free(r->regex);
ctx->regexlist = destroy_element(ctx->regexlist);
free(r);
}
free(ctx);
}
/* Called from 'big_loop' in parser.c. Return 1 if we find menu syntax to
process, otherwise return 0. */
int
handle_menu (ELEMENT **current_inout, char **line_inout)
{
ELEMENT *current = *current_inout;
char *line = *line_inout;
int retval = 1;
// 4052
/* A "*" at the start of a line beginning a menu entry. */
if (*line == '*'
&& current->type == ET_preformatted
&& (current->parent->type == ET_menu_comment
|| current->parent->type == ET_menu_entry_description)
&& current->contents.number > 0
&& last_contents_child(current)->type == ET_empty_line)
{
ELEMENT *star;
debug ("MENU STAR");
abort_empty_line (¤t, 0);
line++; /* Past the '*'. */
star = new_element (ET_menu_star);
text_append (&star->text, "*");
add_to_element_contents (current, star);
/* The ET_menu_star element won't appear in the final tree. */
}
// 4067
/* A space after a "*" at the beginning of a line. */
else if (strchr (whitespace_chars, *line)
&& current->contents.number > 0
&& last_contents_child(current)->type == ET_menu_star)
{
ELEMENT *menu_entry, *leading_text, *entry_name;
int leading_spaces;
debug ("MENU ENTRY (certainly)");
leading_spaces = strspn (line, whitespace_chars);
destroy_element (pop_element_from_contents (current));
if (current->type == ET_preformatted
&& current->parent->type == ET_menu_comment)
{
ELEMENT *menu = current->parent->parent;
/* Remove an empty ET_preformatted, and an empty ET_menu_comment. */
if (current->contents.number == 0)
{
pop_element_from_contents (current->parent);
if (current->parent->contents.number == 0)
{
pop_element_from_contents (menu);
destroy_element (current->parent);
}
destroy_element (current);
}
current = menu;
}
else
{
/* current should be ET_preformatted,
1st parent ET_menu_entry_description,
2nd parent ET_menu_entry,
3rd parent @menu. */
current = current->parent->parent->parent;
}
if (pop_context () != ct_preformatted)
abort (); // bug
menu_entry = new_element (ET_menu_entry);
leading_text = new_element (ET_menu_entry_leading_text);
entry_name = new_element (ET_menu_entry_name);
add_to_element_contents (current, menu_entry);
add_to_element_args (menu_entry, leading_text);
add_to_element_args (menu_entry, entry_name);
current = entry_name;
text_append (&leading_text->text, "*");
text_append_n (&leading_text->text, line, leading_spaces);
line += leading_spaces;
}
// 4116
/* A "*" followed by anything other than a space. */
else if (current->contents.number > 0
&& last_contents_child(current)->type == ET_menu_star)
{
debug ("ABORT MENU STAR");
destroy_element (pop_element_from_contents (current));
}
// 4122
/* After a separator in a menu. */
else if (current->args.number > 0
&& last_args_child (current)->type == ET_menu_entry_separator)
{
ELEMENT *last_child;
char *separator;
last_child = last_args_child (current);
separator = last_child->text.text;
/* Separator is "::". */
if (!strcmp (separator, ":") && *line == ':')
{
text_append (&last_child->text, ":");
line++;
/* Whitespace following the "::" is subsequently appended to
the separator element. */
}
/* A "." not followed by a space. Not a separator. */
else if (!strcmp (separator, ".") && !strchr (whitespace_chars, *line))
{
pop_element_from_args (current);
current = last_args_child (current);
merge_text (current, last_child->text.text);
destroy_element (last_child);
}
else if (strchr (whitespace_chars_except_newline, *line))
{
int n;
n = strspn (line, whitespace_chars_except_newline);
text_append_n (&last_child->text, line, n);
line += n;
}
else if (!strncmp (separator, "::", 2))
{
ELEMENT *entry_name;
debug ("MENU NODE no entry %s", separator);
entry_name = args_child_by_index (current, -2);
/* Change it from ET_menu_entry_name (i.e. the label). */
entry_name->type = ET_menu_entry_node;
current = enter_menu_entry_node (current);
}
/* End of the label. Begin the element for the destination. */
else if (*separator == ':')
{
ELEMENT *entry_node;
debug ("MENU ENTRY %s", separator);
entry_node = new_element (ET_menu_entry_node);
add_to_element_args (current, entry_node);
current = entry_node;
}
else
{
debug ("MENU NODE");
current = enter_menu_entry_node (current);
}
}
else
retval = 0;
*current_inout = current;
*line_inout = line;
return retval;
}
/* Actions to be taken when a whole line of input has been processed */
ELEMENT *
end_line (ELEMENT *current)
{
char *end_command = 0;
enum command_id end_id;
// 2621
/* If empty line, start a new paragraph. */
if (last_contents_child (current)
&& last_contents_child (current)->type == ET_empty_line)
{
debug ("END EMPTY LINE");
if (current->type == ET_paragraph) /* 2625 */
{
ELEMENT *e;
/* Remove empty_line element. */
e = pop_element_from_contents (current);
current = end_paragraph (current);
/* Add empty_line to higher-level element. */
add_to_element_contents (current, e);
}
//else if () // in menu_entry_description
else if (!in_no_paragraph_contexts (current_context ()))
{
current = end_paragraph (current);
}
}
// 2667
/* The end of the line of a menu. */
else if (current->type == ET_menu_entry_name
|| current->type == ET_menu_entry_node)
{
ELEMENT *end_comment;
int empty_menu_entry_node = 0;
if (current->type == ET_menu_entry_node)
{
ELEMENT *last = last_contents_child (current);
if (current->contents.number > 0
&& (last->cmd == CM_c || last->cmd == CM_comment))
{
end_comment = pop_element_from_contents (current);
}
/* If contents empty or is all whitespace. */
if (current->contents.number == 0
|| (current->contents.number == 1
&& last->text.end > 0
&& !last->text.text[strspn (last->text.text,
whitespace_chars)]))
{
empty_menu_entry_node = 1;
if (end_comment)
add_to_element_contents (current, end_comment);
}
}
// 2689
/* Abort the menu entry if there is no destination node given. */
if (empty_menu_entry_node || current->type == ET_menu_entry_name)
{
}
else // 2768
{
debug ("MENU ENTRY END LINE");
current = current->parent;
current = enter_menu_entry_node (current);
if (end_comment)
add_to_element_contents (current, end_comment);
}
}
/* Is it a def line 2778 */
else if (current->parent && current->parent->type == ET_def_line)
{
enum element_type def_command;
if (pop_context () != ct_def)
{
abort ();
}
#if 0
/* current->parent is a ET_def_line, and current->parent->parent
the def command. */
def_command = current->parent->parent->cmd;
// strip a trailing x
parse_def (def_command, current->contents);
#endif
current = current->parent->parent;
current = begin_preformatted (current);
}
// 2872
/* End of a line starting a block. */
else if (current->type == ET_block_line_arg)
{
enum context c;
// pop and check context_stack
c = pop_context ();
if (c != ct_line)
{
// bug
abort ();
}
// 2881
if (current->parent->cmd == CM_multitable)
{
/* Parse prototype row */
// But not @columnfractions, I assume?
}
if (current->parent->cmd == CM_float) // 2943
{
}
current = current->parent; //2965
/* Don't consider empty argument of block @-command as argument,
reparent them as contents. */
if (current->args.list[0]->contents.number > 0
&& current->args.list[0]->contents.list[0]->type
== ET_empty_line_after_command)
{
ELEMENT *e;
e = current->args.list[0]->contents.list[0];
insert_into_contents (current, e, 0);
// TODO: Free lists?
current->args.number = 0;
}
if (command_flags(current) & CF_blockitem) // 2981
{
if (current->cmd == CM_enumerate)
{
}
else if (item_line_command (current->cmd)) // 3002
{
// check command_as_argument registered in 'extra', and
// that it accepts arguments in braces
}
if (current->cmd == CM_itemize) // 3019
{
// check that command_as_argument is alone on the line
}
// check if command_as_argument isn't an accent command
/* 3052 - if no command_as_argument given, default to @bullet for
@itemize, and @asis for @table. */
{
ELEMENT *bi = new_element (ET_before_item);
add_to_element_contents (current, bi);
current = bi;
}
} /* CF_blockitem */
// 3077
if (command_flags(current) & CF_menu)
{
/* Start reading a menu. Processing will continue in
handle_menu in menus.c. */
ELEMENT *menu_comment = new_element (ET_menu_comment);
add_to_element_contents (current, menu_comment);
current = menu_comment;
debug ("MENU COMMENT OPEN");
push_context (ct_preformatted);
}
current = begin_preformatted (current);
}
/* after an "@end verbatim" 3090 */
else if (current->contents.number
&& last_contents_child(current)->type == ET_empty_line_after_command
/* The Perl version gets the command with the 'command' key in 'extra'. */
&& contents_child_by_index(current, -2)
&& contents_child_by_index(current, -2)->cmd == CM_verbatim)
{
// I don't know what this means. raw command is @html etc.?
/*
if we are after a @end verbatim, we must restart a preformatted if needed,
since there is no @end command explicitly associated to raw commands
it won't be done elsewhere.
*/
current = begin_preformatted (current);
}
/* if it's a misc line arg 3100 */
else if (current->type == ET_misc_line_arg)
{
int cmd_id, arg_type;
enum context c;
isolate_last_space (current, 0);
current = current->parent;
cmd_id = current->cmd;
if (!cmd_id)
abort ();
arg_type = command_data(cmd_id).data;
/* Check 'line' is top of the context stack */
c = pop_context ();
if (c != ct_line)
{
/* error */
abort ();
}
// 3114
debug ("MISC END %s", command_data(cmd_id).cmdname);
if (arg_type > 0)
{
/* arg_type is number of args */
// parse_line_command_args
// save in 'misc_args' extra key
}
else if (arg_type == MISC_text) /* 3118 */
{
char *text;
/* argument string has to be parsed as Texinfo. This calls convert in
Common/Text.pm on the first element of current->args. */
/* however, this makes it impossible to decouple the parser and
output stages... Any use of Texinfo::Convert is problematic. */
if (current->args.number > 0)
text = text_convert (current->args.list[0]);
else
text = "foo";
if (!strcmp (text, ""))
{
/* 3123 warning - missing argument */
abort ();
}
else
{
if (current->cmd == CM_end) /* 3128 */
{
char *line = text;
/* Set end_command - used below. */
end_command = read_command_name (&line);
/* Check argument meets format of a Texinfo command
(alphanumberic character followed by alphanumeric
characters or hyphens. */
/* Check if argument is a block Texinfo command. */
end_id = lookup_command (end_command);
if (end_id == -1 || !(command_data(end_id).flags & CF_block))
{
/* error - unknown @end */
}
else
{
debug ("END BLOCK %s", end_command);
/* 3140 Handle conditional block commands (e.g.
@ifinfo) */
/* If we are in a non-ignored conditional, there is not
an element for the block in the tree; it is recorded
in the conditional stack. Pop it and check it is the
same as the one given in the @end line. */
if (command_data(end_id).data == BLOCK_conditional)
{
if (conditional_number > 0)
{
enum command_id popped;
popped = pop_conditional_stack ();
if (popped != end_id)
abort ();
}
}
}
}
else if (current->cmd == CM_include) /* 3166 */
{
debug ("Include %s", text);
input_push_file (text);
}
else if (current->cmd == CM_documentencoding)
/* 3190 */
{
}
else if (current->cmd == CM_documentlanguage)
/* 3223 */
{
}
}
}
else if (current->cmd == CM_node) /* 3235 */
{
int i;
ELEMENT *arg;
ELEMENT *first_arg;
/* Construct 'nodes_manuals' array. This would be an 'extra'
reference to an array that doesn't exist anywhere else. */
/* This sets the 'node_content' and 'normalized' keys on each element
in 'nodes_manuals'. */
//parse_node_manual ();
/* In Perl a copy of the argument list is taken and the empty space
arguments are removed with trim_spaces_comment_from_content. */
first_arg = current->args.list[0];
arg = new_element (ET_NONE);
arg->parent_type = route_not_in_tree;
for (i = 0; i < first_arg->contents.number; i++)
{
if (first_arg->contents.list[i]->type
!= ET_empty_spaces_after_command
&& first_arg->contents.list[i]->type != ET_spaces_at_end)
{
/* FIXME: Is this safe to serialize? */
/* For example, if there are extra keys in the elements under
each argument? They may not be set in a copy.
Hopefully there aren't many extra keys set on commands in
node names. */
add_to_element_contents (arg, first_arg->contents.list[i]);
}
}
add_extra_key_contents (current, "node_content", arg);
/* Also set 'normalized' here. The normalized labels are actually
the keys of "labels_information($parser)". */
/*Check that the node name doesn't have a filename element for
referring to an external manual (_check_internal_node), and that it
is not empty (_check_empty_node). */
//check_node_label ();
/* This sets 'node_content' and 'normalized' on the node, among
other things (which were already set in parse_node_manual). */
register_label (current, arg);
current_node = current;
}
else if (current->cmd == CM_listoffloats) /* 3248 */
{
}
else
{
/* All the other "line" commands" */
}
current = current->parent; /* 3285 */
if (end_command) /* Set above */
{
/* more processing of @end */
ELEMENT *end_elt;
debug ("END COMMAND %s", end_command);
/* Reparent the "@end" element to be a child of the block element. */
end_elt = pop_element_from_contents (current);
/* 3289 If not a conditional */
if (command_data(end_id).data != BLOCK_conditional)
{
ELEMENT *closed_command;
/* This closes tree elements (e.g. paragraphs) until we reach
end_command. It can print an error if another block command
is found first. */
current = close_commands (current, end_id,
&closed_command, 0); /* 3292 */
if (!closed_command)
abort (); // 3335
close_command_cleanup (closed_command);
// 3301 INLINE_INSERTCOPYING
add_to_element_contents (closed_command, end_elt); // 3321
// 3324 ET_menu_comment
if (close_preformatted_command (end_id))
current = begin_preformatted (current);
}
} /* 3340 */
else
{
if (close_preformatted_command (cmd_id))
current = begin_preformatted (current);
}
/* 3346 included file */
/* 3350 */
if (cmd_id == CM_setfilename && (current_node || current_section))
{
/* warning */
abort ();
}
/* 3355 columnfractions */
else if (cmd_id == CM_columnfractions)
{
ELEMENT *before_item;
// check if in multitable
// pop and check context stack
current = current->parent;
before_item = new_element (ET_before_item);
add_to_element_contents (current, before_item);
current = before_item;
}
else if (command_data(cmd_id).flags & CF_root) /* 3380 */
{
current = last_contents_child (current);
/* 3383 Destroy all contents (why do we do this?) */
while (last_contents_child (current))
destroy_element (pop_element_from_contents (current));
/* Set 'associated_section' extra key for a node. */
if (cmd_id != CM_node && cmd_id != CM_part)
{
if (current_node)
{
if (!lookup_extra_key (current_node, "associated_section"))
{
add_extra_key_element
(current_node, "associated_section", current);
add_extra_key_element
(current, "associated_node", current_node);
}
}
// "current parts" - 3394
current_section = current;
}
} /* 3416 */
}
// something to do with an empty line /* 3419 */
//if () /* 'line' or 'def' at top of "context stack" */
{
/* Recurse. */
}
return current;
} /* end_line 3487 */