Go to the first, previous, next, last section, table of contents.

User Interface

사용자 인터페이스

GDB has several user interfaces. Although the command-line interface is the most common and most familiar, there are others.

GDB는 몇몇 사용자 인터페이스를 가지고 있다. 비록 명령어 라인 인터페이스가 가장 일반적이고 대부분 익숙하다 할지라도, 그외 다른 것들도 있다.

The command interpreter in GDB is fairly simple. It is designed to allow for the set of commands to be augmented dynamically, and also has a recursive subcommand capability, where the first argument to a command may itself direct a lookup on a different command list.

GDB내 명령어 해석기는 꽤 간단한다. 그것은 동적으로 인자들을 명령어 집합에 허용하도록 디자인되었으며 또한 명령어에 대한 첫 인자는 다른 명령어 리스트를 직접 찾을수 있는 가능한 재귀적인 하위 명령어를 가지고 있다.

For instance, the `set' command just starts a lookup on the setlist command list, while `set thread' recurses to the set_thread_cmd_list.

예를 들어, `set' 명령어는 setlist 명령어 리스트를 찾기 시작하며, 반면에 `set thread'는 set_thread_cmd_list를 재귀적으로 찾기 시작한다.

To add commands in general, use add_cmd. add_com adds to the main command list, and should be used for those commands. The usual place to add commands is in the _initialize_xyz routines at the ends of most source files.

일반적으로 명령어를 추가하기 위해, add_cmd를 추가해라. add_com는 주 명령어 리스트에 추가하고 이들 명령어를 위해 사용되어야 한다. 명령어를 추가할 실제 위치는 대부분의 소스 파일 끝에서 _initialize_xyz 루틴 내이다.

Before removing commands from the command set it is a good idea to deprecate them for some time. Use deprecate_cmd on commands or aliases to set the deprecated flag. deprecate_cmd takes a struct cmd_list_element as it's first argument. You can use the return value from add_com or add_cmd to deprecate the command immediately after it is created.

명령어 집합에서 명령어를 제거하기 전에 가끔 그것들을 다시 생각하는 것은 좋은 생각이다. 명령어에서 deprecate_cmd를 사용하거나 deprecated flag 설정을 얼라이싱해서 사용해라. deprecate_cmd는 첫 인자로써 struct cmd_list_element를 가져라. 여러분은 생성된후 즉시 명령어를 다시 생각하기위해 add_com나 add_cmd에서 반환 값을 사용할수 있다.

The first time a comamnd is used the user will be warned and offered a replacement (if one exists). Note that the replacement string passed to deprecate_cmd should be the full name of the command, i.e. the entire string the user should type at the command line.

명령어가 사용되는 첫음에 사용자는 경고되고 대체(존재한다면)를 제공한다. deprecate_cmd에 전달되는 대체 문자열은 명령어의 완전한 이름이어야 한다. 즉, 명령어 라인에서 사용자가 타입해야하는 전체 문자열.

UI-Independent Output--the `ui_out` Functions

UI-독립적인 출력--`ui_out` 함수

The ui_out functions present an abstraction level for the GDB output code. They hide the specifics of different user interfaces supported by GDB, and thus free the programmer from the need to write several versions of the same code, one each for every UI, to produce output.

ui_out함수는 GDB 출력 코드를 위해 추상화 단계를 제공한다. GDB는 GDB가 지원하는 여러가지 사용자 인터페이스를 숨기며 모든 UI 마다, 출력을 만들기 위해 같은 코드의 몇몇 버전을 쓸 필요가 있는 프로그래머를 자유스럽게 한다.

ui_out

Overview and Terminology

In general, execution of each GDB command produces some sort of output, and can even generate an input request.

일반적으로, 각 GDB 명령어의 실행은 일부 정렬된 출력을 만들며 입력 요구를 만들수도 있다.

Output can be generated for the following purposes: 출력은 다음 목적을 위해 생성될수 있다:

to display a result of an operation;
작동의 결과를 출력하기 위해;
to convey info or produce side-effects of a requested operation;
info를 알리거나 요구된 작동의 역효과를 만들기 위해;
to provide a notification of an asynchronous event (including progress indication of a prolonged asynchronous operation);
비동기적 이벤트(늘어난 비동기 작동의 진행 지시를 포함하여)의 알림을 제공하기 위해;
to display error messages (including warnings);
에러 메세지들(경고 포함)을 출력하기 위해;
to show debug data;
데이타 디버그를 보여주기 위해;
to query or prompt a user for input (a special case).
입력(특별한 경우)을 위해 사용자를 질의하거나 프롬프트하기 위해.

This section mainly concentrates on how to build result output, although some of it also applies to other kinds of output.

이 섹션은 비록 일부가 다른 종류의 출력에 적용된다 할지라도, 주로 결과 출력을 만드는 방법에 대해 집중한다.

Generation of output that displays the results of an operation involves one or more of the following:

작동의 결과를 보여주는 출력 생성은 다음의 하나 또는 그 이상과 관련이 있다;

output of the actual data
실제 데이터의 출력
formatting the output as appropriate for console output, to make it easily readable by humans
사람이 쉽게 읽을수 있도록 하기 위해 적당한 콘솔 출력처럼 형식화된 출력
machine oriented formatting--a more terse formatting to allow for easy parsing by programs which read GDB's output
머신 기반 형식--GDB 출력을 읽는 프로그램이 쉽게 파싱하도록 하는 더 간결한 형식
annotation, whose purpose is to help a GUI (such as GDBTK or Emacs) to identify interesting parts in the output
출력에서 흥미로운 부분을 식별하기 위해 GUI(GDBTK나 Emacs같은)를 도와주는 목적의 주석

The ui_out routines take care of the first three aspects. Annotations are provided by separate annotation routines. Note that use of annotations for an interface between a GUI and GDB is deprecated.

ui_out 루틴은 첫 세 부분을 다룬다. 주석은 분리된 주석 루틴으로 제공된다. GUI와 GDB 사이의 인터페이스를 위해 주석을 사용하는것은 고려해야할 부분이다.

Output can be in the form of a single item, which we call a field; a list of fields; or a table, which is a list of fields with a header. In a BNF-like form:

출력은 단일 아이템의 형식에 있을수 있을수 있으며, 우리는 field를 호출한다; 필드의 list; 또는 헤더를 가지고 있는 필드의 리스트인 table. BNF 같은 형식으로:

<field> ::= any single item of data kept by gdb ;;

<list> ::= { <field> } ;;

<table> ::= <header> { <list> } ;;

<header> ::= { <column> } ;;

<column> ::= <width> <alignment> <title> ;;

General Conventions

일반적인 변환들

All ui_out routines currently are of type void, except for ui_out_stream_new which returns a pointer to the newly created object.

현재 모든 ui_out 함수들은 새로 생성된 타입의 객체에 대한 포인터를 반환하는 ui_out_stream_new를 제외하고는 void 타입이다.

The first parameter is always the ui_out vector object, a pointer to a struct ui_out.

처음 인자는 항상 ui_out 벡터 객체이며, struct ui_out에 대한 포인터이다.

The format parameter is like in printf family of functions. When it is present, there is usually also a variable list of arguments used to satisfy the % specifiers in the supplied format.

format 파라미터는 printf 계열의 함수 같다. 그것이 존재하면, 제공된 형식내 % 지정자를 만족하는 가변인자 리스트가 있다.

When a character string argument is not used in a ui_out function call, a NULL pointer has to be supplied instead.

문자열 인자가 ui_out 함수 호출시 사용되지 않는다면, NULL 포인터가 대신 제공된다.

Table and List Functions

테이블과 리스트 함수들

This section introduces ui_out routines for building lists and tables. The routines to output the actual data items (fields) are presented in the next section.

이 섹션은 리스트와 테이블 빌딩을 위해 ui_out 루틴을 소개한다. 실제 데이터 아이템(필드)를 출력하는 루틴은 다음장에 있다.

To recap: A list is a sequence of fields with information about an object; a table is a list of lists, each on a separate line, prefixed by a header line with the column titles.

재생하기 위해: list는 객체에 관한 정보를 가지는 연속적인 fields이다.; table은 분리된 라인당 칼럼 titles를 가지는 header 라인에 의해 접두사를 붙인 리스트들의 리스트이다.

Use the table functions if your output is composed of a list of fields for several objects and the console output should have a header. Use this even when you are listing just one object but you still want the header.

만일 출력이 몇몇 객체를 위한 필드 리스트로 이루어졌다면 테이블 함수를 사용해라. 그리고 콘솔 출력은 헤더를 가져야만 한다. 여러분이 단지 하나의 객체를 리스팅할때도 이것을 사용해라. 그러나 여전히 헤더는 원한다.

Use the list functions for the output of each object of a table or if your output consists of a single list of fields.

테이블 각 객체의 출력을 위해서나 만일 출력이 단일 리스트 필드로 이루어 져 있다면 리스트 함수를 사용해라.

You can nest a list into a table, but not the other way around.

근처의 다른 방법이 아니라 리스트를 테이블로 중첩할수 있다.

Lists can also be nested: some of your fields may be lists or tuples--{name,value} pairs. The maximum nesting level is currently 4.

list는 중첩될수 있다. 필드중 일부는 리스트나 tuples이다-- {name,value} 쌍. 최대 중첩 레벨은 현재 4이다.

The overall structure of the table output code is something like this:

테이블 출력 코드의 전체 구조는 다음과 같다:

  ui_out_table_begin
    ui_out_table_header
    ...
    ui_out_table_body
      ui_out_list_begin
        ui_out_field_*
        ...
      ui_out_list_end
      ...
  ui_out_table_end

Here's the description of table- and list-related ui_out functions:

여기에 테이블의 기술과 ui_out 함수 관련 리스트가 있다.

Function: void ui_out_table_begin (struct ui_out *uiout, int nbrofcols, char *tblid)

The function ui_out_table_begin marks the beginning of the output of a table. It should always be called before any other ui_out function for a given table. nbrofcols is the number of columns in the table, and tblid is an optional string identifying the table. The string pointed to by tblid is copied by the implementation of ui_out_table_begin, so the application can free the string if it was malloced.

함수 ui_out_table_begin는 테이블 출력의 시작을 표시한다. 주어진 다른 테이블을 위해 다른 ui_out 함수를 호출하기에 전에 항상 호출되어야 한다. nbrofcols는 테이블내 칼럼의 수이며, tblid는 테이블을 식별하는 선택적인 문자열이다. tblid가 가리키는 문자열은 ui_out_table_begin 수행시 복사된다. 그래서 응용 프로그램은 만일 malloc이라면 문자열을 해제한다.

The companion function ui_out_table_end, described below, marks the end of the table's output.

아래 기술한 쌍인 함수 ui_out_table_end는 테이블의 출력의 끝을 표시한다.

Function: void ui_out_table_header (struct ui_out *uiout, int width, enum ui_align alignment, char *colhdr)

ui_out_table_header provides the header information for a single table column. You call this function several times, one each for every column of the table, after ui_out_table_begin, but before ui_out_table_body.

ui_out_table_header는 단일 테이블 칼럼을 위한 헤더 정보를 제공한다. 여러분은 ui_out_table_begin와 ui_out_table_body사이에 테이블의 모든 칼럼에 한번씩 여러분 이 함수를 호출한다.

The value of width gives the column width in characters. The value of alignment is one of left, center, and right, and it specifies how to align the header: left-justify, center, or right-justify it. colhdr points to a string that specifies the column header; the implementation copies that string, so column header strings in malloced storage can be freed after the call.

width 값은 문자내 칼럼의 폭을 준다. alignment 값은 left, center, right중 하나이며 헤더를 정렬하는 방법을 지정한다.; left, center, rigth 선택. colhdr는 칼럼 헤더를 지정하는 문자열에 대한 포인터이다.; 수행은 문자열을 복사하며 malloc된 스토리지내 칼럼 헤더 문자열은 호출뒤 해제될수 있다.

Function: void ui_out_table_body (struct ui_out *uiout): This function marks the end of header information and the beginning of table body output. It doesn't by itself produce any data output; that is done by the list and field output functions described below.
이 함수는 헤더 정보의 끝과 테이블 바디 출력의 시작을 표시한다. 이 함수는 어떤 데이터 출력을 자체적으로 만들지 않는다.; 그것은 리스트와 아래 기술한 필드 출력 함수가 한다.

Function: void ui_out_table_end (struct ui_out *uiout)

This function signals the end of a table's output. It should be called after the table body has been produced by the list and field output functions.

이 함수는 테이블 출력의 끝을 알려준다. 이 함수는 테이블 바디가 리스트와 필드 출력 함수에 의해 만들어진후 호출되어야 한다.

There should be exactly one call to ui_out_table_end for each call to ui_out_table_begin, otherwise the ui_out functions will signal an internal error.

ui_out_table_begin 호출당 ui_out_table_end를 정확히 한번 호출해야 한다. 그렇지 않으면 ui_out 함수는 내부 에러를 알린다.

The output of the lists that represent the table rows must follow the call to ui_out_table_body and precede the call to ui_out_table_end. You produce the lists by calling ui_out_list_begin and ui_out_list_end, with suitable calls to functions which actually output fields between them.

테이블 Row를 나태내는 리스트 출력은 ui_out_table_body 호출 다음이며 ui_out_table_end 호출 전이다. 여러분은 이 함수들 사이의 실제 출력 필드인 함수를 알맞게 호출하여, ui_out_list_begin와 ui_out_list_end 호출하여 리스트를 호출할수 있다.

Function: void ui_out_list_begin (struct ui_out *uiout, char *lstid): This function marks the beginning or a list output. lstid points to an optional string that identifies the list; it is copied by the implementation, and so strings in malloced storage can be freed after the call.
이 함수는 시작과 리스트 출력을 표시한다. lstid는 리스트를 식별하는 선택적인 문자열에 대한 포인터이다.; 이것은 수행시 복사되며 malloc된 스토리지내 문자열을 호출뒤 해제할수 있다.

Function: void ui_out_list_end (struct ui_out *uiout): This function signals an end of a list output. There should be exactly one call to ui_out_list_end for each call to ui_out_list_begin, otherwise an internal GDB error will be signaled.
이 함수는 리스트 출력의 끝을 알린다. ui_out_list_begin 호출당 ui_out_list_end를 정확히 한번만 호출해야 한다. 그렇지 않으면 내부 GDB 에러가 날아온다.

Item Output Functions

아이템 출력 함수

The functions described below produce output for the actual data items, or fields, which contain information about the object.

아래 기술한 함수는 실제 데이터 아이템이나 객체에 관한 정보를 포함하는 필드를 위한 출력을 만든다.

Choose the appropriate function accordingly to your particular needs.

특별한 필요를 위해 적당한 함수를 선택해라.

Function: void ui_out_field_fmt (struct ui_out *uiout, char *fldname, char *format, ...)

This is the most general output function. It produces the representation of the data in the variable-length argument list according to formatting specifications in format, a printf-like format string. The optional argument fldname supplies the name of the field. The data items themselves are supplied as additional arguments after format.

이것은 가장 일반적인 출력 함수이다. 이 함수는 printf 같은 형식 문자열처럼, format내 형식화된 지정에 따라 가변 인자 리스트내 데이터 표현을 만든다. 선택 인자 fldname는 필드의 이름을 제공한다. 데이터 아이템은 format후 추가적인 인자로써 제공된다.

This generic function should be used only when it is not possible to use one of the specialized versions (see below).

일반적인 함수는 특별한 버전의 것을 사용하기 불가능할때만 사용해야 한다.

Function: void ui_out_field_int (struct ui_out *uiout, char *fldname, int value): This function outputs a value of an int variable. It uses the "%d" output conversion specification. fldname specifies the name of the field.
이 함수는 int 변수의 값을 출력한다. "%d" 출력 변환 지정자를 사용해라. fldname는 필드의 이름을 지정한다.

Function: void ui_out_field_core_addr (struct ui_out *uiout, char *fldname, CORE_ADDR address): This function outputs an address.
이함수는 주소를 출력한다.

Function: void ui_out_field_string (struct ui_out *uiout, char *fldname, const char *string): This function outputs a string using the "%s" conversion specification.
이 함수는 "%s" 변환 지정자를사용하여 문자열을 출력한다.

Sometimes, there's a need to compose your output piece by piece using functions that operate on a stream, such as value_print or fprintf_symbol_filtered. These functions accept an argument of the type struct ui_file *, a pointer to a ui_file object used to store the data stream used for the output. When you use one of these functions, you need a way to pass their results stored in a ui_file object to the ui_out functions. To this end, you first create a ui_stream object by calling ui_out_stream_new, pass the stream member of that ui_stream object to value_print and similar functions, and finally call ui_out_field_stream to output the field you constructed. When the ui_stream object is no longer needed, you should destroy it and free its memory by calling ui_out_stream_delete.

가끔, value_print나 fprintf_symbol_filtered처럼, 스트림에서 작동하는 함수를 사용하여 조각단위로 출력을 이루도록 할 필요가 있다. 이들 함수는 struct ui_file * 타입의 인자와 출력시 사용하는 데이터 스트림을 저장하기 위한 ui_file객체에 대한 포인터를 받는다. 이들 함수들중 하나를 사용할때, 여러분은 ui_file 객체에 저장된 결과를 ui_out 함수에 전달하기 위한 방법이 필요하다. 이러한 목적을 위해, 여러분은 우선 ui_out_stream_new를 호출하여 ui_stream 객체를 만들고, ui_stream 객체의 stream 멤버를 value_print와 비슷한 함수들에게 전달하고, 마지막으로 여러분이 만든 필드를 출력하기 위해 ui_out_field_stream를 호출해라. ui_stream 객체가 더이상 필요하지 않을때, 여러분은 우선 객체를 파괴하고 ui_out_stream_delete를 호출하여 메모리를 해제해야 한다.

Function: struct ui_stream *ui_out_stream_new (struct ui_out *uiout): This function creates a new ui_stream object which uses the same output methods as the ui_out object whose pointer is passed in uiout. It returns a pointer to the newly created ui_stream object.
이 함수는 uiout에 대한 포인터로 전달하는 ui_out 객체와 같은 출력 방법을 사용하는 새로운 ui_stream 객체를 만든다. 이 함수는 새로 생성된 ui_stream 객체에 대한 포인터를 반환한다.

Function: void ui_out_stream_delete (struct ui_stream *streambuf): This functions destroys a ui_stream object specified by streambuf.
이 함수는 streambuf가 지정하는 ui_stream 객체를 파괴한다.

Function: void ui_out_field_stream (struct ui_out *uiout, char *fieldname, struct ui_stream *streambuf): This function consumes all the data accumulated in streambuf->stream and outputs it like ui_out_field_string does. After a call to ui_out_field_stream, the accumulated data no longer exists, but the stream is still valid and may be used for producing more fields.
이 함수는 streambuf->stream에 싸인 모든 데이터를 소비하고 ui_out_field_string가 하는것처럼 출력한다. ui_out_field_stream 호출후, 쌓인 데이터는 더이상 존재하지 않는다. 그러나 스트림은 여전히 유효하며 더 많은 필드들을 만들기 위해 사용된다.

Important: If there is any chance that your code could bail out before completing output generation and reaching the point where ui_out_stream_delete is called, it is necessary to set up a cleanup, to avoid leaking memory and other resources. Here's a skeleton code to do that:

중요: 만일 여러분의 코드가 출력 생성을 끝내고 ui_out_stream_delete가 호출되는 시점에 도달하기 전에 끝날 가능성이 있다면, 메모리와 다른 자원이 릭되는 것을 피하기 위해 cleanup을 설정할 필요가 있다.

 struct ui_stream *mybuf = ui_out_stream_new (uiout);
 struct cleanup *old = make_cleanup (ui_out_stream_delete, mybuf);
 ...
 do_cleanups (old);

If the function already has the old cleanup chain set (for other kinds of cleanups), you just have to add your cleanup to it:

만일 함수가 이미 에전 cleanup cahin set(다른 종류의 cleanup)을 가지고 있다면, 여러분은 여러분의 cleanup만 추가하면 된다.

  mybuf = ui_out_stream_new (uiout);
  make_cleanup (ui_out_stream_delete, mybuf);

Note that with cleanups in place, you should not call ui_out_stream_delete directly, or you would attempt to free the same buffer twice.

cleanup을 할때, 여러분은 ui_out_stream_delete를 직접 호출하거나 같은 버퍼를 해제하기 위해 두번 시도해서는 안된다.

Utility Output Functions

기능 출력 함수

Function: void ui_out_field_skip (struct ui_out *uiout, char *fldname): This function skips a field in a table. Use it if you have to leave an empty field without disrupting the table alignment. The argument fldname specifies a name for the (missing) filed.
이 함수는 테이블내 필드를 건너띈다. 만일 여러분이 테이블 정렬 분열없이 빈 필드를 남길려면 이 함수를 사용해라. fldname 인자는 (잃어버린)필드를 위한 이름을 지정한다.

Function: void ui_out_text (struct ui_out *uiout, char *string)

This function outputs the text in string in a way that makes it easy to be read by humans. For example, the console implementation of this method filters the text through a built-in pager, to prevent it from scrolling off the visible portion of the screen.

이 함수는 사람이 읽기 쉽게 만들기 위한 방법으로 string내 텍스트를 출력한다. 예를 들어, 이 방법의 콘솔 수행은 스크린의 비주얼한 부분의 스크롤을 막기 위해 내장 페이저를 통해 이 텍스트를 필터링한다.

Use this function for printing relatively long chunks of text around the actual field data: the text it produces is not aligned according to the table's format. Use ui_out_field_string to output a string field, and use ui_out_message, described below, to output short messages.

실제 필드 데이터내 텍스트의 긴 chunk을 출력하기 위해 이 함수를 사용해라.; 만드는 텍스트는 테이블 형식에 따라 정렬되지 않는다. 문자열 필드를 출력하기 위해 ui_out_field_string를 사용하고 간단한 메세지를 출력하기 위해 아래 기술한, ui_out_message를 사용해라.

Function: void ui_out_spaces (struct ui_out *uiout, int nspaces): This function outputs nspaces spaces. It is handy to align the text produced by ui_out_text with the rest of the table or list.
이 함수는 nspaces 스페이스를 출력한다. 테이블이나 리스트의 나머지를 가지고 ui_out_text가 만든 텍스트를 정렬하기 쉽다.

Function: void ui_out_message (struct ui_out *uiout, int verbosity, char *format, ...): This function produces a formatted message, provided that the current verbosity level is at least as large as given by verbosity. The current verbosity level is specified by the user with the `set verbositylevel' command.(1)
이 함수는 현재 verbosity 레벨이 verbosity에 의해 주어진 것만큼 커다란 형식화된 메세지를 만든다. 현재 verbosity 레벨은 `set verbositylevel' 명령어로 사용자가 지정한다. (1)

Function: void ui_out_wrap_hint (struct ui_out *uiout, char *indent): This function gives the console output filter (a paging filter) a hint of where to break lines which are too long. Ignored for all other output consumers. indent, if non-NULL, is the string to be printed to indent the wrapped text on the next line; it must remain accessible until the next call to ui_out_wrap_hint, or until an explicit newline is produced by one of the other functions. If indent is NULL, the wrapped text will not be indented.
이 함수는 콘솔 출력 필터(페이징 필터)를 준다. 모든 다른 출력 소비자를 무시한다. 만일 NULL이 아니라면, indent는 다음 라인의 레핑된 텍스트를 들여쓰기 위해 출력하기 위한 문자열이다.; 이 함수는 ui_out_wrap_hint에 대한 다음 호출이나 명백한 newline이 다른 함수중 하나가 만들때까지 접근할수 있도록 남아 있어야 한다. 만일 indent가 NULL이라면, 레핑된 텍스트는 들여쓰여지지 않는다.

Function: void ui_out_flush (struct ui_out *uiout): This function flushes whatever output has been accumulated so far, if the UI buffers output.
만일 UI가 추력을 버퍼한다면, 이 함수는 출력이 지금까지 싸여있는것은 모두 flush한다.

Examples of Use of `ui_out` functions

`ui_out` 함수의 사용 예제

This section gives some practical examples of using the ui_out functions to generalize the old console-oriented code in GDB. The examples all come from functions defined on the `breakpoints.c' file.

이 섹션은 GDB내 예전 콘솔 기반 코드를 일반화하기 위한 ui_out 함수의 특별한 실제적인 사용 예제을 보여준다.

This example, from the breakpoint_1 function, shows how to produce a table.

breakpoint_1 함수에서 이 예제는 테이블을 만드는 방법을 보여준다.

The original code was:

원래 코드는:

 if (!found_a_breakpoint++)
   {
     annotate_breakpoints_headers ();

     annotate_field (0);
     printf_filtered ("Num ");
     annotate_field (1);
     printf_filtered ("Type           ");
     annotate_field (2);
     printf_filtered ("Disp ");
     annotate_field (3);
     printf_filtered ("Enb ");
     if (addressprint)
       {
         annotate_field (4);
         printf_filtered ("Address    ");
       }
     annotate_field (5);
     printf_filtered ("What\n");

     annotate_breakpoints_table ();
   }

Here's the new version:

새로운 버전은:

 if (!found_a_breakpoint++)
   {
     annotate_breakpoints_headers ();
     if (addressprint)
       ui_out_table_begin (ui, 6);
     else
       ui_out_table_begin (ui, 5);

     annotate_field (0);
     ui_out_table_header (ui, 4, left, "Num");
     annotate_field (1);
     ui_out_table_header (ui, 15, left, "Type");
     annotate_field (2);
     ui_out_table_header (ui, 5, left, "Disp");
     annotate_field (3);
     ui_out_table_header (ui, 4, left, "Enb");
     if (addressprint)
       {
         annotate_field (4);
         ui_out_table_header (ui, 11, left, "Address");
       }
     annotate_field (5);
     ui_out_table_header (ui, 40, left, "What");

     ui_out_table_body (ui);
     annotate_breakpoints_table ();
   }

This example, from the print_one_breakpoint function, shows how to produce the actual data for the table whose structure was defined in the above example. The original code was:

print_one_breakpoint 함수에서, 이 예제는 위 예제에서 정의된 구조체내 테이블을 위한 실제 대이터를 만드는 방법을 보여준다.

   annotate_record ();
   annotate_field (0);
   printf_filtered ("%-3d ", b->number);
   annotate_field (1);
   if ((int)b->type > (sizeof(bptypes)/sizeof(bptypes[0]))
       || ((int) b->type != bptypes[(int) b->type].type))
     internal_error ("bptypes table does not describe type #%d.",
                     (int)b->type);
   printf_filtered ("%-14s ", bptypes[(int)b->type].description);
   annotate_field (2);
   printf_filtered ("%-4s ", bpdisps[(int)b->disposition]);
   annotate_field (3);
   printf_filtered ("%-3c ", bpenables[(int)b->enable]);

This is the new version: 이것이 새 버전이다:

   annotate_record ();
   ui_out_list_begin (uiout, "bkpt");
   annotate_field (0);
   ui_out_field_int (uiout, "number", b->number);
   annotate_field (1);
   if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
       || ((int) b->type != bptypes[(int) b->type].type))
     internal_error ("bptypes table does not describe type #%d.",
                     (int) b->type);
   ui_out_field_string (uiout, "type", bptypes[(int)b->type].description);
   annotate_field (2);
   ui_out_field_string (uiout, "disp", bpdisps[(int)b->disposition]);
   annotate_field (3);
   ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int)b->enable]);

This example, also from print_one_breakpoint, shows how to produce a complicated output field using the print_expression functions which requires a stream to be passed. It also shows how to automate stream destruction with cleanups. The original code was:

print_one_breakpoint에서, 이 예제는 스트림 전달을 요구하는 print_expression 함수를 사용하는 복잡한 출력 필드를 만들기 위한 방법을 보여준다. 이 함수는 스트림 파괴를 자동화하기 위한 방법을 제공한다. 원래 코드는 :

    annotate_field (5);
    print_expression (b->exp, gdb_stdout);

The new version is:

새 버전은:

  struct ui_stream *stb = ui_out_stream_new (uiout);
  struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
  ...
  annotate_field (5);
  print_expression (b->exp, stb->stream);
  ui_out_field_stream (uiout, "what", local_stream);

This example, also from print_one_breakpoint, shows how to use ui_out_text and ui_out_field_string. The original code was:

print_one_breakpoint에서, 이 예제는 ui_out_text와 ui_out_field_string를 사용하는 방법을 제공한다. 원래 코드는:

  annotate_field (5);
  if (b->dll_pathname == NULL)
    printf_filtered ("<any library> ");
  else
    printf_filtered ("library \"%s\" ", b->dll_pathname);

It became:

다음과 같다:

  annotate_field (5);
  if (b->dll_pathname == NULL)
    {
      ui_out_field_string (uiout, "what", "<any library>");
      ui_out_spaces (uiout, 1);
    }
  else
    {
      ui_out_text (uiout, "library \"");
      ui_out_field_string (uiout, "what", b->dll_pathname);
      ui_out_text (uiout, "\" ");
    }

The following example from print_one_breakpoint shows how to use ui_out_field_int and ui_out_spaces. The original code was:

print_one_breakpoint에서 다음 예제는 ui_out_field_int과 ui_out_spaces를 사용하는 방법을 보여준다. 원래 코드는:

  annotate_field (5);
  if (b->forked_inferior_pid != 0)
    printf_filtered ("process %d ", b->forked_inferior_pid);

It became:

다음과 같다:

  annotate_field (5);
  if (b->forked_inferior_pid != 0)
    {
      ui_out_text (uiout, "process ");
      ui_out_field_int (uiout, "what", b->forked_inferior_pid);
      ui_out_spaces (uiout, 1);
    }

Here's an example of using ui_out_field_string. The original code was:

이것은 ui_out_field_string의 사용 예제이다. 원래 코드는:

  annotate_field (5);
  if (b->exec_pathname != NULL)
    printf_filtered ("program \"%s\" ", b->exec_pathname);

It became: 다음과 같다:

  annotate_field (5);
  if (b->exec_pathname != NULL)
    {
      ui_out_text (uiout, "program \"");
      ui_out_field_string (uiout, "what", b->exec_pathname);
      ui_out_text (uiout, "\" ");
    }

Finally, here's an example of printing an address. The original code:

마지막으로, 여기에 주소 출력 예제가 있다. 원래 코드는:

  annotate_field (4);
  printf_filtered ("%s ",
        local_hex_string_custom ((unsigned long) b->address, "08l"));

It became:

다음과 같다:

  annotate_field (4);
  ui_out_field_core_addr (uiout, "Address", b->address);

Go to the first, previous, next, last section, table of contents.

User Interface

사용자 인터페이스

Command Interpreter

명령어 해석기

UI-Independent Output--the `ui_out` Functions

UI-독립적인 출력--`ui_out` 함수

Overview and Terminology

General Conventions

일반적인 변환들

Table and List Functions

테이블과 리스트 함수들

Item Output Functions

아이템 출력 함수

Utility Output Functions

기능 출력 함수

Examples of Use of `ui_out` functions

`ui_out` 함수의 사용 예제

Console Printing

콘솔 출력

TUI

libgdb