# Plugin API

## set_charset

Prototyp: `void set_charset (t_weechat_plugin *plugin, char *charset)`

Legt neuen Zeichensatz für ein Plugin fest.

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

- `charset`: neuer Zeichensatz, der benutzt werden soll

Beispiel:

    plugin->set_charset (plugin, "ISO-8859-1");

## iconv_to_internal

Prototyp: `void iconv_to_internal (t_weechat_plugin *plugin, char *charset, char *string)`

Konvertiert eine Zeichenkette in das interne Format von WeeChat (UTF-8).

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

- `charset`: ursprünglicher Zeichensatz, von dem konvertiert werden soll

- `string`: zu konvertierende Zeichenkette

Rückgabewert: konvertierte Zeichenkette

Anmerkung: der Speicher, der durch das Ergebnis belegt wird, muss mit free() wieder freigegeben werden.

Beispiel:

    char *str = plugin->iconv_to_internal (plugin, "ISO-8859-1", "iso string: é à");

## iconv_from_internal

Prototyp: `void iconv_from_internal (t_weechat_plugin *plugin, char *charset, char *string)`

Konvertiert eine Zeichenkette von dem internen WeeChat-Zeichensatz (UTF-8) in einen anderen.

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

- `charset`: Ziel-Zeichensatz

- `string`: zu konvertierende Zeichenkette

Rückgabewert: konvertierte Zeichenkette

Anmerkung: der Speicher, der durch das Ergebnis belegt wird, muss mit free() wieder freigegeben werden.

Beispiel:

    char *str = plugin->iconv_from_internal (plugin, "ISO-8859-1", "utf-8 string: é à");

## ascii_strcasecmp

Prototyp: `int ascii_strcasecmp (t_weechat_plugin *plugin, char *string1, char *string2)`

Vergleich von Zeichenketten unabhängig von Sprache und Schreibweise (gross/klein).

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

- `string1`: erste Zeichenkette des Vergleichs

- `string2`: zweite Zeichenkette des Vergleichs

Rückgabewert: Unterschied zwischen den zwei Zeichenketten: kleiner Null wenn string1 < string2, Null wenn string1 == string2, grösser Null wenn string1 > string2

Beispiel:

    if (plugin->ascii_strcasecmp (plugin, "abc", "def") != 0) ...

## ascii_strncasecmp

Prototyp: `int ascii_strncasecmp (t_weechat_plugin *plugin, char *string1, char *string2, int max)`

Vergleich von Zeichenketten unabhängig von Sprache und Schreibweise (gross/klein) für höchstens "max" Zeichen.

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

- `string1`: erste Zeichenkette des Vergleichs

- `string2`: zweite Zeichenkette des Vergleichs

- `max`: maximale Zahl an Zeichen für den Vergleich

Rückgabewert: Unterschied zwischen den zwei Zeichenketten: kleiner Null wenn string1 < string2, Null wenn string1 == string2, grösser Null wenn string1 > string2

Beispiel:

    if (plugin->ascii_strncasecmp (plugin, "abc", "def", 2) != 0) ...

## explode_string

Prototyp: `char **explode_string (t_weechat_plugin *plugin, char *string, char *separators, int num_items_max, int *num_items)`

Zerlege eine Zeichenkette entsprechend eines oder mehrerer Trennzeichen(s).

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `string`: zu zerlegende Zeichenkette

- `separators`: zu verwendende(s) Trennzeichen

- `num_items_max`: maximale Anzahl an zu erzeugenden Teilen (0 = keine Grenze)

- `num_items`: Zeiger auf eine int-Variable, die die Anzahl der erzeugten Teile enthält

Rückgabewert: ein Array von Zeichenketten, NULL bei Fehlern.

Hinweis: Das zurückgegebene Array muss nach der Benutzung mittels "free_exloded_string" explizit freigegeben werden.

Beispiel:

    char **argv;
    int argc;
    argv = plugin->explode_string (plugin, string, " ", 0, &argc);
    ...
    if (argv != NULL)
        plugin->free_exploded_string (plugin, argv);

## free_exploded_string

Prototyp: `char **free_exploded_string (t_weechat_plugin *plugin, char **string)`

Gib ein Array frei, dass infolge der Zerlegung eines Strings reserviert wurde.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `string`: ein Array von Strings

Rückgabewert: keiner (?).

Beispiel:

    char *argv;
    int argc;
    argv = plugin->explode_string (plugin, string, " ", 0, &argc);
    ...
    if (argv != NULL)
        plugin->free_exploded_string (plugin, argv);

## mkdir_home

Prototyp: `int mkdir_home (t_weechat_plugin *plugin, char *directory)`

Erzeugt ein Verzeichnis im WeeChat-Verzeichnis.

Argumente:

- `plugin`: Zeiger auf Pluginstrukur

- `directory`: Verzeichnis, das erzeugt werden soll

Rückgabewert: 1 wenn das Verzeichnis erfolgreich erstellt wurde, 0 wenn ein Fehler aufgetreten ist.

Beispiel:

    if (!plugin->mkdir_home (plugin, "temp"))
        plugin->print_server(plugin, "Konnte 'temp'-Verzeichnis im WeeChat-Verzeichnis nicht erstellen.");

## exec_on_files

Prototyp: `void exec_on_files (t_weechat_plugin *plugin, char *repertoire, int (*callback)(t_weechat_plugin *, char *))`

Führe eine Funktion auf allen Dateien eines Verzeichnisses aus.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `directory`: Verzeichnis der zu verwendenden Dateien

- `callback`: die anzuwendende Funktion

Rückgabewert: keiner.

Beispiel:

    int callback (t_weechat_plugin *plugin, char *file)
    {
        plugin->print_server (plugin, "file: %s", file);
        return 1;
    }
    ...
    plugin->exec_on_files (plugin, "/tmp", &callback);

## print

Prototyp: `void print (t_weechat_plugin *plugin, char *server, char *channel, char *message, ...)`

Sende eine Nachricht an einen WeeChat-Puffer, bezeichnet durch server und channel (beide können NULL sein, dann wird der aktuelle Puffer verwendet).

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

- `server`: interner Name des Servers, zu welchem der Puffer gehört, in dem die Nachricht angezeigt werden soll (kann NULL sein)

- `channel`: Name des Channels, in dem die Nachricht angezeigt werden soll (kann NULL sein)

- `message`: Nachricht

To display colored text, there are following codes:

Code | Description
--- | ---
0x02 | bold text
0x03 + "xx" | text color "`xx`" (see for colors)
0x03 + "xx,yy" | text color "`xx`" and background "`yy`" (see for colors)
0x0F | disable color and attributes
0x12 | reverse video (revert text color with background)
0x1F | underlined text

Note: the same code (without number for 0x03) may be used to stop the attribute.

Rückgabewert: keiner.

Beispiele:

    plugin->print (plugin, NULL, NULL, "hello");
    plugin->print (plugin, NULL, "#weechat", "hello");
    plugin->print (plugin, "freenode", "#weechat", "hello");
    plugin->print (plugin, NULL, NULL,
                   "Test: \x02 Fett \x0F\x03%02d Blau \x03%02d Grün",
                   plugin->get_irc_color (plugin, "blue"),
                   plugin->get_irc_color (plugin, "green"));

## print_server

Prototyp: `void print_server (t_weechat_plugin *plugin, char *message, ...)`

Zeige eine Nachricht im aktuellen Server-Puffer.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `message`: Nachricht

To display colored text, see .

Rückgabewert: keiner.

Beispiel:

    plugin->print_server (plugin, "hello");

## log

Prototyp: `void log (t_weechat_plugin *plugin, char *server, char *channel, char *message, ...)`

Schreibe eine Nachricht in die Log-Datei (für den entsprechenden Server/Channel).

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `server`: interner Name des Servers, zu welchem der Log-Puffer gehört (kann NULL sein)

- `channel`: Name des Channels, zu welchem der Log-Puffer gehört (kann NULL sein)

- `message`: Nachricht

Rückgabewert: keiner.

Beispiel:

    plugin->log (plugin, "freenode", "#weechat", "test");

## msg_handler_add

Prototyp: `t_plugin_handler *msg_handler_add (t_weechat_plugin *plugin, char *message, t_plugin_handler_func *function, char *handler_args, void *handler_pointer)`

Erzeuge einen IRC-Message-Handler, der aufgerufen wird, wenn eine Nachricht empfangen wird.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `message`: Name (Typ) der IRC-Nachricht ("*" für alle Nachrichten). Eine Liste der bekannten IRC-Nachrichten ist in den RFCs 1459 und 2812 zu finden. Weiterhin können sie einen speziellen Namen verwenden, der mit "weechat_" beginnt, um spezielle Ereignisse zu bearbeiten, wie in der folgenden Tabelle aufgeführt:

  Name | Beschreibung
  --- | ---
  `weechat_pv` | private Nachricht empfangen
  `weechat_highlight` | hervorgehobene Nachricht (in einem Channel oder privatem Chat)
  `weechat_ctcp` | CTCP-Nachricht empfangen (VERSION, PING, ...)
  `weechat_dcc` | DCC-Nachricht empfangen (Chat oder Datei)

- `function`: Funktion, die aufgerufen wird, wenn eine Nachricht empfangen wurde

  Sie verwendet den folgenden Prototyp: `int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Argument argc ist auf 3 gesetzt, die folgenden Werte sind im argv-Array:

  - argv[0] = Server Name

  - argv[1] = IRC Nachricht

  - argv[2] = Kommando Argumente

- `handler_args`: Argumente, die beim Aufruf an die Funktion übergeben werden

- `handler_pointer`: pointer given to function when called `handler_pointer`: Zeiger, der an die Funktion übergeben wird

Rückgabewert: Zeiger auf den neuen Handler

Hinweis: die Funktion, die aufgerufen wird wenn eine Nachricht empfangen wurde, muss einen der folgenden Werte zurückgeben:

- `PLUGIN_RC_KO`: Funktion ist fehlgschlagen

- `PLUGIN_RC_OK`: Funktion war erfolgreich

- `PLUGIN_RC_OK_IGNORE_WEECHAT`: Die Nachricht wird nicht an WeeChat übergeben

- `PLUGIN_RC_OK_IGNORE_PLUGINS`: Die Nachricht wird nicht an andere Plugins weitergegeben

- `PLUGIN_RC_OK_IGNORE_ALL`: Die Nachricht wird weder an WeeChat noch an andere Plugins weitergegeben

- `PLUGIN_RC_OK_WITH_HIGHLIGHT`: Funktion erfolgreich vervollständigt und eine Hervorhebung bei den empfangenen Nachrichten eingebaut

Beispiel:

    int msg_kick (t_weechat_plugin *plugin, int argc, char **argv,
                  char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, argv[0], NULL, "KICK received");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *msg_handler;
    msg_handler = plugin->msg_handler_add (plugin, "KICK",
                                           &msg_kick, NULL, NULL);

## cmd_handler_add

Prototyp: `t_plugin_handler *cmd_handler_add (t_weechat_plugin *plugin, char *command, char *description, char *arguments, char *arguments_description, char *completion_template, t_plugin_handler_func *fonction, char *handler_args, void *handler_pointer)`

Erzeugt einen Handler für ein WeeChat-Kommando, der aufgerufen wird, wenn der Anwender das Kommando ausführt (Beispiel: /command).

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `command`: Name des neuen Kommandos, der auch Name eines bereits existierenden Kommandos sein kann (mit Bedacht zu verwenden, das ersetzte Kommando ist nicht verfügbar, bis das Plugin entfernt wurde)

- `description`: kurze Beschreibung des Kommandos (angezeigt beim Ausführen von /help command)

- `arguments`: kurze Beschreibung der Argumente des Kommandos (angezeigt beim Ausführen von /help command)

- `arguments_description`: lange Beschreibung der Argumente des Kommandos (angezeigt beim Ausführen von /help command)

- `completion_template`: Vorlage für die Vervollständigung; zum Beispiel bedeutet "`abc|%w def|%i`", dass das erste Argument "abc" oder ein WeeChat-Kommando sein kann und das zweite Argument "def" oder ein IRC-Kommando. Eine leere Zeichenkette bedeutet, dass WeeChat für jedes Argument einen Nicknamen des gegenwärtigen Channels einsetzt, ein NULL oder "-" schaltet die Vervollständigung für alle Argumente ab.

  Die folgenden Ersetzungen können verwendet werden:

  Code | Beschreibung
  --- | ---
  `%-` | keine Vervollständigung für das Argument
  `%*` | repeat last completion for all following arguments (this code has to be at the end of completion template, preceded by "|")
  `%a` | Alias
  `%A` | Aliase und Kommandos (WeeChat, IRC und Plugins)
  `%c` | gegenwärtiger Channel
  `%C` | alle channels (inklusive Queries)
  `%f` | Dateiname
  `%h` | Plugin Kommandos
  `%i` | IRC Kommandos (senden)
  `%I` | IRC Kommandos (empfangen)
  `%k` | Grundfunktionen
  `%m` | Nicknamen des gegenwärtigen Servers
  `%M` | Nicks auf dem gegenwärtigen Server (in allen offenen Channeln)
  `%n` | Nicknamen des gegenwärtigen Channels
  `%N` | Nicknamen und Hostnamen des gegenwärtigen Channels
  `%o` | Konfigurationseinstellungen
  `%O` | Plugin Optionen
  `%p` | Standard "part" Nachricht
  `%q` | Standard "quit" Nachricht
  `%s` | Name des gegenwärtigen Servers
  `%S` | Namen aller definierten Server
  `%t` | Topic des gegenwärtigen Channels
  `%v` | Wert einer Konfigurationseinstellung
  `%V` | Wert einer Plugin-Option
  `%w` | WeeChat Kommandos

- `function`: Funktion, die aufgerufen wird, wenn das Kommando ausgeführt wird

  Sie verwendet den folgenden Prototypen: `int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Das Argument argc ist auf 3 gesetzt, das Array argv enthält die folgenden Werte:

  - argv[0] = Server Name

  - argv[1] = Kommando

  - argv[2] = Kommando-Argumente

- `handler_args`: Argumente, die an die Funktion übergeben werden

- `handler_pointer`: Zeiger, der an die Funktion übergeben wird

Rückgabewert: Zeiger auf den neuen Kommando-Handler.

Hinweis: die Funktion, die aufgerufen wird, wenn das Kommando ausgeführt wird, muss einen der folgende Werte zurückgeben:

- `PLUGIN_RC_KO`: Funktion ist fehlgeschlagen

- `PLUGIN_RC_OK`: Funktion war erfolgreich

Beispiel:

    int cmd_test (t_weechat_plugin *plugin, int argc, char **argv,
                  char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, argv[0], NULL,
                       "test command, nick: %s",
                       (argv[2]) ? argv[2] : "none");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *cmd_handler;
    cmd_handler = plugin->cmd_handler_add (plugin, "test", "Test command",
                                           "[nick]", "nick: nick of channel",
                                           "%n", &cmd_test, NULL, NULL);

## timer_handler_add

Prototyp: `t_plugin_handler *timer_handler_add (t_weechat_plugin *plugin, int interval, t_plugin_handler_func *function, char *handler_args, void *handler_pointer)`

Erzeuge einen zeitgesteuerten Handler, der periodisch eine Funktion aufruft.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `interval`: Intervall (in Secunden) zwischen zwei Aufrufen der Funktion

- `function`: Funktion, die aufgerufen wird

  Sie verwendet den folgenden Prototypen: `int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Das Argument argc ist auf 0 gesetzt und argv ist auf NULL gesetzt.

- `handler_args`: Argumente der aufgerufenen Funktion

- `handler_pointer`: Zeiger, der an die Funktion übergeben wird

Rückgabewert: Zeiger auf den neuen timer-Handler.

Hinweis: die Funktion, die aufgerufen wird, muss einen der folgende Werte zurückgeben:

- `PLUGIN_RC_KO`: Funktion ist fehlgeschlagen

- `PLUGIN_RC_OK`: Funktion war erfolgreich

Beispiel:

    int my_timer (t_weechat_plugin *plugin, int argc, char **argv,
                  char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, NULL, NULL, "my timer");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *timer_handler;
    timer_handler = plugin->timer_handler_add (plugin, 60, &my_timer);

## keyboard_handler_add

Prototyp: `t_plugin_handler *keyboard_handler_add (t_weechat_plugin *plugin, t_plugin_handler_func *function, char *handler_args, void *handler_pointer)`

Erzeugt einen Keyboard-Handler, der nach dem Drücken einer Taste aufgerufen wird.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `function`: Die Funktion, die aufgerufen wird

  Sie verwendet den folgenden Prototypen: `int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Das Argument argc ist auf 3 gesetzt, argv enthält die folgenden Werte:

  - argv[0] = Taste, die gedrückt wurde (Name der internen Funktion oder '*' gefolgt von einem Tastaturcode)

  - argv[1] = Kommandozeile vor dem Tastendruck

  - argv[2] = Kommandozeile nach dem Tastendruck

- `handler_args`: Argumente, die bei Aufruf der Funktion übergeben werden

- `handler_pointer`: Zeiger auf die Funktion, der bei Aufruf übergeben wird

Rückgabewert: Zeiger auf den Handler.

Hinweis: Die aufgerufene Funktion muss einen der folgenden Werte zurückgeben:

- `PLUGIN_RC_KO`: Funktion ist fehlgeschlagen

- `PLUGIN_RC_OK`: Funktion war erfolgreich

Beispiel:

    int my_keyb (t_weechat_plugin *plugin, int argc, char **argv,
                 char *handler_args, void *handler_pointer)
    {
        if (argc == 2)
        {
            plugin->print (plugin, NULL, NULL, "key pressed: %s", argv[0]);
            if (argv[1] && (argv[1][0] == '1'))
                plugin->print (plugin, NULL, NULL, "input text changed");
            else
                plugin->print (plugin, NULL, NULL, "input text not changed");
        }
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *keyb_handler;
    keyb_handler = plugin->keyboard_handler_add (plugin, &my_keyb);

## event_handler_add

Prototyp: `t_plugin_handler *event_handler_add (t_weechat_plugin *plugin, char *event, t_plugin_handler_func *function, char *handler_args, void *handler_pointer)`

Fügt einen Ereignishandler hinzu, der aufgerufen wird, wenn ein Ereignis eintritt.

Argumente:

- `plugin`: Zeiger auf Plugin-Strukture

- `event` : Ereignis (siehe folgende Tabelle)

- `function`: aufgerufene Funktion

  Es wird folgender Prototyp verwendet: `int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *handler_args, void *handler_pointer)`

  Arguments depend on event (see table below).

- `handler_args`: Argument, die an die aufgerufene Funktion übergeben werden

- `handler_pointer`: Pointer, der an die aufgerufene Funktion übergeben werden

List of events:

Ereignis | Beschreibung | Arguments
--- | --- | ---
`buffer_open` | ein Puffer wurde geöffnet | argc = 1, argv = { buffer number }
`buffer_close` | ein Puffer wurde geschlossen | argc = 1, argv = { buffer number }
`buffer_move` | a buffer was moved | argc = 2, argv = { new buffer number, old number }

Rückgabewert: Pointer auf den neuen Ereignishandler.

Anmerkung: die aufgerufene Function muss einen der folgenden Werte zurückgeben:

- `PLUGIN_RC_KO`: Funktion fehlgeschlagen

- `PLUGIN_RC_OK`: Funktion erfolgreich beendet

Beispiel:

    int my_event (t_weechat_plugin *plugin, int argc, char **argv,
                  char *handler_args, void *handler_pointer)
    {
        plugin->print (plugin, NULL, NULL, "my_event");
        return PLUGIN_RC_OK;
    }
    ...
    t_plugin_handler *event_handler;
    event_handler = plugin->event_handler_add (plugin, "buffer_open",
                                               &my_event);

## handler_remove

Prototyp: `void handler_remove (t_weechat_plugin *plugin, t_plugin_handler *handler)`

Entfernt einen Nachrichten- oder Kommando-Handler.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `handler`: Handler, der entfernt werden soll

Rückgabewert: keiner

Beispiel:

    plugin->handler_remove (plugin, my_handler);

## handler_remove_all

Prototyp: `void handler_remove_all (t_weechat_plugin *plugin)`

Entfernt alle Handler eines Plugins.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

Rückgabewert: keiner

Beispiel:

    plugin->handler_remove_all (plugin);

## modifier_add

Prototyp: `t_plugin_modifier *modifier_add (t_weechat_plugin *plugin, char *type, char *message, t_plugin_modifier_func *function, char *modifier_args, void *modifier_pointer)`

Füge einen Nachrichtenmodifikator hinzu.

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

- `type`: Modifikatorart:

  Art | Beschreibung
  --- | ---
  `irc_in` | wird bei eingehenden IRC-Nachrichten aufgerufen
  `irc_user` | wird bei jeder Benutzernachricht (oder Befehl) aufgerufen (bevor WeeChat die Nachricht parst)
  `irc_out` | wird unmittelbar vor dem Abschicken einer ausgehenden Nachricht an den IRC-Server aufgerufen (auch bei Nachrichten, die WeeChat automatisch an den Server sendet)

- `message`: Name der IRC-Nachricht (wird nur bei den Arten "irc_in" and "irc_out" benutzt) Um eine Liste der IRC-Nachrichten zu erhalten, lies bitte folgende Dokumente:RFCs 1459 and 2812. Außerdem gibt es den Wert "*", der alle Nachrichten anspricht (ohne Filter).

- `function`: aufgerufene Funktion

  Folgender Prototyp wird dafür benutzt: `int my_function (t_weechat_plugin *plugin, int argc, char **argv, char *modifier_args, void *modifier_pointer)`

  Argument argc hat den Wert 2, folgende Werte sind in dem argv-Array:

  - argv[0] = Servername

  - argv[1] = Nachricht

- `modifier_args`: an die Funktion übergebene Werte

- `modifier_pointer`: an die Funktion übergebener Zeiger

Rückgabewert: Zeiger auf den neuen Nachrichtenmodifikator

Anmerkung: Die Funktion muss die veränderte Zeichenkette oder NULL (wenn keine Änderungen erfolgten) zurückgeben. Wenn die Funktion eine leere Zeichenkette zurückgibt, wird die Nachricht komplett verworfen und nicht weiter von WeeChat verarbeitet. (Seien Sie vorsichtig mit dem Verwerfen von Nachrichten!) Die zurückgegebene Zeichenkette muss mit malloc() zugewiesen worden sein und wird von WeeChat nach Gebrauch automatisch mit free() wieder freigegeben.

Beispiel:

    char *adder (t_weechat_plugin *plugin, int argc, char **argv,
                 char *modifier_args, void *modifier_pointer)
    {
        char *string;
        string = malloc (strlen (argv[1]) + 16);
        strcpy (string, argv[1]);
        strcat (string, "test");
        return string;
    }
    ...
    t_plugin_modifier *modifier;
    modifier = plugin->modifier_add (plugin, "irc_in", "privmsg",
                                     &adder, NULL, NULL);

## modifier_remove

Prototyp: `void modifier_remove (t_weechat_plugin *plugin, t_plugin_modifier *modifier)`

Entfernt einen Nachrichtenmodifikator.

Arguments:

- `plugin`: Zeiger auf Plugin-Struktur

- `modifier`: zu entfernender Modifikator

Rückgabewert: keiner

Beispiel:

    plugin->modifier_remove (plugin, my_modifier);

## modifier_remove_all

Prototyp: `void modifier_remove_all (t_weechat_plugin *plugin)`

Entfernt alle Modifikatoren für ein Plugin.

Argumente:

- `plugin`: Zeiger auf Plugin-Struktur

Rückgabewert: keiner

Beispiel:

    plugin->modifier_remove_all (plugin);

## exec_command

Prototyp: `void exec_command (t_weechat_plugin *plugin, char *server, char *channel, char *command)`

Führe ein WeeChat-Kommando aus (oder sende eine Nachricht an einen Channel).

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `server`: interner Name des Servers, auf den das Kommando angewendet werden soll (kann NULL sein)

- `channel`: Name des Channels, auf den das Kommando angewendet werden soll (kann NULL sein)

- `command`: Kommando

Rückgabewert: keiner

Beispiel:

    plugin->exec_command (plugin, NULL, NULL, "/help nick");
    plugin->exec_command (plugin, "freenode", "#weechat", "hello");

## get_info

Prototyp: `char *get_info (t_weechat_plugin *plugin, char *info, char *server)`

Gib eine Information über WeeChat oder einen Channel zurück.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `info` : Name (Typ) der Information:

  Info | Beschreibung
  --- | ---
  `version` | WeeChats Version
  `nick` | Nickname
  `channel` | Name des Channels (NULL bei einem Server oder Privatchat)
  `server` | Name des Servers
  `type` | Puffertyp: 0=standard, 1=DCC, 2=raw IRC data
  `away` | Status des "away"-Flags
  `inactivity` | Anzahl der Sekunden seit der letzten Tastenbetätigung
  `input` | Inhalt der Kommandozeile im gegenwärtigen Fenster
  `input_mask` | Inhalt der Farbmaske für die Kommandozeile
  `input_pos` | Position des Cursors in der Kommandozeile
  `weechat_dir` | WeeChat-Verzeichnis (Standard: ~/.weechat/)
  `weechat_libdir` | WeeChat-Systemverzeichnis (Bibliotheken)
  `weechat_sharedir` | WeeChat-Systemverzeichnis (gemeinsame Dateien)

- `server`: interner Name des Servers um Informationen zu lesen (wenn benötigt)

Rückgabewert: angeforderte Information oder NULL

Hinweis: das Ergebnis muss nach Nutzung mit "free" wieder freigegeben werden.

Beispiele:

    char *version = plugin->get_info (plugin, "version", NULL);
    char *nick = plugin->get_info (plugin, "nick", "freenode");
    char *inactivity = plugin->get_info (plugin, "inactivity", NULL);

    plugin->print (plugin, NULL, NULL,
                   "WeeChat version %s, you are %s on freenode "
                   "(inactive for %s seconds)",
                   version, nick, inactivity);

    if (version)
    	free (version);
    if (nick)
    	free (nick);
    if (inactivity)
    	free (inactivity);

## get_dcc_info

Prototyp: `t_plugin_info_dcc *get_dcc_info (t_weechat_plugin *plugin)`

Gib eine Liste der aktiven oder beendeten DCCs zurück.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

Rückgabewert: verkettete Liste von DCCs.

Typ | Feld | Beschreibung
--- | --- | ---
char * | `server` | IRC Server
char * | `channel` | IRC Channel
int | `type` | DCC Typ: 0 = Chatanfrage empfangen, 1 = Chatanfrage gesendet, 2 = Datei empfangen, 3 = Datei gesendet
int* | `status` | DCC Status: 0 = wartend, 1 = verbindend, 2 = aktiv, 3 = beendet, 4 = fehlgeschlagen, 5 = unterbrochen durch Anwender
time_t | `start_time` | Datum/Zeit der Erzeugung der DCC
time_t | `start_transfer` | Datum/Zeit des Beginns der Übertragung der DCC
unsigned long | `addr` | IP-Adresse des Partners
int | `port` | Port der DCC
char * | `nick` | Nickname des Partners
char * | `filename` | Dateiname
char * | `local_filename` | lokaler Dateiname
int | `filename_suffix` | Suffix wenn die Datei umbenannt wird
unsigned long | `size` | Dateigrösse
unsigned long | `pos` | Position in Datei
unsigned long | `start_resume` | Startposition nach einer Unterbrechung
unsigned long | `bytes_per_sec` | Übertragungsrate (Bytes/s) seit Beginn der Übertragung
t_plugin_dcc_info * | `prev_dcc` | Zeiger auf voheriges DCC-Info
t_plugin_dcc_info * | `next_dcc` | Zeiger auf nächstes DCC-Info

Hinweis: Das Ergebnis muss nach der Benutzung mittels "free_dcc_info" wieder freigegeben werden.

Beispiele:

    t_plugin_dcc_info *dcc_info = plugin->get_dcc_info (plugin);
    for (ptr_dcc = dcc_info; ptr_dcc; ptr_dcc = ptr_dcc->next_dcc)
    {
        plugin->print_server (plugin, "DCC type=%d, with: %s",
                              ptr_dcc->type, ptr_dcc->nick);
    }
    if (dcc_info)
        plugin->free_dcc_info (plugin, dcc_info);

## free_dcc_info

Prototyp: `void free_dcc_info (t_weechat_plugin *plugin, t_plugin_dcc_info *dcc_info)`

Gibt den Speicher einer Liste von DCC-Infos wieder frei.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `dcc_info`: Zeiger auf eine Liste mit DCC-Infos, die mit "get_dcc_info" angelegt wurde

Rückgabewert: keiner.

Beispiel:

    plugin->free_dcc_info (plugin, dcc_info);

## get_server_info

Prototyp: `t_plugin_server_info *get_server_info (t_weechat_plugin *plugin)`

Gibt die Liste von IRC-Servern zurück (verbunden oder nicht)

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

Rückgabewert: Liste von IRC-Servern.

Typ | Feld | Beschreibung
--- | --- | ---
char * | `name` | interner Servername
int | `autoconnect` | 1 wenn Autoconnect gesetzt ist, 0 sonst
int | `autoreconnect` | 1 wenn autoreconnect gesetzt ist, 0 sonst
int | `autoreconnect_delay` | Wartezeit vor erneutem Verbindungsversuch
int | `command_line` | 1 wenn der Servername auf der Kommandozeile angegeben wurde (ist somit temporär) 0 sonst
char * | `address` | Serveradresse (Name oder IP)
int | `port` | Port
int | `ipv6` | IPv6-Verbindung
int | `ssl` | SSL-Verbindung
char * | `password` | Passwort
char * | `nick1` | primärer Nickname
char * | `nick2` | alternativer Nickname
char * | `nick3` | zweiter, alternativer Nickname
char * | `username` | Username
char * | `real name` | tatsächlicher Name
char * | `command` | Kommando, dass bei erfolgreicher Verbindung ausgeführt wurde
int | `command_delay` | Verzögerung nach Ausführung des Kommandos
char * | `autojoin` | Channels, die automatisch betreten werden sollen
int | `autorejoin` | 1 wenn Channels wieder betreten werden sollen, nachdem man gekickt wurde 0 sonst
char * | `notify_levels` | Benachrichtigungs-Level von Channels
char * | `charset_decode_iso` | Zeichensatz zum Dekodieren von ISO
char * | `charset_decode_utf` | Zeichensatz zum Dekodieren von UTF
char * | `charset_encode` | Zeichensatz der Channels zum Kodieren von Nachrichten
int | `is_connected` | 1 wenn verbunden mit einem Server, 0 otherwise
int | `ssl_connected` | 1 wenn verbunden über SSL, 0 sonst
char * | `nick` | gegenwärtiger Nickname
int | `is_away` | 1 wenn away-flag gesetzt ist, 0 sonst
time_t | `away_time` | Zeitspanne seit away-flag gesetzt ist
int | `lag` | Lag (in Millisekunden)
t_plugin_server_info * | `prev_server` | Zeiger auf vorherigen Knoten der Liste
t_plugin_server_info * | `next_server` | Zeiger auf nächsten Knoten der Liste

Hinweis: das Ergebnis muss nach der Benutzung mit "free_server_info" wieder freigegeben werden.

Beispiel:

    t_plugin_server_info *server_info, *ptr_server_info;
    server_info = plugin->get_server_info (plugin);
    if (server_info)
    {
        for (ptr_server_info = server_info; ptr_server_info;
             ptr_server_info = ptr_server_info->next_server)
        {
            plugin->print (plugin, NULL, NULL,
                           "server: %s, address: %s, port: %d %s",
                           ptr_server_info->name,
                           ptr_server_info->address,
                           ptr_server_info->port,
                           (ptr_server_info->is_connected) ? "(connected)" : "");
        }
        plugin->free_server_info (plugin, server_info);
    }

## free_server_info

Prototyp: `void free_server_info (t_weechat_plugin *plugin, t_plugin_server_info *server_info)`

Gib den Speicher einer Liste "server info" frei

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `server_info`: Zeiger auf eine Server-Liste, der von der Funktion "get_server_info" zurückgegeben wurde.

Rückgabewert: keiner.

Beispiel:

    plugin->free_server_info (plugin, server_info);

## get_channel_info

Prototyp: `t_plugin_channel_info *get_channel_info (t_weechat_plugin *plugin, char *server)`

Gib eine Liste der Channels für einen Server zurück.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `server`: interner Name des Server

Rückgabewert: verkettete Liste von Channels für einen Server.

Typ | Feld | Beschreibung
--- | --- | ---
int | `type` | 0 für einen normalen Channel, 1 für einen Privaten
char * | `name` | Name des Channels
char * | `topic` | Topic des Channels
char * | `modes` | Channelmodus (Flags)
int | `limit` | Anzahl der erlaubten User
char * | `key` | Schlüssel des Channels
int | `nicks_count` | Anzahl der Nicknamen des Channels
t_plugin_channel_info * | `prev_channel` | Zeiger auf vorherigem Knoten der Liste
t_plugin_channel_info * | `next_channel` | Zeiger auf nächsten Knoten der Liste

Hinweis: Das Ergebnis muss nach der Benutzung mit "free_channel_info" wieder freigegeben werden.

Beispiel:

    t_plugin_channel_info *channel_info, *ptr_chan_info;
    channel_info = plugin->get_channel_info (plugin, "freenode");
    if (channel_info)
    {
        for (ptr_chan_info = channel_info; ptr_chan_info;
             ptr_chan_info = ptr_chan_info->next_channel)
        {
            plugin->print (plugin, NULL, NULL,
                           "  %s (type %d)",
                           ptr_chan_info->name,
                           ptr_chan_info->type);
        }
        plugin->free_channel_info (plugin, channel_info);
    }

## free_channel_info

Prototyp: `void free_channel_info (t_weechat_plugin *plugin, t_plugin_channel_info *channel_info)`

Gibt den Speicher einer Liste "channel info" wieder frei.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `channel_info`: Zeiger auf eine Liste "channel info", der von "get_channel_info" zurückgegeben wurde

Rückgabewert: keiner.

Beispiel:

    plugin->free_channel_info (plugin, channel_info);

## get_nick_info

Prototyp: `t_plugin_nick_info *get_nick_info (t_weechat_plugin *plugin, char *server, char *channel)`

Gib eine Liste der Nicknamen für einen Channel zurück.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `server`: interner Name des Servers

- `channel`: Name des Channels

Rückgabewert: verkettete Liste von Nicknamen eines Channels.

Typ | Feld | Beschreibung
--- | --- | ---
char * | `nick` | Nickname
char * | `host` | Hostname
int | `Flags` | Flags, die für einen Nicknamen gesetzt sind: Zweierpotenzen "oder" Zwischenwerte (1 = channel owner, 2 = channel admin, 4 = op, 8 = halfop, 16 = voice, 32 = away)
t_plugin_nick_info * | `prev_nick` | Zeiger auf vorherigen Knoten der Liste
t_plugin_nick_info * | `next_nick` | Zeiger auf nächsten Knoten der Liste

Hinweis: Das Ergebnis muss nach der Benutzung mit "free_nick_info" wieder freigegeben werden.

Beispiel:

    t_plugin_nick_info *nick_info, *ptr_nick_info;
    nick_info = plugin->get_nick_info (plugin, "freenode", "#weechat");
    if (nick_info)
    {
        for (ptr_nick_info = nick_info; ptr_nick_info;
             ptr_nick_info = ptr_nick_info->next_nick)
        {
            plugin->print (plugin, NULL, NULL,
                           "  %s (flags: %d)",
                           ptr_nick_info->nick,
                           ptr_nick_info->flags);
        }
        plugin->free_nick_info (plugin, nick_info);
    }

## free_nick_info

Prototyp: `void free_nick_info (t_weechat_plugin *plugin, t_plugin_nick_info *nick_info)`

Gibt den Speicher einer Liste "nick info" frei.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `nick_info`: Zeiger auf eine Liste "nick info", der von "get_nick_info" zurückgegeben wurde

Rückgabewert: keiner.

Beispiel:

    plugin->free_nick_info (plugin, nick_info);

## get_config

Prototyp: `char *get_config (t_weechat_plugin *plugin, char *option)`

Gibt den Wert einer Option der WeeChat-Konfiguration zurück.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `option`: Name der Option

Rückgabewert: Wert der Option, oder NULL, wenn nichts gefunden wurde.

Hinweis: Das Ergebnis muss nach der Benutzung mit "free" wieder freigegeben werden.

Beispiel:

    char *value1 = plugin->get_config (plugin, "look_set_title");
    char *value2 = plugin->get_config (plugin, "freenode.server_autojoin");

## set_config

Prototyp: `int set_config (t_weechat_plugin *plugin, char *option, char *value)`

Setze den Wert einer Option der WeeChat-Konfiguration.

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `option`: Name der Option

- `value`: der neue Wert der Option

Rückgabewert: 1 wenn der Wert der Option gesetzt werden konnte, 0 bei Auftreten eines Fehlers.

Beispiel:

    plugin->set_config (plugin, "look_nicklist", "off");

## get_plugin_config

Prototyp: `char *get_plugin_config (t_weechat_plugin *plugin, char *option)`

Gibt den Wert einer Option eines Plugins zurück. Die Option wird aus "`~/.weechat/plugins.rc`" gelesen und sieht so aus: "`plugin.option=value`" (Hinweis: der Name des Plugins wird automatisch gesetzt).

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `option`: Name der Option

Rückgabewert: Wert der Option, NULL wenn nichts gefunden wurde.

Hinweis: Das Ergebnis muss nach der Benutzung mit "free" wieder freigegeben werden.

Beispiel:

    char *value = plugin->get_plugin_config (plugin, "my_var");

## set_plugin_config

Prototyp: `int set_plugin_config (t_weechat_plugin *plugin, char *option, char *value)`

Setzt den Wert einer Option eines Plugins. Die Option wird in die Datei "`~/.weechat/plugins.rc`" geschrieben und sieht so aus: "`plugin.option=value`" (Hinweis: der Name des Plugins wird automatisch gesetzt)

Argumente:

- `plugin`: Zeiger auf eine Plugin-Struktur

- `option`: Name der Option, die gesetzt werden soll

- `value`: Wert der zu setzenden Option

Rückgabewert: 1 wenn die Option gesetzt werden konnte, 0 wenn ein Fehler aufgetreten ist.

Beispiel:

    plugin->set_plugin_config (plugin, "my_var", "value");

## get_irc_color

Prototype: `int get_irc_color (t_weechat_plugin *plugin, char *color_name)`

Hole IRC-Farbindex mit dem Farbnamen.

Argumente:

- `plugin`: Zeiger auf die Pluginstruktur

- `color_name`: Farbname Folgende Farben sind erlaubt:

  Farbname | Wert
  --- | ---
  white | 0
  black | 1
  blue | 2
  green | 3
  lightred | 4
  red | 5
  magenta | 6
  brown | 7
  yellow | 8
  lightgreen | 9
  cyan | 10
  lightcyan | 11
  lightblue | 12
  lightmagenta | 13
  gray | 14
  lightgray | 15

Rückgabewert: IRC-Farbindex, -1 wenn die Farbe nicht gefunden wurde.

Beispiel:

    int color_blue = plugin->get_irc_color (plugin, "blue"); /* return 2 */

## input_color

Prototyp: `void input_color (t_weechat_plugin *plugin, int color, int start, int length)`

Erzeugt einen Farbcode im Eingabepuffer.

Argumente:

- `plugin`: Zeiger auf die Pluginstruktur

- `color`: Textfarbe (wenn der Wert < 0 ist, dann wird der Eingabepuffer aufgefrischt und nicht verändert)

- `start`: Startposition für Einfärbung (wenn der Wert < 0 ist, wird die Maske neu initialisiert)

- `length`: Länge der Einfärbung (wenn der Wert <= 0 ist, wird die Maske neu initialisiert)

Rückgabewert: keiner.

Beispiele:

    plugin->input_color (plugin, plugin->get_irc_color (plugin, "blue"), 10, 5);

## get_window_info

Prototype: `t_plugin_window_info *get_window_info (t_weechat_plugin *plugin)`

Gibt die Liste der WeeChat-Fenster zurück.

Argumente:

- `plugin`: Zeiger auf Pluginstruktur

Rückgabewert: verkettete Liste der WeeChat-Fenster.

Typ | Feld | Beschreibung
--- | --- | ---
int | `win_x` | horizontale Fensterposition
int | `win_y` | vertikale Fensterposition
int | `win_width` | Fensterbreite
int | `win_height` | Fensterhöhe
int | `win_width_pct` | Breite in % (im Vergleich zum übergeordneten Fenster)
int | `win_height_pct` | Höhe % (im Vergleich zum übergeordneten Fenster)
int | `num_buffer` | Anzahl der angezeigten Puffer
t_plugin_window_info * | `prev_window` | Zeiger auf die Informationen des vorhergehenden Fensters
t_plugin_window_info * | `next_window` | Zeiger auf die Informationen des nächsten Fensters

Anmerkung: Das Ergebnis muss nach Benutzung durch einen Aufruf der "free_window_info"-Funktion gelöscht werden.

Example:

    t_plugin_window_info *window_info, *ptr_window;

    window_info = plugin->get_window_info (plugin);
    if (window_info)
    {
        for (ptr_window = window_info; ptr_window; ptr_window = ptr_window->next_window)
        {
            plugin->print (plugin, NULL, NULL, "--- window info ---");
            plugin->print (plugin, NULL, NULL, "(%d,%d), size: %dx%d, %%size: %d%%x%d%%",
                           ptr_window->win_x, ptr_window->win_y,
                           ptr_window->win_width, ptr_window->win_height,
                           ptr_window->win_width_pct, ptr_window->win_height_pct);
            plugin->print (plugin, NULL, NULL, "num_buffer: %d", ptr_window->num_buffer);
        }
        plugin->free_window_info (plugin, window_info);
    }
    else
        plugin->print (plugin, NULL, NULL, "no window info!");

## free_window_info

Prototyp: `void free_window_info (t_weechat_plugin *plugin, t_plugin_window_info *window_info)`

Gibt den Speicher wieder frei, der von der Fenster-Informationsliste belegt wird.

Argumente:

- `plugin`: Zeiger auf Pluginstruktur

- `window_info`: Zeiger auf Fenster-Informationsliste, der von der "get_window_info"-Funktion zurückgegeben wurde

Rückgabewert: keiner.

Beispiel:

    plugin->free_window_info (plugin, window_info);

## get_buffer_info

Prototyp: `t_plugin_buffer_info *get_buffer_info (t_weechat_plugin *plugin)`

Gibt eine Liste der WeeChat-Puffer zurück.

Argumente:

- `plugin`: Zeiger auf Pluginstruktur

Rückgabewert: verkettete Liste der WeeChat-Puffer.

Typ | Feld | Beschreibung
--- | --- | ---
int | `type` | Puffertyp: 0=standard, 1=DCC, 2=raw IRC data
int | `number` | Puffer-Nummer
int | `num_displayed` | Anzahl der Fenster im Puffer
char * | `server_name` | Servername für den Puffer (kann NULL sein)
char * | `channel_name` | Channelname für den Puffer (kann NULL sein)
int | `notify_level` | Benachrichtigungslevel für den Puffer
char * | `log_filename` | Name der Logdatei (NULL bedeutet, dass nichts geloggt wird)
t_plugin_buffer_info * | `prev_buffer` | Zeiger auf die vorhergehenden Pufferinformationen
t_plugin_buffer_info * | `next_buffer` | Zeiger auf die nächsten Pufferinformationen

Bemerkung: Das Ergebnis muss nach der Auswertung mit der "free_buffer_info"-Funktion wieder gelöscht werden.

Beispiel:

    t_plugin_buffer_info *buffer_info, *ptr_buffer;

    buffer_info = plugin->get_buffer_info (plugin);
    if (buffer_info)
    {
        for (ptr_buffer = buffer_info; ptr_buffer; ptr_buffer = ptr_buffer->next_buffer)
        {
            plugin->print (plugin, NULL, NULL, "--- buffer info ---");
            plugin->print (plugin, NULL, NULL, "type: %d", ptr_buffer->type);
            plugin->print (plugin, NULL, NULL, "number: %d", ptr_buffer->number);
            plugin->print (plugin, NULL, NULL, "num_displayed: %d", ptr_buffer->num_displayed);
            plugin->print (plugin, NULL, NULL, "server: %s", ptr_buffer->server_name);
            plugin->print (plugin, NULL, NULL, "channel: %s", ptr_buffer->channel_name);
            plugin->print (plugin, NULL, NULL, "notify level: %d", ptr_buffer->notify_level);
            plugin->print (plugin, NULL, NULL, "log filename: %s", ptr_buffer->log_filename);
        }
        plugin->free_buffer_info (plugin, buffer_info);
    }
    else
        plugin->print (plugin, NULL, NULL, "no buffer info!");

## free_buffer_info

Prototyp: `void free_buffer_info (t_weechat_plugin *plugin, t_plugin_buffer_info *buffer_info)`

Gibt den Speicher frei, der von der Puffer-Informationsliste belegt wird.

Argumente:

- `plugin`: Zeiger auf Pluginstruktur

- `buffer_info`: pointer to buffer info list returned by "get_buffer_info" function

Rückgabewert: keiner.

Beispiel:

    plugin->free_buffer_info (plugin, buffer_info);

## get_buffer_data

Prototype: `t_plugin_buffer_data *get_buffer_info (t_weechat_plugin *plugin, char *server, char *channel)`

Gibt den Inhalt des Puffers zurück.

Argumente:

- `plugin`: Zeiger auf Pluginstruktur

- `server`: interner Name des Servers

- `channel`: Channelname

Rückgabewert: Pufferinhalt (verkettete Liste mit den Zeilen).

Typ | Feld | Beschreibung
--- | --- | ---
time_t | `date` | Datum/Zeit
char * | `nick` | Nick
char * | `data` | Zeileninhalt (Farbcodes wurden entfernt)
t_plugin_buffer_line * | `prev_line` | Zeiger auf die vorherige Zeile
t_plugin_buffer_line * | `next_line` | Zeiger auf die nächste Zeile

Bemerkung: Das Ergebnis muss nach der Auswertung mit der "free_buffer_data"-Funktion wieder gelöscht werden.

Example:

    t_plugin_buffer_line *buffer_line, *ptr_line;
    char text_time[256];

    buffer_line = plugin->get_buffer_data (plugin);
    if (buffer_line)
    {
        for (ptr_line = buffer_line; ptr_line; ptr_line = ptr_line->next_line)
        {
            strftime (text_time, sizeof (text_time), "%x %X", localtime (&(ptr_line->date)));
            plugin->print (plugin, NULL, NULL, "date: %s, nick: %s, data: %s",
                           text_time, ptr_line->nick, ptr_line->data);
        }
        plugin->free_buffer_data (plugin, buffer_line);
    }

## free_buffer_data

Prototype: `void free_buffer_data (t_weechat_plugin *plugin, t_plugin_buffer_line *buffer_line)`

Gibt den Speicher frei, der von den Pufferzeilen belegt wurde.

Arguments:

- `plugin`: Zeiger auf Pluginstruktur

- `buffer_line`: Zeiger auf Pufferzeilen, der von der "get_buffer_data"-Funktion zurückgegeben wurde

Rückgabewert: keiner.

Beispiele:

    plugin->free_buffer_data (plugin, buffer_line);

-->