getsubopt(3)               Library Functions Manual               getsubopt(3)

NUME
       getsubopt - analizeaza argumentele subop<?>iunii dintr-un <?>ir de
       caractere

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

SINOPSIS
       #include <stdlib.h>

       int getsubopt(char **restrict optionp, char *const *restrict tokens,
                     char **restrict valuep);

   Cerin<?>e pentru macrocomenzi de testare a caracteristicilor pentru glibc
   (consulta<?>i feature_test_macros(7)):

       getsubopt():
           _XOPEN_SOURCE >= 500
               || /* Incepand cu glibc 2.12: */ _POSIX_C_SOURCE >= 200809L

DESCRIERE
       getsubopt() analizeaza lista de subop<?>iuni separate prin virgule
       furnizate in optionp. O astfel de lista de subop<?>iuni este produsa de
       obicei atunci cand getopt(3) este utilizat pentru a analiza o linie de
       comanda; a se vedea, de exemplu, op<?>iunea -o din mount(8). Fiecare
       subop<?>iune poate include o valoare asociata, care este separata de
       numele subop<?>iunii printr-un semn egal. Urmatorul este un exemplu al
       tipului de <?>ir de caractere care ar putea fi trecut in optionp:

           ro,nume=xyz

       Argumentul tokens este un indicator catre o matrice cu termina<?>ie
       NULL de indicatori catre token-urile pe care getsubopt() le va cauta in
       optionp. Token-urile trebuie sa fie <?>iruri distincte, cu termina<?>ie
       nula, care con<?>in cel pu<?>in un caracter, fara semne egale sau
       virgule incorporate.

       Fiecare apel la getsubopt() returneaza informa<?>ii despre urmatoarea
       subop<?>iune neprocesata din optionp. Primul semn egal dintr-o
       subop<?>iune (daca exista) este interpretat ca un separator intre
       numele <?>i valoarea subop<?>iunii respective. Valoarea se extinde pana
       la urmatoarea virgula sau (pentru ultima subop<?>iune) pana la
       sfar<?>itul <?>irului. Daca numele subop<?>iunii corespunde unui nume
       cunoscut din tokens <?>i a fost gasit un <?>ir de valori, getsubopt()
       stabile<?>te *valuep la adresa <?>irului respectiv. Prima virgula din
       optionp este suprascrisa cu un octet nul, astfel incat *valuep este
       exact ,,<?>irul de valori" pentru subop<?>iunea respectiva.

       Daca subop<?>iunea este recunoscuta, dar nu a fost gasit niciun <?>ir
       de valori, *valuep este stabilita la NULL.

       Cand getsubopt() returneaza, optionp indica urmatoarea subop<?>iune sau
       octetul nul (,,\0") de la sfar<?>itul <?>irului daca ultima
       subop<?>iune tocmai a fost procesata.

VALOAREA RETURNATA
       Daca prima subop<?>iune din optionp este recunoscuta, getsubopt()
       returneaza indexul elementului de subop<?>iune corespunzator din
       tokens. In caz contrar, se returneaza -1, iar *valuep este intregul
       <?>ir nume[=valoare].

       Deoarece *optionp este modificata, prima subop<?>iune inainte de apelul
       la getsubopt() nu este (neaparat) aceea<?>i cu prima subop<?>iune dupa
       getsubopt().

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |getsubopt()                           | Siguran<?>a firelor | MT-Safe |
       +--------------------------------------+---------------------+---------+
STANDARDE
       POSIX.1-2008.

ISTORIC
       POSIX.1-2001.

NOTE
       Deoarece getsubopt() suprascrie orice virgula pe care o gase<?>te in
       <?>irul *optionp, acel <?>ir trebuie sa poata fi scris; nu poate fi o
       constanta de <?>ir.

EXEMPLE
       Urmatorul program a<?>teapta subop<?>iuni dupa o op<?>iune ,,-o".

       #define _XOPEN_SOURCE 500
       #include <stdio.h>
       #include <stdlib.h>

       #include <assert.h>

       int
       main(int argc, char *argv[])
       {
           enum {
               RO_OPT = 0,
               RW_OPT,
               NAME_OPT
           };
           char *const token[] = {
               [RO_OPT]   = "ro",
               [RW_OPT]   = "rw",
               [NAME_OPT] = "name",
               NULL
           };
           char *subopts;
           char *value;
           int opt;

           int readonly = 0;
           int readwrite = 0;
           char *name = NULL;
           int errfnd = 0;

           while ((opt = getopt(argc, argv, "o:")) != -1) {
               switch (opt) {
               case 'o':
                   subopts = optarg;
                   while (*subopts != '\0' && !errfnd) {

                       switch (getsubopt(&subopts, token, &value)) {
                       case RO_OPT:
                           readonly = 1;
                           break;

                       case RW_OPT:
                           readwrite = 1;
                           break;

                       case NAME_OPT:
                           if (value == NULL) {
                               fprintf(stderr,
                                       "Lipse<?>te valoarea pentru subop<?>iunea '%s'\n",
                                       token[NAME_OPT]);
                               errfnd = 1;
                               continue;
                           }

                           name = value;
                           break;

                       default:
                           fprintf(stderr,
                                   "Nu s-a gasit nicio potrivire pentru token: /%s/\n", value);
                           errfnd = 1;
                           break;
                       }
                   }
                   if (readwrite && readonly) {
                       fprintf(stderr,
                               "Doar una dintre '%s' <?>i '%s' poate fi specificata\n",
                               token[RO_OPT], token[RW_OPT]);
                       errfnd = 1;
                   }
                   break;

               default:
                   errfnd = 1;
               }
           }

           if (errfnd || argc == 1) {
               fprintf(stderr, "\nUtilizare: %s -o <<?>ir-subop<?>iune>\n", argv[0]);
               fprintf(stderr,
                       "subop<?>iunile sunt 'ro', 'rw', <?>i 'nume=<valoare>'\n");
               exit(EXIT_FAILURE);
           }

           /* Restul programului... */

           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       getopt(3)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.9.1  15 iunie 2024                    getsubopt(3)