# Translation of bison to Croatian.
# Copyright © 2002, 2012 Free Software Foundation, Inc.
# This file is distributed under the same license as the bison package.
# Denis Lackovic <delacko@fly.srk.fer.hr>, 2002.
# Tomislav Krznar <tomislav.krznar@gmail.com>, 2012.
#
msgid ""
msgstr ""
"Project-Id-Version: bison 2.6.5\n"
"Report-Msgid-Bugs-To: bug-bison@gnu.org\n"
"POT-Creation-Date: 2012-12-12 16:09+0100\n"
"PO-Revision-Date: 2012-11-09 16:52+0100\n"
"Last-Translator: Tomislav Krznar <tomislav.krznar@gmail.com>\n"
"Language-Team: Croatian <lokalizacija@linux.hr>\n"
"Language: hr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
"%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
"X-Generator: Lokalize 1.4\n"

#: src/complain.c:120 src/complain.c:131 src/complain.c:140 src/complain.c:188
#: src/complain.c:198
msgid "warning"
msgstr "upozorenje"

#: src/complain.c:151 src/complain.c:160 src/complain.c:167
#, fuzzy
msgid "error"
msgstr "U/I greška"

#: src/complain.c:208 src/complain.c:215
msgid "fatal error"
msgstr "fatalna greška"

#: src/conflicts.c:77
#, c-format
msgid "    Conflict between rule %d and token %s resolved as shift"
msgstr "    Konflikt između pravila %d i simbola %s razriješen kao pomak"

#: src/conflicts.c:86
#, c-format
msgid "    Conflict between rule %d and token %s resolved as reduce"
msgstr "    Konflikt između pravila %d i simbola %s razriješen kao redukcija"

#: src/conflicts.c:94
#, c-format
msgid "    Conflict between rule %d and token %s resolved as an error"
msgstr "    Konflikt između pravila %d i simbola %s razriješen kao greška"

#: src/conflicts.c:492
#, c-format
msgid "conflicts: %d shift/reduce, %d reduce/reduce\n"
msgstr "konflikti: %d pomakni/reduciraj, %d reduciraj/reduciraj\n"

#: src/conflicts.c:495
#, c-format
msgid "conflicts: %d shift/reduce\n"
msgstr "konflikti: %d pomakni/reduciraj\n"

#: src/conflicts.c:497
#, c-format
msgid "conflicts: %d reduce/reduce\n"
msgstr "konflikti: %d reduciraj/reduciraj\n"

#: src/conflicts.c:515
#, c-format
msgid "State %d "
msgstr "Stanje %d "

#: src/conflicts.c:582
#, c-format
msgid "%%expect-rr applies only to GLR parsers"
msgstr "%%expect-rr se primjenjuje samo na GLR analizatore"

#: src/conflicts.c:616
#, c-format
msgid "expected %d shift/reduce conflict"
msgid_plural "expected %d shift/reduce conflicts"
msgstr[0] "očekujem %d pomakni/reduciraj konflikt"
msgstr[1] "očekujem %d pomakni/reduciraj konflikta"
msgstr[2] "očekujem %d pomakni/reduciraj konflikata"

#: src/conflicts.c:621
#, c-format
msgid "expected %d reduce/reduce conflict"
msgid_plural "expected %d reduce/reduce conflicts"
msgstr[0] "očekujem %d reduciraj/reduciraj konflikt"
msgstr[1] "očekujem %d reduciraj/reduciraj konflikta"
msgstr[2] "očekujem %d reduciraj/reduciraj konflikata"

#: src/files.c:114
#, c-format
msgid "%s: cannot open"
msgstr "%s: ne mogu otvoriti"

#: src/files.c:130
#, c-format
msgid "input/output error"
msgstr "ulazno/izlazna greška"

#: src/files.c:133
#, c-format
msgid "cannot close file"
msgstr "ne mogu zatvoriti datoteku"

#: src/files.c:352
#, c-format
msgid "refusing to overwrite the input file %s"
msgstr "odbijam pisati preko ulazne datoteke %s"

#: src/files.c:362
#, c-format
msgid "conflicting outputs to file %s"
msgstr "konfliktni izlazi u datoteku %s"

#: src/getargs.c:292
#, c-format
msgid "Try `%s --help' for more information.\n"
msgstr "Pokušajte „%s --help” za više informacija.\n"

#: src/getargs.c:301
#, c-format
msgid "Usage: %s [OPTION]... FILE\n"
msgstr "Uporaba: %s [OPCIJA]... DATOTEKA\n"

#: src/getargs.c:302
msgid ""
"Generate a deterministic LR or generalized LR (GLR) parser employing\n"
"LALR(1), IELR(1), or canonical LR(1) parser tables.  IELR(1) and\n"
"canonical LR(1) support is experimental.\n"
"\n"
msgstr ""
"Stvori deterministički LR ili općeniti LR (GLR) analizator koji\n"
"koristi LALR(1), IELR(1) ili kanonske LR(1) tablice analize.\n"
"Podrška za IELR(1) i kanonski LR(1) je eksperimentalna.\n"
"\n"

#: src/getargs.c:309
msgid ""
"Mandatory arguments to long options are mandatory for short options too.\n"
msgstr ""
"Obavezni argumenti dugačkih opcija također su obavezni za kratke opcije.\n"

#: src/getargs.c:312
msgid "The same is true for optional arguments.\n"
msgstr "Isto vrijedi i za opcionalne argumente.\n"

#: src/getargs.c:316
#, fuzzy
msgid ""
"\n"
"Operation modes:\n"
"  -h, --help                 display this help and exit\n"
"  -V, --version              output version information and exit\n"
"      --print-localedir      output directory containing locale-dependent "
"data\n"
"      --print-datadir        output directory containing skeletons and XSLT\n"
"  -y, --yacc                 emulate POSIX Yacc\n"
"  -W, --warnings[=CATEGORY]  report the warnings falling in CATEGORY\n"
"  -f, --feature[=FEATURE]    activate miscellaneous features\n"
"\n"
msgstr ""
"\n"
"Načini rada:\n"
"  -h, --help                 prikaži ovu pomoć i izađi\n"
"  -V, --version              ispiši informacije o inačici i izađi\n"
"      --print-localedir      ispiši direktorij s podacima ovisnima o lokalu\n"
"      --print-datadir        ispiši direktorij s predlošcima i XSLT-om\n"
"  -y, --yacc                 emuliraj POSIX Yacc\n"
"  -W, --warnings[=KATEGORIJA]  prijavi upozorenja iz KATEGORIJE\n"
"\n"

#: src/getargs.c:329
#, fuzzy, c-format
msgid ""
"Parser:\n"
"  -L, --language=LANGUAGE          specify the output programming language\n"
"  -S, --skeleton=FILE              specify the skeleton to use\n"
"  -t, --debug                      instrument the parser for debugging\n"
"      --locations                  enable location support\n"
"  -D, --define=NAME[=VALUE]        similar to '%define NAME \"VALUE\"'\n"
"  -F, --force-define=NAME[=VALUE]  override '%define NAME \"VALUE\"'\n"
"  -p, --name-prefix=PREFIX         prepend PREFIX to the external symbols\n"
"                                   deprecated by '-Dapi.prefix=PREFIX'\n"
"  -l, --no-lines                   don't generate '#line' directives\n"
"  -k, --token-table                include a table of token names\n"
msgstr ""
"Parser:\n"
"  -L, --language=JEZIK             navedi izlazni programski jezik\n"
"                                   (ovo je eksperimentalna mogućnost)\n"
"  -S, --skeleton=DATOTEKA          navedi predložak za korištenje\n"
"  -t, --debug                      pripremi analizator za ispravljanje "
"grešaka\n"
"      --locations                  omogući podršku za lokacije\n"
"  -D, --define=IME[=VRIJEDNOST]    slično kao „%define IME \"VRIJEDNOST\"”\n"
"  -F, --force-define=IME[=VRIJEDNOST]  promijeni „%define IME \"VRIJEDNOST"
"\"”\n"
"  -p, --name-prefix=PREFIKS        dodaj PREFIKS ispred vanjskih simbola\n"
"                                   zastarjelo zbog „-Dapi.prefix=PREFIKS”\n"
"  -l, --no-lines                   ne stvaraj „#line” propise\n"
"  -k, --token-table                uključi tablicu imena simbola\n"
"\n"

#: src/getargs.c:346
#, fuzzy
msgid ""
"Output:\n"
"      --defines[=FILE]       also produce a header file\n"
"  -d                         likewise but cannot specify FILE (for POSIX "
"Yacc)\n"
"  -r, --report=THINGS        also produce details on the automaton\n"
"      --report-file=FILE     write report to FILE\n"
"  -v, --verbose              same as `--report=state'\n"
"  -b, --file-prefix=PREFIX   specify a PREFIX for output files\n"
"  -o, --output=FILE          leave output to FILE\n"
"  -g, --graph[=FILE]         also output a graph of the automaton\n"
"  -x, --xml[=FILE]           also output an XML report of the automaton\n"
"                             (the XML schema is experimental)\n"
msgstr ""
"Izlaz:\n"
"      --defines[=DATOTEKA]   također napravi datoteku zaglavlja\n"
"  -d                         isto, bez navođenja datoteke (za POSIX Yacc)\n"
"  -r, --report=STVARI        također napravi pojedinosti o automatima\n"
"      --report-file=DATOTEKA spremi izvještaj u DATOTEKU\n"
"  -v, --verbose              isto kao „--report=state”\n"
"  -b, --file-prefix=PREFIKS  navedi PREFIKS za izlazne datoteke\n"
"  -o, --output=DATOTEKA      spremi izlaz u DATOTEKU\n"
"  -g, --graph[=DATOTEKA]     također ispiši graf automata\n"
"  -x, --xml[=DATOTEKA]       također ispiši XML izvještaj o automatu\n"
"                             (XML shema je eksperimentalna)\n"
"\n"

#: src/getargs.c:361
#, fuzzy
msgid ""
"Warning categories include:\n"
"  `midrule-values'  unset or unused midrule values\n"
"  `yacc'            incompatibilities with POSIX Yacc\n"
"  `conflicts-sr'    S/R conflicts (enabled by default)\n"
"  `conflicts-rr'    R/R conflicts (enabled by default)\n"
"  `deprecated'      obsolete constructs\n"
"  `other'           all other warnings (enabled by default)\n"
"  `all'             all the warnings\n"
"  `no-CATEGORY'     turn off warnings in CATEGORY\n"
"  `none'            turn off all the warnings\n"
"  `error'           treat warnings as errors\n"
msgstr ""
"Kategorije upozorenja uključuju:\n"
"  „midrule-values”  nepostavljene ili nekorištene midrule vrijednosti\n"
"  „yacc”            nekompatibilnosti za POSIX Yacc\n"
"  „conflicts-sr”    P/R konflikte (uobičajeno uključeno)\n"
"  „conflicts-rr”    R/R konflikte (uobičajeno uključeno)\n"
"  „other”           sva ostala upozorenja (uobičajeno uključeno)\n"
"  „all”             sva upozorenja\n"
"  „no-KATEGORIJA”   isključi upozorenja iz KATEGORIJE\n"
"  „none”            isključi sva upozorenja\n"
"  „error”           postupaj s upozorenjima kao s greškama\n"
"\n"

#: src/getargs.c:376
msgid ""
"THINGS is a list of comma separated words that can include:\n"
"  `state'        describe the states\n"
"  `itemset'      complete the core item sets with their closure\n"
"  `lookahead'    explicitly associate lookahead tokens to items\n"
"  `solved'       describe shift/reduce conflicts solving\n"
"  `all'          include all the above information\n"
"  `none'         disable the report\n"
msgstr ""
"STVARI su riječi odvojene zarezom koje mogu biti:\n"
"  „state”        opiši stanja\n"
"  „itemset”      dovrši osnovne skupove predmeta s njihovim zaključenjem\n"
"  „lookahead”    eksplicitno dodijeli „lookahead” simbole predmetima\n"
"  „solved”       opiši rješavanje pomakni/reduciraj konflikata\n"
"  „all”          uključi sve gore navedene informacije\n"
"  „none”         onemogući izvještaj\n"

#: src/getargs.c:387
msgid ""
"FEATURE is a list of comma separated words that can include:\n"
"  `caret'        show errors with carets\n"
"  `all'          all of the above\n"
"  `none'         disable all of the above\n"
"  "
msgstr ""

#: src/getargs.c:395
#, c-format
msgid "Report bugs to <%s>.\n"
msgstr "Prijavite greške na <%s>.\n"

#: src/getargs.c:396
#, c-format
msgid "%s home page: <%s>.\n"
msgstr "%s početna stranica: <%s>.\n"

#: src/getargs.c:397
msgid "General help using GNU software: <http://www.gnu.org/gethelp/>.\n"
msgstr ""
"Općenita pomoć za korištenje GNU softvera: <http://www.gnu.org/gethelp/>.\n"

#. TRANSLATORS: Replace LANG_CODE in this URL with your language
#. code <http://translationproject.org/team/LANG_CODE.html> to
#. form one of the URLs at http://translationproject.org/team/.
#. Otherwise, replace the entire URL with your translation team's
#. email address.
#: src/getargs.c:410
msgid "Report translation bugs to <http://translationproject.org/team/>.\n"
msgstr ""
"Prijavite greške prijevoda na <http://translationproject.org/team/hr.html>.\n"

#: src/getargs.c:412
msgid "For complete documentation, run: info bison.\n"
msgstr "Za prikaz cjelokupne dokumentacije pokrenite „info bison”.\n"

#: src/getargs.c:428
#, c-format
msgid "bison (GNU Bison) %s"
msgstr "bison (GNU Bison) %s"

#: src/getargs.c:430
msgid "Written by Robert Corbett and Richard Stallman.\n"
msgstr "Napisali Robert Corbett i Richard Stallman.\n"

#: src/getargs.c:434
#, c-format
msgid "Copyright (C) %d Free Software Foundation, Inc.\n"
msgstr "Copyright © %d Free Software Foundation, Inc.\n"

#: src/getargs.c:437
msgid ""
"This is free software; see the source for copying conditions.  There is NO\n"
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
msgstr ""
"Ovo je slobodan softver, pogledajte kod za upute o kopiranju. NEMA "
"jamstava,\n"
"čak ni za TRGOVINSKU PRIKLADNOST ili ODGOVARANJE ODREĐENOJ SVRSI.\n"

#: src/getargs.c:458
#, c-format
msgid "multiple skeleton declarations are invalid"
msgstr "višestruke deklaracije predloška nisu ispravne"

#: src/getargs.c:476
#, c-format
msgid "%s: invalid language"
msgstr "%s: neispravan jezik"

#: src/getargs.c:479
msgid "multiple language declarations are invalid"
msgstr "višestruke deklaracije jezika nisu ispravne"

#: src/getargs.c:747
#, c-format
msgid "%s: missing operand"
msgstr "%s: nedostaje operand"

#: src/getargs.c:749
#, c-format
msgid "extra operand %s"
msgstr "operand viška %s"

#: src/gram.c:112
msgid "empty"
msgstr "prazno"

#: src/gram.c:201
msgid "Grammar"
msgstr "Gramatika"

#: src/graphviz.c:45
#, c-format
msgid ""
"// Generated by %s.\n"
"// Report bugs to <%s>.\n"
"// Home page: <%s>.\n"
"\n"
msgstr ""
"// Napravio %s.\n"
"// Prijavite greške na <%s>.\n"
"// Početna stranica: <%s>.\n"
"\n"

#: src/location.c:93 src/scan-gram.l:859
#, c-format
msgid "line number overflow"
msgstr "preljev broja redaka"

#: src/location.c:95
#, c-format
msgid "column number overflow"
msgstr "preljev broja stupaca"

#: src/main.c:146
msgid "rule useless in parser due to conflicts"
msgstr "pravilo beskorisno u analizatoru zbog konflikata"

#: src/muscle-tab.c:450
#, c-format
msgid "%%define variable %s redefined"
msgstr "%%define varijabla %s je ponovo definirana"

#: src/muscle-tab.c:453
msgid "previous definition"
msgstr "prethodna definicija"

#: src/muscle-tab.c:490 src/muscle-tab.c:504 src/muscle-tab.c:556
#: src/muscle-tab.c:624
#, c-format
msgid "%s: undefined %%define variable %s"
msgstr "%s: nedefinirana %%define varijabla %s"

#: src/muscle-tab.c:550
#, c-format
msgid "invalid value for %%define Boolean variable %s"
msgstr "neispravna vrijednost %%define logičke varijable %s"

#: src/muscle-tab.c:609
#, c-format
msgid "invalid value for %%define variable %s: %s"
msgstr "neispravna vrijednost %%define varijable %s: %s"

#: src/muscle-tab.c:613
#, c-format
msgid "accepted value: %s"
msgstr "prihvaćena vrijednost: %s"

#: src/parse-gram.y:747
#, c-format
msgid "missing identifier in parameter declaration"
msgstr "nedostaje identifikator u deklaraciji paremetra"

#: src/print.c:47
#, c-format
msgid " type %d is %s\n"
msgstr " vrsta %d je %s\n"

#: src/print.c:164
#, c-format
msgid "shift, and go to state %d\n"
msgstr "pomakni i idi u stanje %d\n"

#: src/print.c:166
#, c-format
msgid "go to state %d\n"
msgstr "idi u stanje %d\n"

#: src/print.c:203
msgid "error (nonassociative)\n"
msgstr "greška (neasocijativna)\n"

#: src/print.c:226
#, c-format
msgid "reduce using rule %d (%s)"
msgstr "reduciraj koristeći pravilo %d (%s)"

#: src/print.c:228
#, c-format
msgid "accept"
msgstr "prihvati"

#: src/print.c:264 src/print.c:338
msgid "$default"
msgstr "$default"

#: src/print.c:373 src/print_graph.c:78
#, fuzzy, c-format
msgid "State %d"
msgstr "Stanje %d "

#: src/print.c:409
msgid "Terminals, with rules where they appear"
msgstr "Završni znakovi, s pravilima gdje se pojavljuju"

#: src/print.c:436
msgid "Nonterminals, with rules where they appear"
msgstr "Nezavršni znakovi, s pravilima gdje se pojavljuju"

#: src/print.c:465
#, c-format
msgid " on left:"
msgstr " s lijeva:"

#: src/print.c:482
#, c-format
msgid " on right:"
msgstr " s desna:"

#: src/print.c:510
msgid "Rules useless in parser due to conflicts"
msgstr "Pravila su beskorisna u analizatoru zbog konflikata"

#: src/reader.c:62
#, c-format
msgid "multiple %s declarations"
msgstr "višestruke %s deklaracije"

#: src/reader.c:133
#, c-format
msgid "result type clash on merge function %s: <%s> != <%s>"
msgstr "sukob rezultantne vrste u funkciji spajanja %s: <%s> != <%s>"

#: src/reader.c:139 src/symtab.c:156 src/symtab.c:166 src/symtab.c:938
#: src/symtab.c:953 src/symtab.c:968 src/symtab.c:983
msgid "previous declaration"
msgstr "prethodna deklaracija"

#: src/reader.c:205
#, c-format
msgid "duplicated symbol name for %s ignored"
msgstr "dvostruko ime simbola za %s je zanemareno"

#: src/reader.c:249
#, c-format
msgid "rule given for %s, which is a token"
msgstr "navedeno je pravilo za %s, a to je simbol"

#: src/reader.c:304
#, c-format
msgid "type clash on default action: <%s> != <%s>"
msgstr "sukob vrsta u zadanoj radnji: <%s> != <%s>"

#: src/reader.c:310
#, c-format
msgid "empty rule for typed nonterminal, and no action"
msgstr "prazno pravilo za nezavršni znak i nema radnje"

#: src/reader.c:328
#, c-format
msgid "unused value: $%d"
msgstr "nekorištena vrijednost: $%d"

#: src/reader.c:330
msgid "unset value: $$"
msgstr "nepostavljena vrijednost: $$"

#: src/reader.c:341
#, c-format
msgid "token for %%prec is not defined: %s"
msgstr "simbol za %%prec nije definiran: %s"

#: src/reader.c:431 src/reader.c:445 src/reader.c:458
#, c-format
msgid "only one %s allowed per rule"
msgstr "samo je jedan %s dozvoljen po pravilu"

#: src/reader.c:441 src/reader.c:456
#, c-format
msgid "%s affects only GLR parsers"
msgstr "%s utječe samo na GLR analizatore"

#: src/reader.c:443
#, c-format
msgid "%s must be followed by positive number"
msgstr "nakon %s mora slijediti pozitivan broj"

#: src/reader.c:554
#, c-format
msgid "rule is too long"
msgstr "pravilo je predugačko"

#: src/reader.c:672
#, c-format
msgid "no rules in the input grammar"
msgstr "nema pravila u ulaznoj gramatici"

#: src/reduce.c:241
msgid "rule useless in grammar"
msgstr "pravilo je beskorisno u gramatici"

#: src/reduce.c:302
#, c-format
msgid "nonterminal useless in grammar: %s"
msgstr "nezavršni znak je beskoristan u gramatici: %s"

#: src/reduce.c:350
msgid "Nonterminals useless in grammar"
msgstr "Nezavršni znakovi beskorisni u gramatici"

#: src/reduce.c:363
msgid "Terminals unused in grammar"
msgstr "Završni znakovi nekorišteni u gramatici"

#: src/reduce.c:372
msgid "Rules useless in grammar"
msgstr "Pravila beskorisna u gramatici"

#: src/reduce.c:385
#, c-format
msgid "%d nonterminal useless in grammar"
msgid_plural "%d nonterminals useless in grammar"
msgstr[0] "%d nezavršni znak beskoristan u gramatici"
msgstr[1] "%d nezavršna znaka beskorisna u gramatici"
msgstr[2] "%d nezavršnih znakova beskorisnih u gramatici"

#: src/reduce.c:390
#, c-format
msgid "%d rule useless in grammar"
msgid_plural "%d rules useless in grammar"
msgstr[0] "%d pravilo beskorisno u gramatici"
msgstr[1] "%d pravila beskorisna u gramatici"
msgstr[2] "%d pravila beskorisnih u gramatici"

#: src/reduce.c:419
#, c-format
msgid "start symbol %s does not derive any sentence"
msgstr "početni simbol %s ne daje niti jednu rečenicu"

#: src/scan-code.l:188
#, c-format
msgid "stray '%s'"
msgstr "zalutali „%s”"

#: src/scan-code.l:229
msgid "a ';' might be needed at the end of action code"
msgstr "može biti potrebna „;” na kraju koda radnje"

#: src/scan-code.l:232
msgid "future versions of Bison will not add the ';'"
msgstr "buduće inačice Bisona neće dodavati „;”"

#: src/scan-code.l:254
#, c-format
msgid "use of YYFAIL, which is deprecated and will be removed"
msgstr "korištenje YYFAIL, što je zastarjelo i bit će uklonjeno"

#: src/scan-code.l:431 src/scan-code.l:434
#, c-format
msgid "refers to: %c%s at %s"
msgstr "odnosi se na: %c%s na %s"

#: src/scan-code.l:450
#, c-format
msgid "possibly meant: %c"
msgstr "vjerojatno znači: %c"

#: src/scan-code.l:459
#, c-format
msgid ", hiding %c"
msgstr ", skrivajući %c"

#: src/scan-code.l:467
#, c-format
msgid " at %s"
msgstr " na %s"

#: src/scan-code.l:472
#, c-format
msgid ", cannot be accessed from mid-rule action at $%d"
msgstr ", ne može mu pristupiti mid-rule radnja na $%d"

#: src/scan-code.l:521 src/scan-gram.l:783
#, c-format
msgid "integer out of range: %s"
msgstr "cijeli broj izvan granica: %s"

#: src/scan-code.l:610
#, c-format
msgid "invalid reference: %s"
msgstr "neispravna referenca: %s"

#: src/scan-code.l:619
#, c-format
msgid "syntax error after '%c', expecting integer, letter, '_', '[', or '$'"
msgstr ""
"sintaksna greška nakon „%c”, očekujem cijeli broj, slovo, „_”, „[” ili „$”"

#: src/scan-code.l:626
#, c-format
msgid "symbol not found in production before $%d: %.*s"
msgstr "simbol nije pronađen u proizvodnji prije $%d: %.*s"

#: src/scan-code.l:633
#, c-format
msgid "symbol not found in production: %.*s"
msgstr "simbol nije pronađen u proizvodnji: %.*s"

#: src/scan-code.l:648
#, c-format
msgid "misleading reference: %s"
msgstr "krivo navodeća referenca: %s"

#: src/scan-code.l:663
#, c-format
msgid "ambiguous reference: %s"
msgstr "višeznačna referenca: %s"

#: src/scan-code.l:700
#, c-format
msgid "explicit type given in untyped grammar"
msgstr "navedena eksplicitna vrsta u neunesenoj gramatici"

#: src/scan-code.l:759
#, c-format
msgid "$$ for the midrule at $%d of %s has no declared type"
msgstr "$$ za srednje pravilo na $%d od %s nema deklariranu vrstu"

#: src/scan-code.l:764
#, c-format
msgid "$$ of %s has no declared type"
msgstr "$$ od %s nema deklariranu vrstu"

#: src/scan-code.l:786
#, c-format
msgid "$%s of %s has no declared type"
msgstr "$%s od %s nema deklariranu vrstu"

#: src/scan-gram.l:149
#, c-format
msgid "stray ',' treated as white space"
msgstr "postupam sa zalutalim „,” kao praznim prostorom"

#: src/scan-gram.l:222
#, c-format
msgid "invalid directive: %s"
msgstr "neispravan propis: %s"

#: src/scan-gram.l:250
#, c-format
msgid "invalid identifier: %s"
msgstr "neispravan identifikator: %s"

#: src/scan-gram.l:295
#, fuzzy
msgid "invalid character"
msgid_plural "invalid characters"
msgstr[0] "neispravan znak: %s"
msgstr[1] "neispravan znak: %s"
msgstr[2] "neispravan znak: %s"

#: src/scan-gram.l:354
#, c-format
msgid "unexpected identifier in bracketed name: %s"
msgstr "neočekivani identifikator u zagrađenom imenu: %s"

#: src/scan-gram.l:376
#, c-format
msgid "an identifier expected"
msgstr "očekujem identifikator"

#: src/scan-gram.l:381
#, fuzzy
msgid "invalid character in bracketed name"
msgid_plural "invalid characters in bracketed name"
msgstr[0] "neispravan znak u zagrađenom imenu: %s"
msgstr[1] "neispravan znak u zagrađenom imenu: %s"
msgstr[2] "neispravan znak u zagrađenom imenu: %s"

#: src/scan-gram.l:481 src/scan-gram.l:502
#, c-format
msgid "empty character literal"
msgstr "prazna znakovna konstanta"

#: src/scan-gram.l:486 src/scan-gram.l:507
#, c-format
msgid "extra characters in character literal"
msgstr "višak znakova u znakovnoj konstanti"

#: src/scan-gram.l:518
#, c-format
msgid "invalid null character"
msgstr "neispravan prazan znak"

#: src/scan-gram.l:531 src/scan-gram.l:541 src/scan-gram.l:561
#, c-format
msgid "invalid number after \\-escape: %s"
msgstr "neispravan broj nakon \\-izlaza: %s"

#: src/scan-gram.l:573
#, c-format
msgid "invalid character after \\-escape: %s"
msgstr "neispravan znak nakon \\-izlaza: %s"

#: src/scan-gram.l:901
#, c-format
msgid "missing %s at end of file"
msgstr "nedostaje %s na kraju datoteke"

#: src/scan-gram.l:912
#, c-format
msgid "missing %s at end of line"
msgstr "nedostaje %s na kraju retka"

#: src/scan-skel.l:146
#, c-format
msgid "unclosed %s directive in skeleton"
msgstr "nezatvoren %s propis u predlošku"

#: src/scan-skel.l:291
#, c-format
msgid "too few arguments for %s directive in skeleton"
msgstr "premalo argumenata %s propisa u predlošku"

#: src/scan-skel.l:298
#, c-format
msgid "too many arguments for %s directive in skeleton"
msgstr "premalo argumenata %s propisa u predlošku"

#: src/symlist.c:211
#, c-format
msgid "invalid $ value: $%d"
msgstr "neispravna $ vrijednost: $%d"

#: src/symtab.c:71
#, c-format
msgid "POSIX Yacc forbids dashes in symbol names: %s"
msgstr "POSIX Yacc zabranjuje povlake u imenima simbola: %s"

#: src/symtab.c:91
#, c-format
msgid "too many symbols in input grammar (limit is %d)"
msgstr "previše simbola u ulaznoj gramatici (ograničenje je %d)"

#: src/symtab.c:154
#, c-format
msgid "%s redeclaration for %s"
msgstr "ponovna deklaracija %s za %s"

#: src/symtab.c:164
#, c-format
msgid "%s redeclaration for <%s>"
msgstr "ponovna deklaracija %s za <%s>"

#: src/symtab.c:332
#, c-format
msgid "symbol %s redefined"
msgstr "simbol %s ponovo definiran"

#: src/symtab.c:346
#, c-format
msgid "symbol %s redeclared"
msgstr "simbol %s ponovo deklariran"

#: src/symtab.c:367
#, c-format
msgid "redefining user token number of %s"
msgstr "ponovo definiram broj korisničkog simbola od %s"

#: src/symtab.c:395
#, c-format
msgid "symbol %s is used, but is not defined as a token and has no rules"
msgstr "simbol %s je korišten, ali nije definiran kao simbol i nema pravila"

#: src/symtab.c:415
#, c-format
msgid "symbol %s used more than once as a literal string"
msgstr "simbol %s je korišten više puta kao konstantan niz"

#: src/symtab.c:418
#, c-format
msgid "symbol %s given more than one literal string"
msgstr "simbolu %s je dano više od jednog konstantnog niza"

#: src/symtab.c:535
#, c-format
msgid "user token number %d redeclaration for %s"
msgstr "ponovna deklaracija broja korisničkog simbola %d za %s"

#: src/symtab.c:539
#, c-format
msgid "previous declaration for %s"
msgstr "prethodna deklaracija za %s"

#: src/symtab.c:915
#, c-format
msgid "the start symbol %s is undefined"
msgstr "početni simbol %s nije definiran"

#: src/symtab.c:919
#, c-format
msgid "the start symbol %s is a token"
msgstr "početni simbol %s je simbol"

#: src/symtab.c:935
#, c-format
msgid "redeclaration for default tagged %%destructor"
msgstr "ponovna deklaracija za zadani označeni %%destructor"

#: src/symtab.c:950
#, c-format
msgid "redeclaration for default tagless %%destructor"
msgstr "ponovna deklaracija za zadani neoznačeni %%destructor"

#: src/symtab.c:965
#, c-format
msgid "redeclaration for default tagged %%printer"
msgstr "ponovna deklaracija za zadani označeni %%printer"

#: src/symtab.c:980
#, c-format
msgid "redeclaration for default tagless %%printer"
msgstr "ponovna deklaracija za zadani neoznačeni %%printer"

#: djgpp/subpipe.c:63 djgpp/subpipe.c:286 djgpp/subpipe.c:288
#, c-format
msgid "removing of '%s' failed"
msgstr "uklanjanje „%s” nije uspjelo"

#: djgpp/subpipe.c:85 djgpp/subpipe.c:92
#, c-format
msgid "creation of a temporary file failed"
msgstr "stvaranje privremene datoteke nije uspjelo"

#: djgpp/subpipe.c:127
#, c-format
msgid "saving stdin failed"
msgstr "spremanje standardnog ulaza nije uspjelo"

#: djgpp/subpipe.c:131
#, c-format
msgid "saving stdout failed"
msgstr "spremanje standardnog izlaza nije uspjelo"

#: djgpp/subpipe.c:153 djgpp/subpipe.c:197 djgpp/subpipe.c:258
#, c-format
msgid "opening of tmpfile failed"
msgstr "otvaranje privremene datoteke nije uspjelo"

#: djgpp/subpipe.c:157
#, c-format
msgid "redirecting bison's stdout to the temporary file failed"
msgstr ""
"preusmjeravanje standardnog izlaza programa bison u privremenu datoteku nije "
"uspjelo"

#: djgpp/subpipe.c:201
#, c-format
msgid "redirecting m4's stdin from the temporary file failed"
msgstr ""
"preusmjeravanje standardnog ulaza programa m4 iz privremene datoteke nije "
"uspjelo"

#: djgpp/subpipe.c:212
#, c-format
msgid "opening of a temporary file failed"
msgstr "otvaranje privremene datoteke nije uspjelo"

#: djgpp/subpipe.c:218
#, c-format
msgid "redirecting m4's stdout to a temporary file failed"
msgstr ""
"preusmjeravanje standardnog izlaza programa u privremenu datoteku nije "
"uspjelo"

#: djgpp/subpipe.c:234
#, c-format
msgid "subsidiary program '%s' interrupted"
msgstr "podređeni program „%s” je prekinut"

#: djgpp/subpipe.c:241
#, c-format
msgid "subsidiary program '%s' not found"
msgstr "podređeni program „%s” nije pronađen"

#: djgpp/subpipe.c:265
#, c-format
msgid "redirecting bison's stdin from the temporary file failed"
msgstr ""
"preusmjeravanje standardnog ulaza programa bison iz privremene datoteke nije "
"uspjelo"

#: lib/argmatch.c:133
#, c-format
msgid "invalid argument %s for %s"
msgstr "neispravan argument %s za %s"

#: lib/argmatch.c:134
#, c-format
msgid "ambiguous argument %s for %s"
msgstr "višeznačan argument %s za %s"

#: lib/argmatch.c:153
msgid "Valid arguments are:"
msgstr "Ispravni argumenti su:"

#: lib/bitset_stats.c:177
#, c-format
msgid "%u bitset_allocs, %u freed (%.2f%%).\n"
msgstr "%u bitset_allocs, %u oslobođeno (%.2f%%).\n"

#: lib/bitset_stats.c:180
#, c-format
msgid "%u bitset_sets, %u cached (%.2f%%)\n"
msgstr "%u bitset_sets, %u u spremniku (%.2f%%)\n"

#: lib/bitset_stats.c:183
#, c-format
msgid "%u bitset_resets, %u cached (%.2f%%)\n"
msgstr "%u bitset_resets, %u u spremniku (%.2f%%)\n"

#: lib/bitset_stats.c:186
#, c-format
msgid "%u bitset_tests, %u cached (%.2f%%)\n"
msgstr "%u bitset_tests, %u u spremniku (%.2f%%)\n"

#: lib/bitset_stats.c:190
#, c-format
msgid "%u bitset_lists\n"
msgstr "%u bitset_lists\n"

#: lib/bitset_stats.c:192
msgid "count log histogram\n"
msgstr "histogram dnevnika brojanja\n"

#: lib/bitset_stats.c:195
msgid "size log histogram\n"
msgstr "histogram dnevnika veličine\n"

#: lib/bitset_stats.c:198
msgid "density histogram\n"
msgstr "histogram gustoće\n"

#: lib/bitset_stats.c:212
#, c-format
msgid ""
"Bitset statistics:\n"
"\n"
msgstr ""
"Statistike postavljanja bitova:\n"
"\n"

#: lib/bitset_stats.c:215
#, c-format
msgid "Accumulated runs = %u\n"
msgstr "Akumulirana izvršavanja = %u\n"

#: lib/bitset_stats.c:259 lib/bitset_stats.c:264
msgid "cannot read stats file"
msgstr "ne mogu čitati datoteku stanja"

#: lib/bitset_stats.c:261
#, c-format
msgid "bad stats file size\n"
msgstr "neispravna veličina datoteke stanja\n"

#: lib/bitset_stats.c:287 lib/bitset_stats.c:289
msgid "cannot write stats file"
msgstr "ne mogu zapisati datoteku stanja"

#: lib/bitset_stats.c:292
msgid "cannot open stats file for writing"
msgstr "ne mogu otvoriti datoteku stanja za pisanje"

#: lib/closeout.c:112
msgid "write error"
msgstr "greška pisanja"

#: lib/error.c:188
msgid "Unknown system error"
msgstr "Nepoznata greška sustava"

#: lib/getopt.c:547 lib/getopt.c:576
#, c-format
msgid "%s: option '%s' is ambiguous; possibilities:"
msgstr "%s: opcija „%s” je višeznačna, mogućnosti:"

#: lib/getopt.c:624 lib/getopt.c:628
#, c-format
msgid "%s: option '--%s' doesn't allow an argument\n"
msgstr "%s: opcija „--%s” ne dozvoljava argument\n"

#: lib/getopt.c:637 lib/getopt.c:642
#, c-format
msgid "%s: option '%c%s' doesn't allow an argument\n"
msgstr "%s: opcija „%c%s” ne dozvoljava argument\n"

#: lib/getopt.c:685 lib/getopt.c:704
#, c-format
msgid "%s: option '--%s' requires an argument\n"
msgstr "%s: opcija „--%s” zahtijeva argument\n"

#: lib/getopt.c:742 lib/getopt.c:745
#, c-format
msgid "%s: unrecognized option '--%s'\n"
msgstr "%s: neprepoznata opcija „--%s”\n"

#: lib/getopt.c:753 lib/getopt.c:756
#, c-format
msgid "%s: unrecognized option '%c%s'\n"
msgstr "%s: neprepoznata opcija „%c%s”\n"

#: lib/getopt.c:805 lib/getopt.c:808
#, c-format
msgid "%s: invalid option -- '%c'\n"
msgstr "%s: neispravna opcija -- „%c”\n"

#: lib/getopt.c:861 lib/getopt.c:878 lib/getopt.c:1088 lib/getopt.c:1106
#, c-format
msgid "%s: option requires an argument -- '%c'\n"
msgstr "%s: opcija zahtijeva argument -- „%c”\n"

#: lib/getopt.c:934 lib/getopt.c:950
#, c-format
msgid "%s: option '-W %s' is ambiguous\n"
msgstr "%s: opcija „-W %s” je višeznačna\n"

#: lib/getopt.c:974 lib/getopt.c:992
#, c-format
msgid "%s: option '-W %s' doesn't allow an argument\n"
msgstr "%s: opcija „-W %s” ne dozvoljava argument\n"

#: lib/getopt.c:1013 lib/getopt.c:1031
#, c-format
msgid "%s: option '-W %s' requires an argument\n"
msgstr "%s: opcija „-W %s” zahtijeva argument\n"

#: lib/obstack.c:413 lib/obstack.c:415 lib/xalloc-die.c:34
msgid "memory exhausted"
msgstr "memorija iscrpljena"

#: lib/spawn-pipe.c:140 lib/spawn-pipe.c:143 lib/spawn-pipe.c:264
#: lib/spawn-pipe.c:267
#, c-format
msgid "cannot create pipe"
msgstr "ne mogu napraviti cjevovod"

#: lib/spawn-pipe.c:234 lib/spawn-pipe.c:348 lib/wait-process.c:282
#: lib/wait-process.c:356
#, c-format
msgid "%s subprocess failed"
msgstr "%s potproces nije uspio"

#. TRANSLATORS:
#. Get translations for open and closing quotation marks.
#. The message catalog should translate "`" to a left
#. quotation mark suitable for the locale, and similarly for
#. "'".  For example, a French Unicode local should translate
#. these to U+00AB (LEFT-POINTING DOUBLE ANGLE
#. QUOTATION MARK), and U+00BB (RIGHT-POINTING DOUBLE ANGLE
#. QUOTATION MARK), respectively.
#.
#. If the catalog has no translation, we will try to
#. use Unicode U+2018 (LEFT SINGLE QUOTATION MARK) and
#. Unicode U+2019 (RIGHT SINGLE QUOTATION MARK).  If the
#. current locale is not Unicode, locale_quoting_style
#. will quote 'like this', and clocale_quoting_style will
#. quote "like this".  You should always include translations
#. for "`" and "'" even if U+2018 and U+2019 are appropriate
#. for your locale.
#.
#. If you don't know what to put here, please see
#. <http://en.wikipedia.org/wiki/Quotation_marks_in_other_languages>
#. and use glyphs suitable for your language.
#: lib/quotearg.c:312
msgid "`"
msgstr "„"

#: lib/quotearg.c:313
msgid "'"
msgstr "”"

#: lib/timevar.c:475
msgid ""
"\n"
"Execution times (seconds)\n"
msgstr ""
"\n"
"Vremena izvršavanja (u sekundama)\n"

#: lib/timevar.c:525
msgid " TOTAL                 :"
msgstr " UKUPNO                :"

#: lib/timevar.c:561
#, c-format
msgid "time in %s: %ld.%06ld (%ld%%)\n"
msgstr "vrijeme u %s: %ld.%06ld (%ld%%)\n"

#: lib/w32spawn.h:43
#, c-format
msgid "_open_osfhandle failed"
msgstr "_open_osfhandle nije uspio"

#: lib/w32spawn.h:84
#, c-format
msgid "cannot restore fd %d: dup2 failed"
msgstr "ne mogu obnoviti fd %d: dup2 nije uspio"

#: lib/wait-process.c:223 lib/wait-process.c:255 lib/wait-process.c:317
#, c-format
msgid "%s subprocess"
msgstr "%s potproces"

#: lib/wait-process.c:274 lib/wait-process.c:346
#, c-format
msgid "%s subprocess got fatal signal %d"
msgstr "%s potproces je primio fatalni signal %d"

#~ msgid "state %d"
#~ msgstr "stanje %d"

#~ msgid "stray '@'"
#~ msgstr "stray „@”"

#~ msgid ""
#~ "undefined %%define variable `%s' passed to muscle_percent_define_get_loc"
#~ msgstr ""
#~ "nedefinirana %%define varijabla „%s” je proslijeđena "
#~ "muscle_percent_define_get_loc"

#~ msgid ""
#~ "undefined %%define variable `%s' passed to "
#~ "muscle_percent_define_get_syncline"
#~ msgstr ""
#~ "nedefinirana %%define varijabla „%s” je proslijeđena "
#~ "muscle_percent_define_get_syncline"

#~ msgid ""
#~ "undefined %%define variable `%s' passed to muscle_percent_define_flag_if"
#~ msgstr ""
#~ "nedefinirana %%define varijabla „%s” je proslijeđena "
#~ "muscle_percent_define_flag_if"

#~ msgid ""
#~ "undefined %%define variable `%s' passed to "
#~ "muscle_percent_define_check_values"
#~ msgstr ""
#~ "nedefinirana %%define varijable „%s” je proslijeđena "
#~ "muscle_percent_define_check_values"

#~ msgid "too many states (max %d)"
#~ msgstr "previše stanja (maks %d)"

#~ msgid "reduce"
#~ msgstr "reduciraj"

#~ msgid "shift"
#~ msgstr "pomakni"

#~ msgid "%d shift/reduce conflict"
#~ msgid_plural "%d shift/reduce conflicts"
#~ msgstr[0] "%d pomakni/reduciraj konflikat"
#~ msgstr[1] "%d pomakni/reduciraj konflikata"

#~ msgid "and"
#~ msgstr "i"

#~ msgid "State %d contains "
#~ msgstr "Stanje %d sadrži"

#~ msgid "conflicts: "
#~ msgstr "konflikt:"

#~ msgid "%s contains "
#~ msgstr "%s sadrži"

#~ msgid "    %-4s\t[reduce using rule %d (%s)]\n"
#~ msgstr "    %-4s\t[reduciraj koristeći pravilo %d (%s)]\n"

#~ msgid ""
#~ "    $default\treduce using rule %d (%s)\n"
#~ "\n"
#~ msgstr ""
#~ "    $default\treduciraj koristeći pravilo %d (%s)\n"
#~ "\n"

#~ msgid "    %-4s\treduce using rule %d (%s)\n"
#~ msgstr "    %-4s\treduciraj koristeći pravilo %d (%s)\n"

#~ msgid "    $default\treduce using rule %d (%s)\n"
#~ msgstr "    $default\treduciraj koristeći pravilo %d (%s)\n"

#~ msgid "GNU bison generates parsers for LALR(1) grammars.\n"
#~ msgstr "GNU bison generira parsere za LALR(1) gramatike.\n"

#~ msgid ""
#~ "If a long option shows an argument as mandatory, then it is mandatory\n"
#~ "for the equivalent short option also.  Similarly for optional arguments.\n"
#~ msgstr ""
#~ "Ako duga opcija kaže da je argument obavezan, tada je on obavezan\n"
#~ "i za ekvivalentnu kratku opciju. Slično je i za opcionalne argumente.\n"

#~ msgid ""
#~ "Operation modes:\n"
#~ "  -h, --help      display this help and exit\n"
#~ "  -V, --version   output version information and exit\n"
#~ "  -y, --yacc      emulate POSIX yacc\n"
#~ msgstr ""
#~ "Načini rada:\n"
#~ "  -h, --help      prikaži ovu pomoć i izađi\n"
#~ "  -V, --version   prikaži verziju i izađi\n"
#~ "  -y, --yacc      emuliraj POSIX yacc\n"

#~ msgid ""
#~ "Output:\n"
#~ "  -d, --defines              also produce a header file\n"
#~ "  -v, --verbose              also produce an explanation of the "
#~ "automaton\n"
#~ "  -b, --file-prefix=PREFIX   specify a PREFIX for output files\n"
#~ "  -o, --output=FILE          leave output to FILE\n"
#~ "  -g, --graph                also produce a VCG description of the "
#~ "automaton\n"
#~ msgstr ""
#~ "Izlaz:\n"
#~ "  -d, --defines              također proizvedi header datoteku\n"
#~ "  -v, --verbose              također proizvedi objašnjenje automata\n"
#~ "  -b, --file-prefix=PREFIKS   specificiraj PREFIKS za izlazne datoteke\n"
#~ "  -o, --output=DATOTEKA          ispiši izlaz u DATOTEKU\n"
#~ "  -g, --graph                također proizvedi VCG opis automata\n"

#~ msgid "`%s' is no longer supported"
#~ msgstr "`%s' više nije podržano"

#~ msgid "%s: no grammar file given\n"
#~ msgstr "%s: nije data datoteka sa gramatikom\n"

#~ msgid "%s: extra arguments ignored after `%s'\n"
#~ msgstr "%s: dodatni argumenti se ignoriraju nakon `%s'\n"

#~ msgid "too many gotos (max %d)"
#~ msgstr "previše goto-a (maksimalno %d)"

#~ msgid "unexpected `/' found and ignored"
#~ msgstr "neočekivan  `/' nađen i zanemaren"

#~ msgid "unterminated comment"
#~ msgstr "nezavršeni komentar"

#~ msgid "unexpected end of file"
#~ msgstr "neočekivan kraj datoteke"

#~ msgid "unescaped newline in constant"
#~ msgstr "neočekivan znak za novu liniju u konstanti"

#~ msgid "octal value outside range 0...255: `\\%o'"
#~ msgstr "oktalna vrijednost izvan dosega 0...255: `\\%o'"

#~ msgid "hexadecimal value above 255: `\\x%x'"
#~ msgstr "heksadecimalna vrijednost viša od 255: `\\x%x'"

#~ msgid "unknown escape sequence: `\\' followed by `%s'"
#~ msgstr "nepoznata escape sekvenca: `\\' koju slijedi `%s'"

#~ msgid "unterminated type name at end of file"
#~ msgstr "nezavršeno ime tipa pri kraju datoteke"

#~ msgid "unterminated type name"
#~ msgstr "nezavršeno ime tipa"

#~ msgid "use \"...\" for multi-character literal tokens"
#~ msgstr "koristi \"...\" za višebajtne znakove"

#~ msgid "`%s' supports no argument: %s"
#~ msgstr "`%s' ne podržava argument: %s"

#~ msgid "`%s' requires an argument"
#~ msgstr "`%s' zahtijeva argument"

#~ msgid "maximum table size (%d) exceeded"
#~ msgstr "maksimalna veličina tablice (%d) prekoračena"

#~ msgid "   (rule %d)"
#~ msgstr "   (pravilo %d)"

#~ msgid "    $default\taccept\n"
#~ msgstr "    $default\tprihvati\n"

#~ msgid "    NO ACTIONS\n"
#~ msgstr "    NEMA AKCIJA\n"

#~ msgid "    %-4s\terror (nonassociative)\n"
#~ msgstr "    %-4s\tgreška (nonassociative)\n"

#~ msgid "    %-4s\tgo to state %d\n"
#~ msgstr "    %-4s\tidu u stanje %d\n"

#~ msgid "Number, Line, Rule"
#~ msgstr "Broj, Linija, Pravilo"

#~ msgid "  %3d %3d %s ->"
#~ msgstr "  %3d %3d %s ->"

#~ msgid "   Skipping to next \\n"
#~ msgstr "   Preskačem na slijedeće \\n"

#~ msgid "   Skipping to next %c"
#~ msgstr "   Preskačem na slijedeći %c"

#~ msgid "unterminated string"
#~ msgstr "nezavršeni znakovni niz"

#~ msgid "invalid @ value"
#~ msgstr "nedozvoljena  @ vrijednost"

#~ msgid "%s is invalid"
#~ msgstr "%s je nedozvoljeno"

#~ msgid "unterminated `%{' definition"
#~ msgstr "nezavršena `%{' definicija"

#~ msgid "Premature EOF after %s"
#~ msgstr "Preuranjeni EOF nakon %s"

#~ msgid "`%s' is invalid in %s"
#~ msgstr "`%s' je nedozvoljen u %s"

#~ msgid "%type declaration has no <typename>"
#~ msgstr "%type deklaracija nema  <typename>"

#~ msgid "invalid %%type declaration due to item: %s"
#~ msgstr "nedozvoljena %%type deklaracija zbog: %s"

#~ msgid "invalid text (%s) - number should be after identifier"
#~ msgstr "nedozvoljeno tekst (%s) - broj bi trebao biti nakon identifikatora"

#~ msgid "unmatched %s"
#~ msgstr "nije pronađen %s"

#~ msgid "argument of %%expect is not an integer"
#~ msgstr "argument od %%expect nije cijeli broj"

#~ msgid "unrecognized item %s, expected an identifier"
#~ msgstr "neprepoznati %s, očekivan nakon identifikatora"

#~ msgid "expected string constant instead of %s"
#~ msgstr "očekivana znakovna konstana umjesto %s"

#~ msgid "unrecognized: %s"
#~ msgstr "neprepoznati: %s"

#~ msgid "no input grammar"
#~ msgstr "nema ulazne gramatike"

#~ msgid "unterminated %guard clause"
#~ msgstr "nezavršena %guard klauzula"

#~ msgid "ill-formed rule: initial symbol not followed by colon"
#~ msgstr "loše pravilo: zarez ne bi trebao slijediti početni simbol"

#~ msgid "grammar starts with vertical bar"
#~ msgstr "gramatika počinje sa okomitom crtom"

#~ msgid "previous rule lacks an ending `;'"
#~ msgstr "prethodnom pravilu nedostaje završetak `;'"

#~ msgid "two @prec's in a row"
#~ msgstr "dva @prec's u retku"

#~ msgid "%%guard present but %%semantic_parser not specified"
#~ msgstr "%%guard prisutan ali %%semantic_parser nije specificiran"

#~ msgid "two actions at end of one rule"
#~ msgstr "dvije akcije pri kraju jednog pravila"

#~ msgid "tokens %s and %s both assigned number %d"
#~ msgstr "objema znakovima %s i %s je pridružen broj %d"

#~ msgid "conflicting precedences for %s and %s"
#~ msgstr "konflikt u prethodnici za %s and %s"

#~ msgid "Useless nonterminals:"
#~ msgstr "Beskorisni nezavršni znakovi:"

#~ msgid "Terminals which are not used:"
#~ msgstr "Završni znakovi koji nisu korišteni:"

#~ msgid "Useless rules:"
#~ msgstr "Beskorisna pravila:"

#~ msgid "%d rule never reduced\n"
#~ msgid_plural "%d rules never reduced\n"
#~ msgstr[0] "%d pravilo nije nikad reducirano\n"
#~ msgstr[1] "%d pravila nisu nikad reducirana\n"

#~ msgid "%d useless nonterminal"
#~ msgid_plural "%d useless nonterminals"
#~ msgstr[0] "%d beskorisan nezavršni znak"
#~ msgstr[1] "%d beskorisnih nezavršnih znakova"

#~ msgid " and "
#~ msgstr " i"

#~ msgid "%d useless rule"
#~ msgid_plural "%d useless rules"
#~ msgstr[0] "%d beskorisno pravilo"
#~ msgstr[1] "%d beskorisnih pravila"

#~ msgid "%s: illegal option -- %c\n"
#~ msgstr "%s: nedozvoljena opcija -- %c\n"
