Esempio n. 1
0
tnetwork_transmission::tnetwork_transmission(
		connection_data& connection,
		const std::string& title,
		const std::string& subtitle)
	: connection_(&connection)
	, pump_monitor_(connection_)
	, subtitle_(subtitle)
{
	register_label("title", true, title, false);
	set_restore(true);
}
Esempio n. 2
0
tnetwork_transmission::tnetwork_transmission(
		network_asio::connection& connection,
		const std::string& title,
		const std::string& subtitle)
	: connection_(connection)
	, track_upload_(false)
	, pump_monitor_(connection, track_upload_)
	, subtitle_(subtitle)
{
	register_label("title", true, title, false);
}
Esempio n. 3
0
tmp_cmd_wrapper::tmp_cmd_wrapper(const t_string& user)
	: message_()
	, reason_()
	, time_()
{
	register_text("message", false, message_, true);
	register_text("reason", false, reason_);
	register_text("time", false, time_);
	register_label("user_label", false, user);

	set_always_save_fields(true);
}
Esempio n. 4
0
tmp_depcheck_confirm_change::tmp_depcheck_confirm_change
			(bool action,
			 const std::vector<std::string>& mods,
			 const std::string&	requester)
{
	utils::string_map symbols;
	symbols["requester"] = requester;
	std::string message;
	if (action) {
		message = vgettext("$requester requires the following modifications to be enabled:", symbols);
	} else {
		message = vgettext("$requester requires the following modifications to be disabled:", symbols);
	}

	std::string list = "\t";
	list += utils::join(mods, "\n\t");

	register_label("message", false, message);

	register_label("itemlist", false, list);
}
tscreenshot_notification::tscreenshot_notification(const std::string& path)
	: path_(path), screenshots_dir_path_(filesystem::get_screenshot_dir())
{
	const int filesize = filesystem::file_size(path);

	const std::string sizetext
			= filesize >= 0
			? utils::si_string(filesize, true, _("unit_byte^B"))
			: _("file_size^Unknown");

	register_label("filesize",
				   false,
				   sizetext,
				   false);
}
Esempio n. 6
0
tmp_login::tmp_login(const std::string& label, const bool focus_password)
{
	register_label("login_label", false, label);
	register_text("user_name"
			, true
			, &preferences::login
			, &preferences::set_login
			, !focus_password);

	register_text("password"
			, true
			, &preferences::password
			, NULL /* The password box returns '*' as value. */
			, focus_password);

	register_bool("remember_password"
			, false
			, &preferences::remember_password
			, &preferences::set_remember_password);
}
Esempio n. 7
0
teditor_edit_side::teditor_edit_side(int side,
									 std::string& id,
									 std::string& name,
									 int& gold,
									 int& income,
									 int& village_income,
									 int& village_support,
									 bool& fog,
									 bool& share_view,
									 bool& shroud,
									 bool& share_maps,
									 team::CONTROLLER& controller,
									 int controller_num,
									 bool& no_leader,
									 bool& hidden)
	: controller_(controller)
{
	std::stringstream side_stream;
	side_stream << side;
	register_label("side_number", true, side_stream.str(), true);

	register_text("team_name", true, id, true);
	register_text("user_team_name", true, name, true);

	register_integer("gold", true, gold);
	register_integer("income", true, income);

	register_integer("village_income", true, village_income);
	register_integer("village_support", true, village_support);

	register_integer("controller_number_player", true, controller_num);

	register_bool("fog", true, fog);
	register_bool("share_view", true, share_view);

	register_bool("shroud", true, shroud);
	register_bool("share_maps", true, share_maps);

	register_bool("no_leader", true, no_leader);
	register_bool("hidden", true, hidden);
}
Esempio n. 8
0
teditor_edit_side::teditor_edit_side(editor::editor_team_info& info)
	: controller_(info.controller)
	, share_vision_(info.share_vision)
{
	register_label("side_number", true, std::to_string(info.side), true);

	register_text("team_name", true, info.id, true);
	register_text("user_team_name", true, info.name, true);

	register_integer("gold", true, info.gold);
	register_integer("income", true, info.income);

	register_integer("village_income", true, info.village_income);
	register_integer("village_support", true, info.village_support);

	register_bool("fog", true, info.fog);
	register_bool("shroud", true, info.shroud);

	register_bool("no_leader", true, info.no_leader);
	register_bool("hidden", true, info.hidden);
}
Esempio n. 9
0
int assemble(uint32_t *out_buf, char *asm_buf) {
	output_alias = out_buf;

	while (mygets(asm_line, asm_buf, COL_MAX) != NULL) {
		if (set_term0(asm_line, term0) == 1) {
			if (is_comment(asm_line, term0)) {
				// blank(comment)
			} else if (is_directive(asm_line, term0)) {
				exec_directive(asm_line, term0);
			} else if (is_label(asm_line, term0)) {
				register_label(asm_line, term0);
			} else { 
				encode_and_output(asm_line, term0);
			}
		} else {
			// blank(empty line)
		}
		input_line_cnt++;
	}
	resolve_label();
	return output_cnt;
}
Esempio n. 10
0
	/** Registers a new control as image. */
	tfield_label* register_image(const std::string& id,
								 const bool mandatory,
								 const std::string& filename)
	{
		return register_label(id, mandatory, filename);
	}
Esempio n. 11
0
taddon_description::taddon_description(const std::string& addon_id,
									   const addons_list& addons_list,
									   const addons_tracking_list& addon_states)
	: feedback_url_()
{
	const addon_info& addon = const_at(addon_id, addons_list);
	const addon_tracking_info& state = const_at(addon_id, addon_states);

	const std::string& created_text = format_addon_time(addon.created);
	const std::string& updated_text = format_addon_time(addon.updated);

	register_label("image", true, addon.display_icon());
	register_label("title", true, addon.title);
	register_label("version", true, addon.version);
	register_label("status", true, describe_addon_state_info(state), true);
	register_label("author", true, addon.author);
	register_label("type", true, addon.display_type());
	register_label("size", true, size_display_string(addon.size));
	register_label("downloads", true, std::to_string(addon.downloads));
	register_label("created", true, created_text);
	register_label("updated", true, updated_text);
	if(!addon.description.empty()) {
		register_label("description", true, addon.description);
	}
	if(!addon.depends.empty()) {
		register_label(
				"dependencies",
				true,
				make_display_dependencies(addon_id, addons_list, addon_states),
				true);
	}

	feedback_url_ = addon.feedback_url;

	std::string languages;

	for(const auto & lc : addon.locales)
	{
		const std::string& langlabel = langcode_to_string(lc);
		if(!langlabel.empty()) {
			if(!languages.empty()) {
				languages += ", ";
			}
			languages += langlabel;
		}
	}

	if(!languages.empty()) {
		register_label("translations", true, languages);
	}
}
Esempio n. 12
0
tgame_save::tgame_save(std::string& filename, const std::string& title)
{
	register_text("txtFilename", false, filename, true);
	register_label("lblTitle", true, title);
}
Esempio n. 13
0
/*
 *	assemble a file and load into memory
 */
Assembly* parse_file(FILE* file) {
	Assembly* assembly;					/* assembly structure */
	int labelid;								/* new label id */
	Segment* current_segment;		/* holds current segment */
	char line[MAX_LINE];				/* holds one line */
	char* items[MAX_ARGS];			/* split line into items (split on ' ' and '\t') */
	int segment;								/* holds current segment id */
	int count, i, size;					/* loop variables */
	long long params[MAX_ARGS];	/* parsed items array */
	char sbuffer[1024];					/* 1K string buffer */
	char* sourcefile;						/* current source file */
	Label* label;
	
	/* initialize variables */
	assembly = new_assembly();
	labelid = 0;
	
	linenr = 0;
	segment = UNKNOWN;
	sourcefile = NULL;
	
	/* read a line lines (returns nr of characters read, -1 if eof) */
	while(read_line(file, line, MAX_LINE) >= 0) {
		linenr++;
		/* get rid of spaces/tabs in front of the line */
		trim_line(line);

		/* split the line on spaces/tabs */
		count = split_line(line, items);
		/* note: line == items[0] */
		
		/* check if the line was not empty */
		if (strlen(line) > 0) {
			if (strcmp(line, "code") == 0) {
				/* code segment */
				segment = CODE;
				current_segment = assembly->code;
			} else if (strcmp(line, "bss") == 0) {
				/* bss segment */
				segment = BSS;
				/* bss has no segment structure */
				/* (no point in saving uninitialized data */
				current_segment = 0;
			} else if (strcmp(line, "lit") == 0) {
				/* lit segment */
				segment = LIT;
				current_segment = assembly->lit;
			} else if (strcmp(line, "data") == 0) {
				/* data segment */
				segment = DATA;
				current_segment = assembly->data;
			} else if (strcmp(line, "export") == 0) {
				/* mark label as public */
				if (count != 2) error(linenr, "invalid number of parameters");
				label = get_label(assembly, items[1]);
				/* any exported function should be included */
				label->accessed = 1;
				label->exported = TRUE;
			} else if (strcmp(line, "import") == 0) {
				/* mark label as imported */
				if (count != 2) error(linenr, "invalid number of parameters");
				get_label(assembly, items[1])->imported = TRUE;
			} else if (segment == UNKNOWN) {
				/* all other things must be in segments */
				error(linenr, "code outside segment");
			} else if (strcmp(line, "align") == 0) {
				/* align a segment */
				if (count != 2) error(linenr, "invalid number of parameters");
				params[0] = parse_numeric(items[1]);
				if (segment == BSS) {
					/* align bss just by size */
					while(assembly->bss_size % params[0]) assembly->bss_size++;
				} else {
					align_segment(current_segment, params[0]);
				}
			}	else if (strcmp(line, "byte") == 0) {
				/* one byte of data */
				if (count != 3) error(linenr, "invalid number of parameters");
				if (segment == BSS) {
					error(linenr, "can't put initialized data in bss, use data segment instead");
				} else {
					/* parse */
					params[0] = parse_numeric(items[1]);
					params[1] = parse_numeric(items[2]);
					/* write to segment */
					MS_WriteBE(current_segment->data, params[1], (int)params[0]);
					for (i = 0; i < (int)params[0]; i++) MS_WriteBit(current_segment->mask, FALSE);
				}
			}	else if (strcmp(line, "skip") == 0) {
				/* some empty space */
				if (count != 2) error(linenr, "invalid number of parameters");
				/* parse */
				params[0] = parse_numeric(items[1]);
				if (segment == BSS) {
					/* for bss: just update the size */
					assembly->bss_size += params[0];
				} else {
					/* for other segment: write zeros */
					MS_Write(current_segment->data, 0, (int)params[0]);
					for (i = 0; i < (int)params[0]; i++) MS_WriteBit(current_segment->mask, FALSE);
				}
			} else if (strcmp(line, "address") == 0) {
				/* insert address to label here */

				/* some empty space */
				if (count != 2) error(linenr, "invalid number of parameters");
				/* write the id to the current segment */
				MS_WriteBE(current_segment->data, get_label(assembly, items[1])->id, PTR_SIZE);
				/* needs to be resolved */
				for (i = 0; i < PTR_SIZE; i++) MS_WriteBit(current_segment->mask, TRUE);
			} else if (strcmp(line, "line") == 0) {
				if (count < 2) error(linenr, "invalid number of parameters");
				if (sourcefile == NULL) error(linenr, "file directive must precede line directive");

				size = sprintf(sbuffer, "$%s:", sourcefile);
				for (i = 1; i < count; i++) {
					size += sprintf(sbuffer+size, "%s", items[i]);
					if (i == count-1) {
						sbuffer[size++] = 0;
					} else {
						sbuffer[size++] = ' ';
					}
				}
				
				/* register debug label */
				label = get_label(assembly, sbuffer);
				if (label->segment == UNKNOWN) {
					if (segment == BSS) {
						label->location = assembly->bss_size;
					} else {
						label->location = current_segment->data->size;
					}
					label->segment = segment;
				}
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_LINE;
			} else if (strcmp(line, "file") == 0) {
				if (count < 2) error(linenr, "invalid number of parameters");

				size = sprintf(sbuffer, "$");
				for (i = 1; i < count; i++) {
					size += sprintf(sbuffer+size, "%s", items[i]);
					if (i == count-1) {
						sbuffer[size++] = 0;
					} else {
						sbuffer[size++] = ' ';
					}
				}

				if (sourcefile != NULL) free(sourcefile);
				sourcefile = malloc(size-1);
				strcpy(sourcefile, sbuffer+1);
				
				/* register debug label */
				label = get_label(assembly, sbuffer);
				if (segment == BSS) {
					label->location = assembly->bss_size;
				} else {
					label->location = current_segment->data->size;
				}
				label->segment = segment;
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_FILE;
			} else if (strcmp(line, "local") == 0) {
				if (count < 3) error(linenr, "invalid number of parameters");

				size = sprintf(sbuffer, "$");
				for (i = 1; i < count; i++) {
					if (i != 2) {
						size += sprintf(sbuffer+size, "%s", items[i]);
						if (i == count-1) {
							sbuffer[size++] = 0;
						} else {
							sbuffer[size++] = ' ';
						}
					}
				}
				
				/* register debug label */
				label = get_label(assembly, sbuffer);
				label->location = parse_numeric(items[2]);				

				label->segment = UNKNOWN;
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_LOCAL;
			} else if (strcmp(line, "param") == 0) {
				if (count < 3) error(linenr, "invalid number of parameters");

				size = sprintf(sbuffer, "$");
				for (i = 1; i < count; i++) {
					if (i != 2) {
						size += sprintf(sbuffer+size, "%s", items[i]);
						if (i == count-1) {
							sbuffer[size++] = 0;
						} else {
							sbuffer[size++] = ' ';
						}
					}
				}
				
				/* register debug label */
				label = get_label(assembly, sbuffer);
				label->location = parse_numeric(items[2]);
				label->segment = UNKNOWN;
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_PARAM;
			} else if (strcmp(line, "global") == 0) {
				if (count < 2) error(linenr, "invalid number of parameters");

				size = sprintf(sbuffer, "$");
				for (i = 1; i < count; i++) {
					size += sprintf(sbuffer+size, "%s", items[i]);
					if (i == count-1) {
						sbuffer[size++] = 0;
					} else {
						sbuffer[size++] = ' ';
					}
				}
				
				/* register debug label */
				label = get_label(assembly, sbuffer);
				label->ref = get_label(assembly, items[1]);
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_GLOBAL;
			} else if (strcmp(line, "function") == 0) {
				if (count < 2) error(linenr, "invalid number of parameters");

				size = sprintf(sbuffer, "$");
				for (i = 1; i < count; i++) {
					size += sprintf(sbuffer+size, "%s", items[i]);
					if (i == count-1) {
						sbuffer[size++] = 0;
					} else {
						sbuffer[size++] = ' ';
					}
				}
				
				/* register debug label */
				label = get_label(assembly, sbuffer);
				label->ref = get_label(assembly, items[1]);
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_FUNCTION;
			} else if (strcmp(line, "label") == 0) {
				/* a label; register */
				if (count != 2) error(linenr, "invalid number of parameters");

				if (segment == BSS) {
					register_label(assembly, items[1], segment, assembly->bss_size);
				} else {
					register_label(assembly, items[1], segment, current_segment->data->size);
				}
			} else if (strcmp(line, "typedef") == 0) {
				if (count < 2) error(linenr, "invalid number of parameters");

				size = sprintf(sbuffer, "$");
				for (i = 1; i < count; i++) {
					size += sprintf(sbuffer+size, "%s", items[i]);
					if (i == count-1) {
						sbuffer[size++] = 0;
					} else {
						sbuffer[size++] = ' ';
					}
				}

				/* register debug label */
				label = get_label(assembly, sbuffer);
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_TYPEDEF;
			} else if (strcmp(line, "field") == 0) {
				if (count < 2) error(linenr, "invalid number of parameters");

				size = sprintf(sbuffer, "$");
				for (i = 1; i < count; i++) {
					if (i != 2) {
						size += sprintf(sbuffer+size, "%s", items[i]);
						if (i == count-1) {
							sbuffer[size++] = 0;
						} else {
							sbuffer[size++] = ' ';
						}
					}
				}

				/* register debug label */
				label = get_label(assembly, sbuffer);
				label->location = parse_numeric(items[2]);				

				label->segment = UNKNOWN;
				/* mark as debug function, set accessed to 1 to include it in the assembly */
				label->accessed = 1;
				label->debuginfo = LABEL_DEBUG_FIELD;
			} else {
				/* not identified; should be an instruction */
				write_instruction(assembly, items, count, current_segment);
			}
		}
	}	
	
	if (sourcefile != NULL) free(sourcefile);

	/* return the structure */
	return assembly;
}
Esempio n. 14
0
tedit_text::tedit_text(const std::string& title, const std::string& label, std::string& text)
{
    register_label("title", true, title, true);
    register_label("label", true, label, true);
    register_text("text", true, text, true);
}
Esempio n. 15
0
/* 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 */