type: wikipedia

text:
Ο Κρίστοφ Βίλιμπαλντ Γκλουκ (Christoph Willibald Gluck, 2 Ιουλίου 1714 – 15 Νοεμβρίου 1787) ήταν βοημικής καταγωγής συνθέτης όπερας.
 Σε ηλικία 13 ετών εγκατέλειψε την πατρική εστία για να γίνει πλανόδιος μουσικός. Κατά βάση αυτοδίδακτος, εργάστηκε στην Πράγα και στη Βιέννη προτού καταλήξει στην Ιταλία. Εκεί γνωρίστηκε με τον συνθέτη Τζιοβάνι Μπατίστα Σαμαρτίνι, υπό την προστασία του οποίου ξεκίνησε το 1741 τη σταδιοδρομία του ως συνθέτης του λυρικού θεάτρου γνωρίζοντας πολλές και σημαντικές επιτυχίες.
 Το 1752 εγκαταστάθηκε οριστικά στη Βιέννη, παντρεύτηκε μια ευκατάστατη γυναίκα και συνδέθηκε στενά με την αυτοκρατορική αυλή. Οι όπερές του αυτής της περιόδου ήταν γραμμένες στα γαλλικά ή στα ιταλικά.
 Η συνεργασία του με τον λιμπρετίστα Γκαλζαμπίγκι σημάδεψε ανεξίτηλα την πορεία της όπερας ως μουσικού είδους.
 Η καινοτομία του Γκλουκ ήταν να προσθέσει δράμα στην όπερα, οδηγώντας τη σε νέα ύψη. Οι πιο δημοφιλείς του όπερες είναι οι Ορφέας και Ευριδίκη (1762), "Ο θρίαμβος της Κλέλιας" 1763, Άλκηστη (1767), Ιφιγένεια εν Αυλίδι (1774) και Ιφιγένεια εν Ταύροις (1779).
 Από το 1781 αφού έπαθε εγκεφαλικό, έγραψε πολύ λίγο. Τελικά το 1787 ύστερα από δεύτερο εγκεφαλικό πέθανε σε ηλικία 73 ετών.
 Παραπομπές
 Συνθέτες της κλασικής εποχής
 Συνθέτες όπερας
 Γερμανοί συνθέτες κλασικής μουσικής


type: other

text:
VSL Sklep I Cp 622/2018
 ECLI:SI:VSLJ:2018:I.CP.622.2018
 VSL00018974
 Mojca Hribernik (preds.), Majda Irt (poroč.), dr. Peter Rudolf
 vzpostavitev etažne lastnine - etažna lastnina - posamezni del stavbe - skupni del stavbe - upravnik - absolutna bistvena kršitev določb pravdnega postopka
 Določitev novega naslova na samo dokončanje etažne lastnine ne vpliva, saj gre kljub dvema naslovoma, po podatkih prostorskega portala RS ob dnevu odločanja pritožbenega sodišča, za eno stavbo. Sodišče prve stopnje pa bo moralo ugotoviti, ali ima del stavbe na novem naslovu upravnika in v kolikor ga ima, pritegniti v postopek kot udeleženca tudi Skupnost vsakokratnih etažnih lastnikov na novem naslovu (prvi odstavek 4. člena ZVEtL-1).
 Etažna lastnina je lastnina posameznega dela zgradbe in solastnina skupnih delov (prvi odstavek 105. člena SPZ). Del stavbe ne more biti hkrati posamezni in skupni del stavbe.
 - ugotovilo, da je udeleženka v postopku tudi Skupnost vsakokratnih etažnih lastnikov stavbe na naslovu K. 2, ki jo kot zakoniti zastopnik zastopa upravnik stavbe A., d. d.(I. točka izreka sklepa) ter da upravnik stavbe A., d. d., ni več samostojni udeleženec tega nepravdnega postopka (II. točka izreka sklepa),
 - ugotovilo, da je pravna naslednica Občine, zemljiškoknjižne lastnice nerazdeljenega dela X-1907-9999, nasprotna udeleženka,
 - v postopek pritegnilo zakonite udeležence (III. točka izreka sklepa),
 - na stavbi z ident. št. X-1907, ki stoji na parc. št. 3016, k. o. X1, na naslovu K. 2, dokončalo vzpostavitev etažne lastnine (V. točka izreka sklepa),
 - ugotovilo, kateri so posamezni deli stavbe X-1907 ter določilo solastniške idealne deleže na splošnih skupnih delih stavbe (VI. točka izreka sklepa),
 - ugotovilo, da je splošni skupni del stavbe z ident. št. X-1907 parc. št. 3016, k. o. X, in na njem vzpostavilo solastninsko pravico v korist vsakokratnih lastnikov posameznih delov stavbe, s solastniškimi deleži iz VI. točke izreka sklepa (VII. točka izreka sklepa),
 - ugotovilo preostale splošne skupne dele stavbe z ident. št. X-1907 in na njih vzpostavilo solastninsko pravico v korist vsakokratnih lastnikov posameznih delov stavbe, s solastniškimi deleži iz VI. točke izreka sklepa (VIII. točka izreka sklepa),
 - ugotovilo obstoj lastninske pravice na novo vpisanih posameznih delih stavbe (IX. točka izreka sklepa),
 - ohranilo vse izvedene pravice oziroma vsa bremena, ustanovljena pri že vpisanih posameznih delih stavbe v vrstnem redu - bodisi pred bodisi po vpisu zaznambe tega postopka (XI. točka izreka sklepa) ter
 - odločilo, da se izpodbijani sklep izvede v zemljiški knjigi v vrstnem redu vpisane zaznambe postopka vzpostavitve etažne lastnine (XII. točka izreka sklepa.
 2. Zoper sklep se pravočasno pritožuje nasprotna udeleženka in druga udeleženka.
 Nasprotna udeleženka uveljavlja vse pritožbene razloge in predlaga, da se izpodbijani sklep spremeni tako, da se pri posameznih delih stavbe z ID znakom X-1907-103 in X-1907-114, kot lastnika ne določi nasprotne udeleženke, temveč drugega lastnika ali pa predlog v tem delu zavrne. Podrejeno predlaga razveljavitev izpodbijanega sklepa in vrnitev zadeve sodišču prve stopnje v nov postopek. Navaja, da predmetnih posameznih delov ni imela nikoli v lasti in je v postopku aktivno navajala, da ni njuna lastnica. Obvestilu upravnika o lastništvu na posameznih delih stavbe, iz katerega izhaja, da je lastnik teh posameznih delov B. B., ni nasprotovala. Vpis pravne prednice Mestne občine v zemljiško knjigo je zgolj posledica neurejenega zemljiškoknjižnega stanja oziroma nedokončane etažne lastnine. Pravna prednica Mestne občine je bila vpisana zgolj zato, ker je bila kot imetnica pravice uporabe zemljišča pod stavbo vpisana tudi v zemljiški knjigi. Z izpodbijano odločitvijo je sodišče prve stopnje poseglo v pravni in ekonomski položaj nasprotne udeleženke, kršeno je tudi načelo pravne varnosti.
 Druga udeleženka navaja, da je ob vpogledu v elaborat za vpis podatkov v kataster stavb, ki ga je prejela 18. 9. 2017, ugotovila, da je bil elaborat izdelan brez ogleda dejanskega stanja. V njem so navedeni neresnični podatki glede lastništva posameznih prostorov, njihove namembnosti, velikosti skupnih prostorov. Njena lastninska pravica je bila tako razvrednotena z navajanjem manjše stanovanjske kvadrature in njihove namenske rabe glede na prodajno pogodbo z dne 20. 5. 2010. Posledično je napačen tudi izračun idealnih deležev na splošnih skupnih delih stavbe. Del stavbe ima od 1. 8. 2017 nov naslov: K. 2A. Zakonita udeleženca, ki udeležbe nista prijavila, sta tudi C. in D. C. Lastniki na naslovu K. 2A bodo etažno lastnino izvedli sami.
 3. Upravnik, kot zakonit zastopnik Skupnosti vsakokratnih etažnih lastnikov stavbe na naslovu K. 2 in pooblaščenec 6. - 18. udeleženca, je na pritožbo nasprotne udeleženke odgovoril. Navaja, da se v evidenci upravnika dela stavbe z ID številko X-1907-103 in X-1907-114 kot lastnik vodi Mestna občina - oddelek za ..., prostor zaseda vrtec.
 5. Stavba z ident. št. X-1907, na kateri je sodišče prve stopnje dokončalo etažno lastnino, je bila pred začetkom predmetnega postopka že vpisana v kataster stavb. V takem primeru sodišče zagotovi spremembo vpisov oziroma nov vpis stavbe in njenih delov le, če ugotovi odločilno neskladje med dejanskim stanjem in stanjem v katastru stavb, ali če o tem, da se izvedejo spremembe oziroma nov vpis, med udeleženci ni spora (prvi odstavek 28. člena Zakona o vzpostavitvi etažne lastnine na določenih stavbah in o ugotavljanju pripadajočega zemljišča, v nadaljevanju: ZVEtL-1). Odstopanje evidentiranih tlorisov in površin delov stavbe od dejanskih, na kar se druga udeleženka pavšalno sklicuje v pritožbi, se ne šteje za odločilno neskladje med dejanskim stanjem in stanjem v katastru stavb (tretji odstavek 28. člena ZVEtL-1), zato je pritožbeni očitek druge udeleženke o manjši stanovanjski kvadraturi neutemeljen.
 6. Posameznim delom 104, 105, 106 in 107, v stavbi št. X-1907, je bil pred zaključkom postopka pred sodiščem prve stopnje, z obvestilom z dne 1. 8. 2017 (priloga D57), določen nov naslov: K. 2A. Določitev novega naslova na samo dokončanje etažne lastnine ne vpliva, saj gre kljub dvema naslovoma, po podatkih prostorskega portala RS ob dnevu odločanja pritožbenega sodišča, za eno stavbo. Glede na to, da je hišno številko stavbe sodišče prve stopnje uporabilo kot eno izmed okoliščin za identifikacijo stavbe, pa bi moralo to spremembo sodišče prve stopnje upoštevati pri pisanju sklepa (12. člen ZVEtL-1). Prav tako bo moralo sodišče prve stopnje ugotoviti, ali ima del stavbe na novem naslovu upravnika in v kolikor ga ima, pritegniti v postopek kot udeleženca tudi Skupnost vsakokratnih etažnih lastnikov na naslovu K. 2A (prvi odstavek 4. člena ZVEtL-1).
 7. Pritožbeno sodišče je pri preizkusu pritožbe druge udeleženke v delu, ki se nanaša na solastniške deleže na splošnih skupnih delih stavbe, ugotovilo, da seštevek deležev ni 1/1. V 9. točki obrazložitve izpodbijanega sklepa je sodišče prve stopnje določilo ključ za izračun solastniški deležev, vendar pritožbeno sodišče, upoštevajoč podatke o površinah delov stavbe, izhajajočih iz odločbe Geodetske uprave Republike Slovenije 02132-01098/2008-7 z dne 22. 1. 2009, ni moglo ugotoviti, kako je sodišče prve stopnje določilo imenovalec deležev na splošnih skupnih delih. Sklepa se v tem delu tako ne da preizkusiti.
 8. Etažna lastnina je lastnina posameznega dela zgradbe in solastnina skupnih delov (prvi odstavek 105. člena Stvarnopravnega zakonika). Del stavbe ne more biti hkrati posamezni in skupni del stavbe. Iz VI. točke izpodbijanega sklepa izhaja, da je sodišče prve stopnje za del stavbe z ID št. X-1907-111 ugotovilo, da je posamezen del, v VIII. točki pa, da gre za splošni skupni del, pri čemer iz obrazložitve sklepa niso razvidni razlogi za tako odločitev. V tem delu je izrek izpodbijanega sklepa sam s seboj v nasprotju, prav tako ga tudi ni mogoče preizkusiti. Podana je absolutna bistvena kršitev postopka iz 14. točke 339. člena Zakona o pravdnem postopku (v nadaljevanju: ZPP) v zvezi s 37. členom Zakona o nepravdnem postopku (v nadaljevanju: ZNP) in 3. členom ZVEtL-1.
 9. Glede na zgoraj ugotovljene (absolutne) bistvene kršitve postopka in zmotno uporaba materialnega prava, ki jih glede na njihovo naravo pritožbeno sodišče ne more samo odpraviti,2 je pritožbi druge udeleženke in posledično tudi pritožbi nasprotne udeleženke ugodilo, izpodbijani sklep razveljavilo in zadevo vrnilo sodišču prve stopnje v nov postopek (3. točka 365. člena ZPP v zvezi s 37. členom ZNP in 3. členom ZVEtL-1). V novem postopku naj sodišče odpravi navedene pomanjkljivosti.
 Temu je dodati, da je določba prvega odstavka 31. člena ZVEtL-1 jasna. V primeru, če za posamezni del stavbe na način, določen s tem zakonom, ni izkazan temelj pridobitve ali prenosa lastninske pravice v korist nobenega pridobitelja posameznega dela stavbe, sodišče ugotovi, da je njegov lastnik zemljiškoknjižni lastnik.
 10. Odločitev o stroških pritožbenega postopka se pridrži za končno odločbo (tretji odstavek 165. člen ZPP v zvezi s 37. členom ZNP in 3. členom ZVEtL-1 ).
 1 V izpodbijanem sklepu je pri navedbi katastrske občine očitna pisna pomota.
 2 V postopek pred sodiščem prve stopnje ni bil pritegnjen eden izmed udeležencev, glede ostalih ugotovljenih kršitev pa iz obrazložitve niso razvidni razlogi, ki bi omogočali preizkus odločitve oziroma so ti v nasprotju z izrekom sklepa.
 Zakon o vzpostavitvi etažne lastnine na določenih stavbah in o ugotavljanju pripadajočega zemljišča (2017) - ZVEtL-1 - člen 3, 4, 4/1, 12, 28, 28/1, 28/3, 31, 31/1
 Stvarnopravni zakonik (2002) - SPZ - člen 105, 105/1
 VSC Sklep Cp 349/2017
 VSL sklep I Cp 1740/2016
 P2RvYy0yMDE1MDgxMTExNDI2Njcx


text:
# Line 135 static struct regression_test_case regre Line 164 static struct regression_test_case regre
 164 { PCRE_CASELESS, 0, "\xff#a", "\xff#\xff\xfe##\xff#A" }, { PCRE_CASELESS, 0, "\xff#a", "\xff#\xff\xfe##\xff#A" },
 165 { PCRE_CASELESS, 0, "\xfe", "\xff\xfc#\xfe\xfe" }, { PCRE_CASELESS, 0, "\xfe", "\xff\xfc#\xfe\xfe" },
 167 { MA, 0, "\\Ca", "cda" },
 168 { CMA, 0, "\\Ca", "CDA" },
 169 { MA, 0 | F_NOMATCH, "\\Cx", "cda" },
 170 { CMA, 0 | F_NOMATCH, "\\Cx", "CDA" },
 # Line 146 static struct regression_test_case regre Line 183 static struct regression_test_case regre
 # Line 186 static struct regression_test_case regre Line 225 static struct regression_test_case regre
 # Line 263 static struct regression_test_case regre Line 302 static struct regression_test_case regre
 311 /* Bracket repeats with limit. */
 312 { MUA, 0, "(?:(ab){2}){5}M", "abababababababababababM" },
 313 { MUA, 0, "(?:ab|abab){1,5}M", "abababababababababababM" },
 314 { MUA, 0, "(?>ab|abab){1,5}M", "abababababababababababM" },
 315 { MUA, 0, "(?:ab|abab){1,5}?M", "abababababababababababM" },
 316 { MUA, 0, "(?>ab|abab){1,5}?M", "abababababababababababM" },
 317 { MUA, 0, "(?:(ab){1,4}?){1,3}?M", "abababababababababababababM" },
 318 { MUA, 0, "(?:(ab){1,4}){1,3}abababababababababababM", "ababababababababababababM" },
 319 { MUA, 0 | F_NOMATCH, "(?:(ab){1,4}){1,3}abababababababababababM", "abababababababababababM" },
 320 { MUA, 0, "(ab){4,6}?M", "abababababababM" },
 322 /* Basic character sets. */ /* Basic character sets. */
 323 { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " }, { MUA, 0, "(?:\\s)+(?:\\S)+", "ab \t\xc3\xa9\xe6\x92\xad " },
 # Line 274 static struct regression_test_case regre Line 329 static struct regression_test_case regre
 330 /* Unicode properties. */ /* Unicode properties. */
 331 { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" }, { MUAP, 0, "[1-5\xc3\xa9\\w]", "\xc3\xa1_" },
 332 { MUAP, 0, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" }, { MUAP, 0 | F_PROPERTY, "[\xc3\x81\\p{Ll}]", "A_\xc3\x89\xc3\xa1" },
 333 { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" }, { MUAP, 0, "[\\Wd-h_x-z]+", "a\xc2\xa1#_yhzdxi" },
 334 { MUAP, 0, "[\\P{Any}]", "abc" }, { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}]", "abc" },
 335 { MUAP, 0, "[^\\p{Any}]", "abc" }, { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}]", "abc" },
 336 { MUAP, 0, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" }, { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\\P{Any}\xc3\xa1-\xc3\xa8]", "abc" },
 337 { MUAP, 0, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" }, { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\\p{Any}\xc3\xa1-\xc3\xa8]", "abc" },
 338 { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" }, { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
 339 { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" }, { MUAP, 0 | F_NOMATCH | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
 340 { MUAP, 0, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" }, { MUAP, 0 | F_PROPERTY, "[\xc3\xa1-\xc3\xa8\\p{Any}]", "abc" },
 341 { MUAP, 0, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" }, { MUAP, 0 | F_PROPERTY, "[^\xc3\xa1-\xc3\xa8\\P{Any}]", "abc" },
 342 { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" }, { MUAP, 0, "[b-\xc3\xa9\\s]", "a\xc\xe6\x92\xad" },
 343 { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" }, { CMUAP, 0, "[\xc2\x85-\xc2\x89\xc3\x89]", "\xc2\x84\xc3\xa9" },
 344 { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" }, { MUAP, 0, "[^b-d^&\\s]{3,}", "db^ !a\xe2\x80\xa8_ae" },
 345 { MUAP, 0, "[^\\S\\P{Any}][\\sN]{1,3}[\\P{N}]{4}", "\xe2\x80\xaa\xa N\x9\xc3\xa9_0" }, { MUAP, 0 | F_PROPERTY, "[^\\S\\P{Any}][\\sN]{1,3}[\\P{N}]{4}", "\xe2\x80\xaa\xa N\x9\xc3\xa9_0" },
 346 { MUA, 0, "[^\\P{L}\x9!D-F\xa]{2,3}", "\x9,.DF\xa.CG\xc3\x81" }, { MUA, 0 | F_PROPERTY, "[^\\P{L}\x9!D-F\xa]{2,3}", "\x9,.DF\xa.CG\xc3\x81" },
 347 { CMUAP, 0, "[\xc3\xa1-\xc3\xa9_\xe2\x80\xa0-\xe2\x80\xaf]{1,5}[^\xe2\x80\xa0-\xe2\x80\xaf]", "\xc2\xa1\xc3\x89\xc3\x89\xe2\x80\xaf_\xe2\x80\xa0" }, { CMUAP, 0, "[\xc3\xa1-\xc3\xa9_\xe2\x80\xa0-\xe2\x80\xaf]{1,5}[^\xe2\x80\xa0-\xe2\x80\xaf]", "\xc2\xa1\xc3\x89\xc3\x89\xe2\x80\xaf_\xe2\x80\xa0" },
 348 { MUAP, 0, "[\xc3\xa2-\xc3\xa6\xc3\x81-\xc3\x84\xe2\x80\xa8-\xe2\x80\xa9\xe6\x92\xad\\p{Zs}]{2,}", "\xe2\x80\xa7\xe2\x80\xa9\xe6\x92\xad \xe6\x92\xae" }, { MUAP, 0 | F_PROPERTY, "[\xc3\xa2-\xc3\xa6\xc3\x81-\xc3\x84\xe2\x80\xa8-\xe2\x80\xa9\xe6\x92\xad\\p{Zs}]{2,}", "\xe2\x80\xa7\xe2\x80\xa9\xe6\x92\xad \xe6\x92\xae" },
 349 { MUAP, 0, "[\\P{L&}]{2}[^\xc2\x85-\xc2\x89\\p{Ll}\\p{Lu}]{2}", "\xc3\xa9\xe6\x92\xad.a\xe6\x92\xad|\xc2\x8a#" }, { MUAP, 0 | F_PROPERTY, "[\\P{L&}]{2}[^\xc2\x85-\xc2\x89\\p{Ll}\\p{Lu}]{2}", "\xc3\xa9\xe6\x92\xad.a\xe6\x92\xad|\xc2\x8a#" },
 350 { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB baaa" }, { PCRE_UCP, 0, "[a-b\\s]{2,5}[^a]", "AB baaa" },
 352 /* Possible empty brackets. */ /* Possible empty brackets. */
 # Line 308 static struct regression_test_case regre Line 363 static struct regression_test_case regre
 364 /* Start offset. */ /* Start offset. */
 365 { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" }, { MUA, 3, "(\\d|(?:\\w)*\\w)+", "0ac01Hb" },
 366 { MUA, 4, "(\\w\\W\\w)+", "ab#d" }, { MUA, 4 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
 367 { MUA, 2, "(\\w\\W\\w)+", "ab#d" }, { MUA, 2 | F_NOMATCH, "(\\w\\W\\w)+", "ab#d" },
 368 { MUA, 1, "(\\w\\W\\w)+", "ab#d" }, { MUA, 1, "(\\w\\W\\w)+", "ab#d" },
 370 /* Newline. */ /* Newline. */
 # Line 323 static struct regression_test_case regre Line 378 static struct regression_test_case regre
 378 { PCRE_NEWLINE_ANYCRLF, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" }, { PCRE_NEWLINE_ANYCRLF, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
 379 { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" }, { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.)", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa8" },
 380 { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.).", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa9$de" }, { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.).", "a\rb\nc\r\n\xc2\x85\xe2\x80\xa9$de" },
 381 { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0, ".(.).", "\xe2\x80\xa8\nb\r" }, { PCRE_NEWLINE_ANYCRLF | PCRE_UTF8, 0 | F_NOMATCH, ".(.).", "\xe2\x80\xa8\nb\r" },
 382 { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" }, { PCRE_NEWLINE_ANY, 0, "(.)(.)", "#\x85#\r#\n#\r\n#\x84" },
 383 { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" }, { PCRE_NEWLINE_ANY | PCRE_UTF8, 0, "(.+)#", "#\rMn\xc2\x85#\n###" },
 384 { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" }, { PCRE_BSR_ANYCRLF, 0, "\\R", "\r" },
 # Line 331 static struct regression_test_case regre Line 386 static struct regression_test_case regre
 386 { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" }, { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\xe2\x80\xa8#c" },
 387 { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" }, { PCRE_BSR_UNICODE | PCRE_UTF8, 0, "\\R", "ab\r\nc" },
 388 { PCRE_NEWLINE_CRLF | PCRE_BSR_UNICODE | PCRE_UTF8, 0, "(\\R.)+", "\xc2\x85\r\n#\xe2\x80\xa8\n\r\n\r" }, { PCRE_NEWLINE_CRLF | PCRE_BSR_UNICODE | PCRE_UTF8, 0, "(\\R.)+", "\xc2\x85\r\n#\xe2\x80\xa8\n\r\n\r" },
 389 { MUA, 0, "\\R+", "ab" }, { MUA, 0 | F_NOMATCH, "\\R+", "ab" },
 390 { MUA, 0, "\\R+", "ab\r\n\r" }, { MUA, 0, "\\R+", "ab\r\n\r" },
 391 { MUA, 0, "\\R*", "ab\r\n\r" }, { MUA, 0, "\\R*", "ab\r\n\r" },
 392 { MUA, 0, "\\R*", "\r\n\r" }, { MUA, 0, "\\R*", "\r\n\r" },
 # Line 339 static struct regression_test_case regre Line 394 static struct regression_test_case regre
 394 { MUA, 0, "\\R{2,4}", "\r\nab\n\n\n\r\r\r" }, { MUA, 0, "\\R{2,4}", "\r\nab\n\n\n\r\r\r" },
 395 { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" }, { MUA, 0, "\\R{2,}", "\r\nab\n\n\n\r\r\r" },
 396 { MUA, 0, "\\R{0,3}", "\r\n\r\n\r\n\r\n\r\n" }, { MUA, 0, "\\R{0,3}", "\r\n\r\n\r\n\r\n\r\n" },
 397 { MUA, 0, "\\R+\\R\\R", "\r\n\r\n" }, { MUA, 0 | F_NOMATCH, "\\R+\\R\\R", "\r\n\r\n" },
 398 { MUA, 0, "\\R+\\R\\R", "\r\r\r" }, { MUA, 0, "\\R+\\R\\R", "\r\r\r" },
 399 { MUA, 0, "\\R*\\R\\R", "\n\r" }, { MUA, 0, "\\R*\\R\\R", "\n\r" },
 400 { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r" }, { MUA, 0 | F_NOMATCH, "\\R{2,4}\\R\\R", "\r\r\r" },
 401 { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" }, { MUA, 0, "\\R{2,4}\\R\\R", "\r\r\r\r" },
 403 /* Atomic groups (no fallback from "next" direction). */ /* Atomic groups (no fallback from "next" direction). */
 404 { MUA, 0, "(?>ab)ab", "bab" }, { MUA, 0 | F_NOMATCH, "(?>ab)ab", "bab" },
 405 { MUA, 0, "(?>(ab))ab", "bab" }, { MUA, 0 | F_NOMATCH, "(?>(ab))ab", "bab" },
 406 { MUA, 0, "(?>ab)+abc(?>de)*def(?>gh)?ghe(?>ij)+?k(?>lm)*?n(?>op)?\?op", { MUA, 0, "(?>ab)+abc(?>de)*def(?>gh)?ghe(?>ij)+?k(?>lm)*?n(?>op)?\?op",
 407 "bababcdedefgheijijklmlmnop" }, "bababcdedefgheijijklmlmnop" },
 408 { MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" }, { MUA, 0, "(?>a(b)+a|(ab)?\?(b))an", "abban" },
 # Line 375 static struct regression_test_case regre Line 430 static struct regression_test_case regre
 430 { CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" }, { CMA, 0, "(?>((?>a{32}|b+|(a*))?(?>c+|d*)?\?)+e)+?f", "aaccebbdde bbdaaaccebbdee bbdaaaccebbdeef" },
 431 { MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" }, { MUA, 0, "(?>(?:(?>aa|a||x)+?b|(?>aa|a||(x))+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
 432 { MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" }, { MUA, 0, "(?>(?:(?>aa|a||(x))+?b|(?>aa|a||x)+?c)?(?>[ad]{0,2})*?d)+d", "aaacdbaabdcabdbaaacd aacaabdbdcdcaaaadaabcbaadd" },
 433 { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d" }, { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d" },
 434 { MUA, 0, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" }, { MUA, 0 | F_PROPERTY, "\\X", "\xcc\x8d\xcc\x8d#\xcc\x8d\xcc\x8d" },
 435 { MUA, 0, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" }, { MUA, 0 | F_PROPERTY, "\\X+..", "\xcc\x8d#\xcc\x8d#\xcc\x8d\xcc\x8d" },
 436 { MUA, 0, "\\X{2,4}", "abcdef" }, { MUA, 0 | F_PROPERTY, "\\X{2,4}", "abcdef" },
 437 { MUA, 0, "\\X{2,4}?", "abcdef" }, { MUA, 0 | F_PROPERTY, "\\X{2,4}?", "abcdef" },
 438 { MUA, 0, "\\X{2,4}..", "#\xcc\x8d##" }, { MUA, 0 | F_NOMATCH | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d##" },
 439 { MUA, 0, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" }, { MUA, 0 | F_PROPERTY, "\\X{2,4}..", "#\xcc\x8d#\xcc\x8d##" },
 440 { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" }, { MUA, 0, "(c(ab)?+ab)+", "cabcababcab" },
 441 { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" }, { MUA, 0, "(?>(a+)b)+aabab", "aaaabaaabaabab" },
 # Line 416 static struct regression_test_case regre Line 471 static struct regression_test_case regre
 471 { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" }, { MUA, 0, "((b*))++m", "bxbbxbbbxbbm" },
 472 { MUA, 0, "((b*))*+m", "bxbbxbbbxm" }, { MUA, 0, "((b*))*+m", "bxbbxbbbxm" },
 473 { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" }, { MUA, 0, "((b*))*+m", "bxbbxbbbxbbm" },
 474 { MUA, 0, "(?>(b{2,4}))(?:(?:(aa|c))++m|(?:(aa|c))+n)", "bbaacaaccaaaacxbbbmbn" }, { MUA, 0 | F_NOMATCH, "(?>(b{2,4}))(?:(?:(aa|c))++m|(?:(aa|c))+n)", "bbaacaaccaaaacxbbbmbn" },
 475 { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" }, { MUA, 0, "((?:b)++a)+(cd)*+m", "bbababbacdcdnbbababbacdcdm" },
 476 { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" }, { MUA, 0, "((?:(b))++a)+((c)d)*+m", "bbababbacdcdnbbababbacdcdm" },
 477 { MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" }, { MUA, 0, "(?:(?:(?:ab)*+k)++(?:n(?:cd)++)*+)*+m", "ababkkXababkkabkncXababkkabkncdcdncdXababkkabkncdcdncdkkabkncdXababkkabkncdcdncdkkabkncdm" },
 # Line 440 static struct regression_test_case regre Line 495 static struct regression_test_case regre
 495 { MUA, 0, "(?:(aa|bb)(\\1{0,3}?)){2}(dd|)(\\3{0,3}?)b(\\1{0,3}?)(\\1{0,3})", "aaaaaaaaaaaaaaabaaaaa" }, { MUA, 0, "(?:(aa|bb)(\\1{0,3}?)){2}(dd|)(\\3{0,3}?)b(\\1{0,3}?)(\\1{0,3})", "aaaaaaaaaaaaaaabaaaaa" },
 496 { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" }, { MUA, 0, "(a(?:\\1|)a){3}b", "aaaaaaaaaaab" },
 497 { MA, 0, "(a?)b(\\1\\1*\\1+\\1?\\1*?\\1+?\\1??\\1*+\\1++\\1?+\\1{4}\\1{3,5}\\1{4,}\\1{0,5}\\1{3,5}?\\1{4,}?\\1{0,5}?\\1{3,5}+\\1{4,}+\\1{0,5}+#){2}d", "bb#b##d" }, { MA, 0, "(a?)b(\\1\\1*\\1+\\1?\\1*?\\1+?\\1??\\1*+\\1++\\1?+\\1{4}\\1{3,5}\\1{4,}\\1{0,5}\\1{3,5}?\\1{4,}?\\1{0,5}?\\1{3,5}+\\1{4,}+\\1{0,5}+#){2}d", "bb#b##d" },
 498 { MUAP, 0, "(\\P{N})\\1{2,}", ".www." }, { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
 499 { MUAP, 0, "(\\P{N})\\1{0,2}", "wwwww." }, { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{0,2}", "wwwww." },
 500 { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwww" }, { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwww" },
 501 { MUAP, 0, "(\\P{N})\\1{1,2}ww", "wwwww" }, { MUAP, 0 | F_PROPERTY, "(\\P{N})\\1{1,2}ww", "wwwww" },
 502 { PCRE_UCP, 0, "(\\P{N})\\1{2,}", ".www." }, { PCRE_UCP, 0 | F_PROPERTY, "(\\P{N})\\1{2,}", ".www." },
 503 { CMUAP, 0, "(\xf0\x90\x90\x80)\\1", "\xf0\x90\x90\xa8\xf0\x90\x90\xa8" },
 505 /* Assertions. */ /* Assertions. */
 506 { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" }, { MUA, 0, "(?=xx|yy|zz)\\w{4}", "abczzdefg" },
 # Line 460 static struct regression_test_case regre Line 516 static struct regression_test_case regre
 516 { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" }, { MUA, 0, "(?>a(?>(b+))a(?=(..)))*?k", "acabbcabbaabacabaabbakk" },
 517 { MUA, 0, "((?(?=(a))a)+k)", "bbak" }, { MUA, 0, "((?(?=(a))a)+k)", "bbak" },
 518 { MUA, 0, "((?(?=a)a)+k)", "bbak" }, { MUA, 0, "((?(?=a)a)+k)", "bbak" },
 519 { MUA, 0, "(?=(?>(a))m)amk", "a k" }, { MUA, 0 | F_NOMATCH, "(?=(?>(a))m)amk", "a k" },
 520 { MUA, 0, "(?!(?>(a))m)amk", "a k" }, { MUA, 0 | F_NOMATCH, "(?!(?>(a))m)amk", "a k" },
 521 { MUA, 0, "(?>(?=(a))am)amk", "a k" }, { MUA, 0 | F_NOMATCH, "(?>(?=(a))am)amk", "a k" },
 522 { MUA, 0, "(?=(?>a|(?=(?>(b+))a|c)[a-c]+)*?m)[a-cm]+k", "aaam bbam baaambaam abbabba baaambaamk" }, { MUA, 0, "(?=(?>a|(?=(?>(b+))a|c)[a-c]+)*?m)[a-cm]+k", "aaam bbam baaambaam abbabba baaambaamk" },
 523 { MUA, 0, "(?> ?\?\\b(?(?=\\w{1,4}(a))m)\\w{0,8}bc){2,}?", "bca ssbc mabd ssbc mabc" }, { MUA, 0, "(?> ?\?\\b(?(?=\\w{1,4}(a))m)\\w{0,8}bc){2,}?", "bca ssbc mabd ssbc mabc" },
 524 { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" }, { MUA, 0, "(?:(?=ab)?[^n][^n])+m", "ababcdabcdcdabnababcdabcdcdabm" },
 # Line 473 static struct regression_test_case regre Line 529 static struct regression_test_case regre
 529 { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" }, { MUA, 0, "((?!a)?\?(?!([^a]))?\?)+$", "acbab" },
 531 /* Not empty, ACCEPT, FAIL */ /* Not empty, ACCEPT, FAIL */
 532 { MUA | PCRE_NOTEMPTY, 0, "a*", "bcx" }, { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*", "bcx" },
 533 { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" }, { MUA | PCRE_NOTEMPTY, 0, "a*", "bcaad" },
 534 { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" }, { MUA | PCRE_NOTEMPTY, 0, "a*?", "bcaad" },
 535 { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" }, { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*", "bcaad" },
 536 { MUA, 0, "a(*ACCEPT)b", "ab" }, { MUA, 0, "a(*ACCEPT)b", "ab" },
 537 { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcx" }, { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a*(*ACCEPT)b", "bcx" },
 538 { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" }, { MUA | PCRE_NOTEMPTY, 0, "a*(*ACCEPT)b", "bcaad" },
 539 { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" }, { MUA | PCRE_NOTEMPTY, 0, "a*?(*ACCEPT)b", "bcaad" },
 540 { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcx" }, { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "(?:z|a*(*ACCEPT)b)", "bcx" },
 541 { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" }, { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*(*ACCEPT)b)", "bcaad" },
 542 { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" }, { MUA | PCRE_NOTEMPTY, 0, "(?:z|a*?(*ACCEPT)b)", "bcaad" },
 543 { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" }, { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "bcx" },
 544 { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a*(*ACCEPT)b", "" }, { MUA | PCRE_NOTEMPTY_ATSTART, 0 | F_NOMATCH, "a*(*ACCEPT)b", "" },
 545 { MUA, 0, "((a(*ACCEPT)b))", "ab" }, { MUA, 0, "((a(*ACCEPT)b))", "ab" },
 546 { MUA, 0, "(a(*FAIL)a|a)", "aaa" }, { MUA, 0, "(a(*FAIL)a|a)", "aaa" },
 547 { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" }, { MUA, 0, "(?=ab(*ACCEPT)b)a", "ab" },
 # Line 502 static struct regression_test_case regre Line 558 static struct regression_test_case regre
 558 { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" }, { MUA, 0, "(?(?!(b))a*|b*)+k", "ababbalbbadabak" },
 559 { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" }, { MUA, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
 560 { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" }, { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+aaaak", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb aaaaaaak" },
 561 { MUA | PCRE_BUG, 0, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" }, { MUA, 0 | F_DIFF, "(?(?!(b))(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
 562 { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" }, { MUA, 0, "(?(?!b)(?:aaaaaa|a)|(?:bbbbbb|b))+bbbbk", "aaaaaaaaaaaaaa bbbbbbbbbbbbbbb bbbbbbbk" },
 563 { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" }, { MUA, 0, "(?(?=a)a*|b*)+k", "ababbalbbadabak" },
 564 { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" }, { MUA, 0, "(?(?!b)a*|b*)+k", "ababbalbbadabak" },
 # Line 516 static struct regression_test_case regre Line 572 static struct regression_test_case regre
 572 { MUA, 0, "((?=\\w{5})\\w(?(?=\\w*k)\\d|[a-f_])*\\w\\s)+", "mol m10kk m088k _f_a_ mbkkl" }, { MUA, 0, "((?=\\w{5})\\w(?(?=\\w*k)\\d|[a-f_])*\\w\\s)+", "mol m10kk m088k _f_a_ mbkkl" },
 573 { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" }, { MUA, 0, "(c)?\?(?(1)a|b)", "cdcaa" },
 574 { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" }, { MUA, 0, "(c)?\?(?(1)a|b)", "cbb" },
 575 { MUA | PCRE_BUG, 0, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" }, { MUA, 0 | F_DIFF, "(?(?=(a))(aaaa|a?))+aak", "aaaaab aaaaak" },
 576 { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" }, { MUA, 0, "(?(?=a)(aaaa|a?))+aak", "aaaaab aaaaak" },
 577 { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" }, { MUA, 0, "(?(?!(b))(aaaa|a?))+aak", "aaaaab aaaaak" },
 578 { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" }, { MUA, 0, "(?(?!b)(aaaa|a?))+aak", "aaaaab aaaaak" },
 579 { MUA | PCRE_BUG, 0, "(?(?=(a))a*)+aak", "aaaaab aaaaak" }, { MUA, 0 | F_DIFF, "(?(?=(a))a*)+aak", "aaaaab aaaaak" },
 580 { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" }, { MUA, 0, "(?(?=a)a*)+aak", "aaaaab aaaaak" },
 581 { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" }, { MUA, 0, "(?(?!(b))a*)+aak", "aaaaab aaaaak" },
 582 { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" }, { MUA, 0, "(?(?!b)a*)+aak", "aaaaab aaaaak" },
 583 { MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" }, { MUA, 0, "(?(?=(?=(?!(x))a)aa)aaa|(?(?=(?!y)bb)bbb))*k", "abaabbaaabbbaaabbb abaabbaaabbbaaabbbk" },
 584 { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)*l", "bc ddd abccabccl" },
 585 { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+?dd", "bcabcacdb bdddd" },
 586 { MUA, 0, "(?P<Name>a)?(?P<Name2>b)?(?(Name)c|d)+l", "ababccddabdbccd abcccl" },
 587 { MUA, 0, "((?:a|aa)(?(1)aaa))x", "aax" },
 589 /* Set start of match. */ /* Set start of match. */
 590 { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" }, { MUA, 0, "(?:\\Ka)*aaaab", "aaaaaaaa aaaaaaabb" },
 591 { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" }, { MUA, 0, "(?>\\Ka\\Ka)*aaaab", "aaaaaaaa aaaaaaaaaabb" },
 592 { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" }, { MUA, 0, "a+\\K(?<=\\Gaa)a", "aaaaaa" },
 593 { MUA | PCRE_NOTEMPTY, 0, "a\\K(*ACCEPT)b", "aa" }, { MUA | PCRE_NOTEMPTY, 0 | F_NOMATCH, "a\\K(*ACCEPT)b", "aa" },
 594 { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" }, { MUA | PCRE_NOTEMPTY_ATSTART, 0, "a\\K(*ACCEPT)b", "aa" },
 596 /* First line. */ /* First line. */
 597 { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\naaa" }, { MUA | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}a", "bb\naaa" },
 598 { MUA | PCRE_FIRSTLINE, 0, "\\p{Any}a", "bb\r\naaa" }, { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}a", "bb\r\naaa" },
 599 { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" }, { MUA | PCRE_FIRSTLINE, 0, "(?<=a)", "a" },
 600 { MUA | PCRE_FIRSTLINE, 0, "[^a][^b]", "ab" }, { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[^a][^b]", "ab" },
 601 { MUA | PCRE_FIRSTLINE, 0, "a", "\na" }, { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "a", "\na" },
 602 { MUA | PCRE_FIRSTLINE, 0, "[abc]", "\na" }, { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "[abc]", "\na" },
 603 { MUA | PCRE_FIRSTLINE, 0, "^a", "\na" }, { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^a", "\na" },
 604 { MUA | PCRE_FIRSTLINE, 0, "^(?<=\n)", "\na" }, { MUA | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^(?<=\n)", "\na" },
 605 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\xc2\x85#" }, { MUA | PCRE_FIRSTLINE, 0, "\xf0\x90\x90\x80", "\xf0\x90\x90\x80" },
 606 { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "#", "\x85#" }, { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\xc2\x85#" },
 607 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0, "^#", "\xe2\x80\xa8#" }, { PCRE_MULTILINE | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "#", "\x85#" },
 608 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "\\p{Any}", "\r\na" }, { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_ANY | PCRE_FIRSTLINE, 0 | F_NOMATCH, "^#", "\xe2\x80\xa8#" },
 609 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_PROPERTY, "\\p{Any}", "\r\na" },
 610 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" }, { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, ".", "\r" },
 611 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" }, { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "a", "\ra" },
 612 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "ba", "bbb\r\nba" }, { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH, "ba", "bbb\r\nba" },
 613 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0, "\\p{Any}{4}|a", "\r\na" }, { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 0 | F_NOMATCH | F_PROPERTY, "\\p{Any}{4}|a", "\r\na" },
 614 { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" }, { PCRE_MULTILINE | PCRE_UTF8 | PCRE_NEWLINE_CRLF | PCRE_FIRSTLINE, 1, ".", "\r\n" },
 615 { PCRE_FIRSTLINE | PCRE_NEWLINE_LF | PCRE_DOTALL, 0 | F_NOMATCH, "ab.", "ab" },
 617 /* Recurse. */ /* Recurse. */
 618 { MUA, 0, "(a)(?1)", "aa" }, { MUA, 0, "(a)(?1)", "aa" },
 619 { MUA, 0, "((a))(?1)", "aa" }, { MUA, 0, "((a))(?1)", "aa" },
 620 { MUA, 0, "(b|a)(?1)", "aa" }, { MUA, 0, "(b|a)(?1)", "aa" },
 621 { MUA, 0, "(b|(a))(?1)", "aa" }, { MUA, 0, "(b|(a))(?1)", "aa" },
 622 { MUA, 0, "((a)(b)(?:a*))(?1)", "aba" }, { MUA, 0 | F_NOMATCH, "((a)(b)(?:a*))(?1)", "aba" },
 623 { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" }, { MUA, 0, "((a)(b)(?:a*))(?1)", "abab" },
 624 { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" }, { MUA, 0, "((a+)c(?2))b(?1)", "aacaabaca" },
 625 { MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" }, { MUA, 0, "((?2)b|(a)){2}(?1)", "aabab" },
 # Line 565 static struct regression_test_case regre Line 627 static struct regression_test_case regre
 627 { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" }, { MUA, 0, "(?1)(((a(*ACCEPT)))b)", "axaa" },
 628 { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" }, { MUA, 0, "(?1)(?(DEFINE) (((ac(*ACCEPT)))b) )", "akaac" },
 629 { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" }, { MUA, 0, "(a+)b(?1)b\\1", "abaaabaaaaa" },
 630 { MUA, 0, "(?(DEFINE)(aa|a))(?1)ab", "aab" }, { MUA, 0 | F_NOMATCH, "(?(DEFINE)(aa|a))(?1)ab", "aab" },
 631 { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" }, { MUA, 0, "(?(DEFINE)(a\\Kb))(?1)+ababc", "abababxabababc" },
 632 { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" }, { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababc" },
 633 { MUA, 0, "(a\\Kb)(?1)+ababc", "abababxababababxc" }, { MUA, 0 | F_NOMATCH, "(a\\Kb)(?1)+ababc", "abababxababababxc" },
 634 { MUA, 0, "b|<(?R)*>", "<<b>" }, { MUA, 0, "b|<(?R)*>", "<<b>" },
 635 { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" }, { MUA, 0, "(a\\K){0}(?:(?1)b|ac)", "ac" },
 636 { MUA, 0, "(?(DEFINE)(a(?2)|b)(b(?1)|(a)))(?:(?1)|(?2))m", "ababababnababababaam" }, { MUA, 0, "(?(DEFINE)(a(?2)|b)(b(?1)|(a)))(?:(?1)|(?2))m", "ababababnababababaam" },
 637 { MUA, 0, "(a)((?(R)a|b))(?2)", "aabbabaa" },
 638 { MUA, 0, "(a)((?(R2)a|b))(?2)", "aabbabaa" },
 639 { MUA, 0, "(a)((?(R1)a|b))(?2)", "ababba" },
 640 { MUA, 0, "(?(R0)aa|bb(?R))", "abba aabb bbaa" },
 641 { MUA, 0, "((?(R)(?:aaaa|a)|(?:(aaaa)|(a)))+)(?1)$", "aaaaaaaaaa aaaa" },
 642 { MUA, 0, "(?P<Name>a(?(R&Name)a|b))(?1)", "aab abb abaa" },
 643 { MUA, 0, "((?(R)a|(?1)){3})", "XaaaaaaaaaX" },
 644 { MUA, 0, "((?:(?(R)a|(?1))){3})", "XaaaaaaaaaX" },
 645 { MUA, 0, "((?(R)a|(?1)){1,3})aaaaaa", "aaaaaaaaXaaaaaaaaa" },
 646 { MUA, 0, "((?(R)a|(?1)){1,3}?)M", "aaaM" },
 648 /* 16 bit specific tests. */
 649 { CMA, 0 | F_FORCECONV, "\xc3\xa1", "\xc3\x81\xc3\xa1" },
 650 { CMA, 0 | F_FORCECONV, "\xe1\xbd\xb8", "\xe1\xbf\xb8\xe1\xbd\xb8" },
 651 { CMA, 0 | F_FORCECONV, "[\xc3\xa1]", "\xc3\x81\xc3\xa1" },
 652 { CMA, 0 | F_FORCECONV, "[\xe1\xbd\xb8]", "\xe1\xbf\xb8\xe1\xbd\xb8" },
 653 { CMA, 0 | F_FORCECONV, "[a-\xed\xb0\x80]", "A" },
 654 { CMA, 0 | F_NO8 | F_FORCECONV, "[a-\\x{dc00}]", "B" },
 655 { CMA, 0 | F_NO8 | F_NOMATCH | F_FORCECONV, "[b-\\x{dc00}]", "a" },
 656 { CMA, 0 | F_NO8 | F_FORCECONV, "\xed\xa0\x80\\x{d800}\xed\xb0\x80\\x{dc00}", "\xed\xa0\x80\xed\xa0\x80\xed\xb0\x80\xed\xb0\x80" },
 657 { CMA, 0 | F_NO8 | F_FORCECONV, "[\xed\xa0\x80\\x{d800}]{1,2}?[\xed\xb0\x80\\x{dc00}]{1,2}?#", "\xed\xa0\x80\xed\xa0\x80\xed\xb0\x80\xed\xb0\x80#" },
 658 { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80\xed\xb0\x80#]{0,3}(?<=\xed\xb0\x80.)", "\xed\xa0\x80#\xed\xa0\x80##\xed\xb0\x80\xed\xa0\x80" },
 659 { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\x9f\xbf\xed\xa0\x83" },
 660 { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xed\xb3\xbf]", "\xed\xb4\x80\xed\xb3\xb0" },
 661 { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\x9f\xbf\xed\xa0\x83" },
 662 { CMA, 0 | F_NO8 | F_FORCECONV, "[\\x{d800}-\\x{dcff}]", "\xed\xb4\x80\xed\xb3\xb0" },
 663 { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80-\xef\xbf\xbf]+[\x1-\xed\xb0\x80]+#", "\xed\xa0\x85\xc3\x81\xed\xa0\x85\xef\xbf\xb0\xc2\x85\xed\xa9\x89#" },
 664 { CMA, 0 | F_FORCECONV, "[\xed\xa0\x80][\xed\xb0\x80]{2,}", "\xed\xa0\x80\xed\xb0\x80\xed\xa0\x80\xed\xb0\x80\xed\xb0\x80\xed\xb0\x80" },
 665 { MA, 0 | F_FORCECONV, "[^\xed\xb0\x80]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
 666 { MA, 0 | F_NO8 | F_FORCECONV, "[^\\x{dc00}]{3,}?", "##\xed\xb0\x80#\xed\xb0\x80#\xc3\x89#\xed\xb0\x80" },
 667 { CMA, 0 | F_FORCECONV, ".\\B.", "\xed\xa0\x80\xed\xb0\x80" },
 668 { CMA, 0 | F_FORCECONV, "\\D+(?:\\d+|.)\\S+(?:\\s+|.)\\W+(?:\\w+|.)\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80" },
 669 { CMA, 0 | F_FORCECONV, "\\d*\\s*\\w*\xed\xa0\x80\xed\xa0\x80", "\xed\xa0\x80\xed\xa0\x80" },
 670 { CMA, 0 | F_FORCECONV | F_NOMATCH, "\\d*?\\D*?\\s*?\\S*?\\w*?\\W*?##", "\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80\xed\xa0\x80#" },
 671 { CMA | PCRE_EXTENDED, 0 | F_FORCECONV, "\xed\xa0\x80 \xed\xb0\x80 !", "\xed\xa0\x80\xed\xb0\x80!" },
 672 { CMA, 0 | F_FORCECONV, "\xed\xa0\x80+#[^#]+\xed\xa0\x80", "\xed\xa0\x80#a\xed\xa0\x80" },
 673 { CMA, 0 | F_FORCECONV, "(\xed\xa0\x80+)#\\1", "\xed\xa0\x80\xed\xa0\x80#\xed\xa0\x80\xed\xa0\x80" },
 674 { PCRE_MULTILINE | PCRE_NEWLINE_ANY, 0 | F_NO8 | F_FORCECONV, "^-", "a--\xe2\x80\xa8--" },
 675 { PCRE_BSR_UNICODE, 0 | F_NO8 | F_FORCECONV, "\\R", "ab\xe2\x80\xa8" },
 676 { 0, 0 | F_NO8 | F_FORCECONV, "\\v", "ab\xe2\x80\xa9" },
 677 { 0, 0 | F_NO8 | F_FORCECONV, "\\h", "ab\xe1\xa0\x8e" },
 678 { 0, 0 | F_NO8 | F_FORCECONV, "\\v+?\\V+?#", "\xe2\x80\xa9\xe2\x80\xa9\xef\xbf\xbf\xef\xbf\xbf#" },
 679 { 0, 0 | F_NO8 | F_FORCECONV, "\\h+?\\H+?#", "\xe1\xa0\x8e\xe1\xa0\x8e\xef\xbf\xbf\xef\xbf\xbf#" },
 681 /* Partial matching. */
 682 { MUA | PCRE_PARTIAL_SOFT, 0, "ab", "a" },
 683 { MUA | PCRE_PARTIAL_SOFT, 0, "ab|a", "a" },
 684 { MUA | PCRE_PARTIAL_HARD, 0, "ab|a", "a" },
 685 { MUA | PCRE_PARTIAL_SOFT, 0, "\\b#", "a" },
 686 { MUA | PCRE_PARTIAL_SOFT, 0, "(?<=a)b", "a" },
 687 { MUA | PCRE_PARTIAL_SOFT, 0, "abc|(?<=xxa)bc", "xxab" },
 688 { MUA | PCRE_PARTIAL_SOFT, 0, "a\\B", "a" },
 689 { MUA | PCRE_PARTIAL_HARD, 0, "a\\b", "a" },
 691 /* (*MARK) verb. */
 692 { MUA, 0, "a(*MARK:aa)a", "ababaa" },
 693 { MUA, 0 | F_NOMATCH, "a(*:aa)a", "abab" },
 694 { MUA, 0, "a(*:aa)(b(*:bb)b|bc)", "abc" },
 695 { MUA, 0 | F_NOMATCH, "a(*:1)x|b(*:2)y", "abc" },
 696 { MUA, 0, "(?>a(*:aa))b|ac", "ac" },
 697 { MUA, 0, "(?(DEFINE)(a(*:aa)))(?1)", "a" },
 698 { MUA, 0 | F_NOMATCH, "(?(DEFINE)((a)(*:aa)))(?1)b", "aa" },
 699 { MUA, 0, "(?(DEFINE)(a(*:aa)))a(?1)b|aac", "aac" },
 700 { MUA, 0, "(a(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
 701 { MUA, 0, "(a(*:aa)){0}(?:b(?1)b)+", "babba" },
 702 { MUA, 0 | F_NOMATCH | F_STUDY, "(a(*:aa)){0}(?:b(?1)b)+", "ba" },
 703 { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b|c)+c", "babbab cc" },
 704 { MUA, 0, "(a\\K(*:aa)){0}(?:b(?1)b)+", "babba" },
 705 { MUA, 0 | F_NOMATCH | F_STUDY, "(a\\K(*:aa)){0}(?:b(?1)b)+", "ba" },
 706 { MUA, 0 | F_NOMATCH | F_STUDY, "(*:mark)m", "a" },
 708 /* (*COMMIT) verb. */
 709 { MUA, 0 | F_NOMATCH, "a(*COMMIT)b", "ac" },
 710 { MUA, 0, "aa(*COMMIT)b", "xaxaab" },
 711 { MUA, 0 | F_NOMATCH, "a(*COMMIT)(*:msg)b|ac", "ac" },
 712 { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b)++", "abac" },
 713 { MUA, 0 | F_NOMATCH, "((a)(*COMMIT)b)++", "abac" },
 714 { MUA, 0 | F_NOMATCH, "(?=a(*COMMIT)b)ab|ad", "ad" },
 716 /* (*PRUNE) verb. */
 717 { MUA, 0, "aa\\K(*PRUNE)b", "aaab" },
 718 { MUA, 0, "aa(*PRUNE:bb)b|a", "aa" },
 719 { MUA, 0, "(a)(a)(*PRUNE)b|(a)", "aa" },
 720 { MUA, 0, "(a)(a)(a)(a)(a)(a)(a)(a)(*PRUNE)b|(a)", "aaaaaaaa" },
 721 { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|", "a" },
 722 { MUA | PCRE_PARTIAL_SOFT, 0, "a(*PRUNE)a|m", "a" },
 723 { MUA, 0 | F_NOMATCH, "(?=a(*PRUNE)b)ab|ad", "ad" },
 724 { MUA, 0, "a(*COMMIT)(*PRUNE)d|bc", "abc" },
 725 { MUA, 0, "(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
 726 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=a(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
 727 { MUA, 0, "(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
 728 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?=(a)(*COMMIT)b)a(*PRUNE)c|bc", "abc" },
 729 { MUA, 0, "(a(*COMMIT)b){0}a(?1)(*PRUNE)c|bc", "abc" },
 730 { MUA, 0 | F_NOMATCH, "(a(*COMMIT)b){0}a(*COMMIT)(?1)(*PRUNE)c|bc", "abc" },
 731 { MUA, 0, "(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
 732 { MUA, 0 | F_NOMATCH, "(*COMMIT)(a(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
 733 { MUA, 0, "((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
 734 { MUA, 0 | F_NOMATCH, "(*COMMIT)((a)(*COMMIT)b)++(*PRUNE)d|c", "ababc" },
 735 { MUA, 0, "(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
 736 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*abab(*PRUNE)d|ba", "ababab" },
 737 { MUA, 0, "(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
 738 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+abab(*PRUNE)d|ba", "ababab" },
 739 { MUA, 0, "(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
 740 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)?ab(*PRUNE)d|ba", "aba" },
 741 { MUA, 0, "(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
 742 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)*?n(*PRUNE)d|ba", "abababn" },
 743 { MUA, 0, "(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
 744 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)+?n(*PRUNE)d|ba", "abababn" },
 745 { MUA, 0, "(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
 746 { MUA, 0 | F_NOMATCH, "(*COMMIT)(?>a(*COMMIT)b)??n(*PRUNE)d|bn", "abn" },
 748 /* (*SKIP) verb. */
 749 { MUA, 0 | F_NOMATCH, "(?=a(*SKIP)b)ab|ad", "ad" },
 751 /* (*THEN) verb. */
 752 { MUA, 0, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcaabcaabcaabcnacm" },
 753 { MUA, 0 | F_NOMATCH, "((?:a(*THEN)|aab)(*THEN)c|a+)+m", "aabcm" },
 754 { MUA, 0, "((?:a(*THEN)|aab)c|a+)+m", "aabcaabcnmaabcaabcm" },
 755 { MUA, 0, "((?:a|aab)(*THEN)c|a+)+m", "aam" },
 756 { MUA, 0, "((?:a(*COMMIT)|aab)(*THEN)c|a+)+m", "aam" },
 757 { MUA, 0, "(?(?=a(*THEN)b)ab|ad)", "ad" },
 758 { MUA, 0, "(?(?!a(*THEN)b)ad|add)", "add" },
 759 { MUA, 0 | F_NOMATCH, "(?(?=a)a(*THEN)b|ad)", "ad" },
 760 { MUA, 0, "(?!(?(?=a)ab|b(*THEN)d))bn|bnn", "bnn" },
 762 /* Deep recursion. */ /* Deep recursion. */
 763 { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " }, { MUA, 0, "((((?:(?:(?:\\w)+)?)*|(?>\\w)+?)+|(?>\\w)?\?)*)?\\s", "aaaaa+ " },
 764 { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " }, { MUA, 0, "(?:((?:(?:(?:\\w*?)+)??|(?>\\w)?|\\w*+)*)+)+?\\s", "aa+ " },
 765 { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaaa b" }, { MUA, 0, "((a?)+)+b", "aaaaaaaaaaaa b" },
 767 /* Deep recursion: Stack limit reached. */ /* Deep recursion: Stack limit reached. */
 768 { MA, 0, "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaa" }, { MA, 0 | F_NOMATCH, "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaa" },
 769 { MA, 0, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" }, { MA, 0 | F_NOMATCH, "(?:a+)+b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
 770 { MA, 0, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" }, { MA, 0 | F_NOMATCH, "(?:a+?)+?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
 771 { MA, 0, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" }, { MA, 0 | F_NOMATCH, "(?:a*)*b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
 772 { MA, 0, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" }, { MA, 0 | F_NOMATCH, "(?:a*?)*?b", "aaaaaaaaaaaaaaaaaaaaaaaa b" },
 774 { 0, 0, NULL, NULL } { 0, 0, NULL, NULL }
 775 }; };
 777 static const unsigned char *tables(int mode)
 779 /* The purpose of this function to allow valgrind
 780 for reporting invalid reads and writes. */
 781 static unsigned char *tables_copy;
 782 const char *errorptr;
 783 int erroroffset;
 784 unsigned char *default_tables;
 785 #if defined SUPPORT_PCRE8
 786 pcre *regex;
 787 char null_str[1] = { 0 };
 788 #elif defined SUPPORT_PCRE16
 789 pcre16 *regex;
 790 PCRE_UCHAR16 null_str[1] = { 0 };
 791 #elif defined SUPPORT_PCRE32
 792 pcre32 *regex;
 793 PCRE_UCHAR32 null_str[1] = { 0 };
 796 if (mode) {
 797 if (tables_copy)
 798 free(tables_copy);
 799 tables_copy = NULL;
 800 return NULL;
 803 if (tables_copy)
 804 return tables_copy;
 806 default_tables = NULL;
 807 #if defined SUPPORT_PCRE8
 808 regex = pcre_compile(null_str, 0, &errorptr, &erroroffset, NULL);
 809 if (regex) {
 810 pcre_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
 811 pcre_free(regex);
 813 #elif defined SUPPORT_PCRE16
 814 regex = pcre16_compile(null_str, 0, &errorptr, &erroroffset, NULL);
 815 if (regex) {
 816 pcre16_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
 817 pcre16_free(regex);
 819 #elif defined SUPPORT_PCRE32
 820 regex = pcre32_compile(null_str, 0, &errorptr, &erroroffset, NULL);
 821 if (regex) {
 822 pcre32_fullinfo(regex, NULL, PCRE_INFO_DEFAULT_TABLES, &default_tables);
 823 pcre32_free(regex);
 826 /* Shouldn't ever happen. */
 827 if (!default_tables)
 828 return NULL;
 830 /* Unfortunately this value cannot get from pcre_fullinfo.
 831 Since this is a test program, this is acceptable at the moment. */
 832 tables_copy = (unsigned char *)malloc(1088);
 833 if (!tables_copy)
 836 memcpy(tables_copy, default_tables, 1088);
 837 return tables_copy;
 840 #ifdef SUPPORT_PCRE8
 841 static pcre_jit_stack* callback8(void *arg)
 843 return (pcre_jit_stack *)arg;
 845 #endif
 847 #ifdef SUPPORT_PCRE16
 848 static pcre16_jit_stack* callback16(void *arg)
 850 return (pcre16_jit_stack *)arg;
 854 #ifdef SUPPORT_PCRE32
 855 static pcre32_jit_stack* callback32(void *arg)
 857 return (pcre32_jit_stack *)arg;
 861 #ifdef SUPPORT_PCRE8
 862 static pcre_jit_stack *stack8;
 864 static pcre_jit_stack *getstack8(void)
 866 if (!stack8)
 867 stack8 = pcre_jit_stack_alloc(1, 1024 * 1024);
 868 return stack8;
 871 static void setstack8(pcre_extra *extra)
 873 if (!extra) {
 874 if (stack8)
 875 pcre_jit_stack_free(stack8);
 876 stack8 = NULL;
 880 pcre_assign_jit_stack(extra, callback8, getstack8());
 882 #endif /* SUPPORT_PCRE8 */
 884 #ifdef SUPPORT_PCRE16
 885 static pcre16_jit_stack *stack16;
 887 static pcre16_jit_stack *getstack16(void)
 889 if (!stack16)
 890 stack16 = pcre16_jit_stack_alloc(1, 1024 * 1024);
 891 return stack16;
 894 static void setstack16(pcre16_extra *extra)
 896 if (!extra) {
 897 if (stack16)
 898 pcre16_jit_stack_free(stack16);
 899 stack16 = NULL;
 903 pcre16_assign_jit_stack(extra, callback16, getstack16());
 905 #endif /* SUPPORT_PCRE8 */
 907 #ifdef SUPPORT_PCRE32
 908 static pcre32_jit_stack *stack32;
 910 static pcre32_jit_stack *getstack32(void)
 912 if (!stack32)
 913 stack32 = pcre32_jit_stack_alloc(1, 1024 * 1024);
 914 return stack32;
 917 static void setstack32(pcre32_extra *extra)
 919 if (!extra) {
 920 if (stack32)
 921 pcre32_jit_stack_free(stack32);
 922 stack32 = NULL;
 926 pcre32_assign_jit_stack(extra, callback32, getstack32());
 928 #endif /* SUPPORT_PCRE8 */
 930 #ifdef SUPPORT_PCRE16
 932 static int convert_utf8_to_utf16(const char *input, PCRE_UCHAR16 *output, int *offsetmap, int max_length)
 934 unsigned char *iptr = (unsigned char*)input;
 935 PCRE_UCHAR16 *optr = output;
 936 unsigned int c;
 938 if (max_length == 0)
 941 while (*iptr && max_length > 1) {
 942 c = 0;
 944 *offsetmap++ = (int)(iptr - (unsigned char*)input);
 946 if (!(*iptr & 0x80))
 947 c = *iptr++;
 948 else if (!(*iptr & 0x20)) {
 949 c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
 950 iptr += 2;
 951 } else if (!(*iptr & 0x10)) {
 952 c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
 953 iptr += 3;
 954 } else if (!(*iptr & 0x08)) {
 955 c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
 956 iptr += 4;
 959 if (c < 65536) {
 960 *optr++ = c;
 961 max_length--;
 962 } else if (max_length <= 2) {
 963 *optr = '\0';
 964 return (int)(optr - output);
 966 c -= 0x10000;
 967 *optr++ = 0xd800 | ((c >> 10) & 0x3ff);
 968 *optr++ = 0xdc00 | (c & 0x3ff);
 969 max_length -= 2;
 970 if (offsetmap)
 971 offsetmap++;
 974 if (offsetmap)
 975 *offsetmap = (int)(iptr - (unsigned char*)input);
 976 *optr = '\0';
 977 return (int)(optr - output);
 980 static int copy_char8_to_char16(const char *input, PCRE_UCHAR16 *output, int max_length)
 982 unsigned char *iptr = (unsigned char*)input;
 983 PCRE_UCHAR16 *optr = output;
 989 *optr++ = *iptr++;
 990 max_length--;
 992 *optr = '\0';
 993 return (int)(optr - output);
 996 #define REGTEST_MAX_LENGTH16 4096
 997 static PCRE_UCHAR16 regtest_buf16[REGTEST_MAX_LENGTH16];
 998 static int regtest_offsetmap16[REGTEST_MAX_LENGTH16];
 1000 #endif /* SUPPORT_PCRE16 */
 1002 #ifdef SUPPORT_PCRE32
 1004 static int convert_utf8_to_utf32(const char *input, PCRE_UCHAR32 *output, int *offsetmap, int max_length)
 1006 unsigned char *iptr = (unsigned char*)input;
 1007 PCRE_UCHAR32 *optr = output;
 1008 unsigned int c;
 1010 if (max_length == 0)
 1013 while (*iptr && max_length > 1) {
 1014 c = 0;
 1015 if (offsetmap)
 1016 *offsetmap++ = (int)(iptr - (unsigned char*)input);
 1018 if (!(*iptr & 0x80))
 1019 c = *iptr++;
 1020 else if (!(*iptr & 0x20)) {
 1021 c = ((iptr[0] & 0x1f) << 6) | (iptr[1] & 0x3f);
 1022 iptr += 2;
 1023 } else if (!(*iptr & 0x10)) {
 1024 c = ((iptr[0] & 0x0f) << 12) | ((iptr[1] & 0x3f) << 6) | (iptr[2] & 0x3f);
 1025 iptr += 3;
 1026 } else if (!(*iptr & 0x08)) {
 1027 c = ((iptr[0] & 0x07) << 18) | ((iptr[1] & 0x3f) << 12) | ((iptr[2] & 0x3f) << 6) | (iptr[3] & 0x3f);
 1028 iptr += 4;
 1031 *optr++ = c;
 1032 max_length--;
 1034 if (offsetmap)
 1035 *offsetmap = (int)(iptr - (unsigned char*)input);
 1036 *optr = 0;
 1037 return (int)(optr - output);
 1040 static int copy_char8_to_char32(const char *input, PCRE_UCHAR32 *output, int max_length)
 1042 unsigned char *iptr = (unsigned char*)input;
 1043 PCRE_UCHAR32 *optr = output;
 1045 if (max_length == 0)
 1046 return 0;
 1048 while (*iptr && max_length > 1) {
 1049 *optr++ = *iptr++;
 1050 max_length--;
 1052 *optr = '\0';
 1053 return (int)(optr - output);
 1056 #define REGTEST_MAX_LENGTH32 4096
 1057 static PCRE_UCHAR32 regtest_buf32[REGTEST_MAX_LENGTH32];
 1058 static int regtest_offsetmap32[REGTEST_MAX_LENGTH32];
 1060 #endif /* SUPPORT_PCRE32 */
 1062 static int check_ascii(const char *input)
 1064 const unsigned char *ptr = (unsigned char *)input;
 1065 while (*ptr) {
 1066 if (*ptr > 127)
 1067 return 0;
 1068 ptr++;
 1070 return 1;
 1073 static int regression_tests(void) static int regression_tests(void)
 1075 struct regression_test_case *current = regression_test_cases; struct regression_test_case *current = regression_test_cases;
 1076 const char *error; const char *error;
 1077 pcre_extra *extra; char *cpu_info;
 1078 int i, err_offs; int i, err_offs;
 1079 int total = 0, succesful = 0; int is_successful, is_ascii_pattern, is_ascii_input;
 1080 int total = 0;
 1081 int successful = 0;
 1082 int successful_row = 0;
 1083 int counter = 0; int counter = 0;
 1084 int disabled_flags = PCRE_BUG; int study_mode;
 1085 int utf = 0, ucp = 0;
 1086 int disabled_flags = 0;
 1087 #ifdef SUPPORT_PCRE8
 1088 pcre *re8;
 1089 pcre_extra *extra8;
 1090 pcre_extra dummy_extra8;
 1091 int ovector8_1[32];
 1092 int ovector8_2[32];
 1093 int return_value8[2];
 1094 unsigned char *mark8_1, *mark8_2;
 1096 #ifdef SUPPORT_PCRE16
 1097 pcre16 *re16;
 1098 pcre16_extra *extra16;
 1099 pcre16_extra dummy_extra16;
 1100 int ovector16_1[32];
 1101 int ovector16_2[32];
 1102 int return_value16[2];
 1103 PCRE_UCHAR16 *mark16_1, *mark16_2;
 1104 int length16;
 1106 #ifdef SUPPORT_PCRE32
 1107 pcre32 *re32;
 1108 pcre32_extra *extra32;
 1109 pcre32_extra dummy_extra32;
 1110 int ovector32_1[32];
 1111 int ovector32_2[32];
 1112 int return_value32[2];
 1113 PCRE_UCHAR32 *mark32_1, *mark32_2;
 1114 int length32;
 1117 /* This test compares the behaviour of interpreter and JIT. Although disabling /* This test compares the behaviour of interpreter and JIT. Although disabling
 1118 utf8 or ucp may make tests fail, if the pcre_exec result is the SAME, it is utf or ucp may make tests fail, if the pcre_exec result is the SAME, it is
 1119 still considered successful from pcre_jit_test point of view. */ still considered successful from pcre_jit_test point of view. */
 1121 pcre_config(PCRE_CONFIG_UTF8, &utf8); #if defined SUPPORT_PCRE8
 1122 pcre_config(PCRE_CONFIG_JITTARGET, &cpu_info);
 1123 #elif defined SUPPORT_PCRE16
 1124 pcre16_config(PCRE_CONFIG_JITTARGET, &cpu_info);
 1125 #elif defined SUPPORT_PCRE32
 1126 pcre32_config(PCRE_CONFIG_JITTARGET, &cpu_info);
 1129 printf("Running JIT regression tests\n");
 1130 printf(" target CPU of SLJIT compiler: %s\n", cpu_info);
 1132 #if defined SUPPORT_PCRE8
 1133 pcre_config(PCRE_CONFIG_UTF8, &utf);
 1134 pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp); pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
 1135 if (!utf8) #elif defined SUPPORT_PCRE16
 1136 disabled_flags |= PCRE_UTF8; pcre16_config(PCRE_CONFIG_UTF16, &utf);
 1137 pcre16_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
 1138 #elif defined SUPPORT_PCRE16
 1139 pcre32_config(PCRE_CONFIG_UTF32, &utf);
 1140 pcre32_config(PCRE_CONFIG_UNICODE_PROPERTIES, &ucp);
 1143 if (!utf)
 1144 disabled_flags |= PCRE_UTF8 | PCRE_UTF16 | PCRE_UTF32;
 1145 if (!ucp) if (!ucp)
 1146 disabled_flags |= PCRE_UCP; disabled_flags |= PCRE_UCP;
 1147 #ifdef SUPPORT_PCRE8
 1148 printf(" in 8 bit mode with UTF-8 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
 1150 #ifdef SUPPORT_PCRE16
 1151 printf(" in 16 bit mode with UTF-16 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
 1154 printf(" in 32 bit mode with UTF-32 %s and ucp %s:\n", utf ? "enabled" : "disabled", ucp ? "enabled" : "disabled");
 1157 while (current->pattern) { while (current->pattern) {
 1158 /* printf("\nPattern: %s :\n", current->pattern); */ /* printf("\nPattern: %s :\n", current->pattern); */
 1159 total++; total++;
 1160 if (current->start_offset & F_PROPERTY) {
 1161 is_ascii_pattern = 0;
 1162 is_ascii_input = 0;
 1164 is_ascii_pattern = check_ascii(current->pattern);
 1165 is_ascii_input = check_ascii(current->input);
 1168 if (current->flags & PCRE_PARTIAL_SOFT)
 1169 study_mode = PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE;
 1170 else if (current->flags & PCRE_PARTIAL_HARD)
 1171 study_mode = PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE;
 1173 study_mode = PCRE_STUDY_JIT_COMPILE;
 1174 error = NULL; error = NULL;
 1175 re = pcre_compile(current->pattern, current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | disabled_flags), &error, &err_offs, NULL); #ifdef SUPPORT_PCRE8
 1176 re8 = NULL;
 1177 if (!re) { if (!(current->start_offset & F_NO8))
 1178 if (utf8 && ucp) re8 = pcre_compile(current->pattern,
 1179 printf("\nCannot compile pattern: %s\n", current->pattern); current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
 1180 else { &error, &err_offs, tables(0));
 1181 /* Some patterns cannot be compiled when either of utf8
 1182 or ucp is disabled. We just skip them. */ extra8 = NULL;
 1183 printf("."); if (re8) {
 1184 succesful++; error = NULL;
 1185 extra8 = pcre_study(re8, study_mode, &error);
 1186 if (!extra8) {
 1187 printf("\n8 bit: Cannot study pattern: %s\n", current->pattern);
 1188 pcre_free(re8);
 1189 re8 = NULL;
 1191 current++; else if (!(extra8->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
 1192 continue; printf("\n8 bit: JIT compiler does not support: %s\n", current->pattern);
 1193 } pcre_free_study(extra8);
 1194 pcre_free(re8);
 1195 re8 = NULL;
 1197 extra8->flags |= PCRE_EXTRA_MARK;
 1198 } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO8))
 1199 printf("\n8 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
 1201 #ifdef SUPPORT_PCRE16
 1202 if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
 1203 convert_utf8_to_utf16(current->pattern, regtest_buf16, NULL, REGTEST_MAX_LENGTH16);
 1205 copy_char8_to_char16(current->pattern, regtest_buf16, REGTEST_MAX_LENGTH16);
 1207 re16 = NULL;
 1208 if (!(current->start_offset & F_NO16))
 1209 re16 = pcre16_compile(regtest_buf16,
 1210 current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
 1211 &error, &err_offs, tables(0));
 1213 extra16 = NULL;
 1214 if (re16) {
 1215 error = NULL;
 1216 extra16 = pcre16_study(re16, study_mode, &error);
 1217 if (!extra16) {
 1218 printf("\n16 bit: Cannot study pattern: %s\n", current->pattern);
 1219 pcre16_free(re16);
 1220 re16 = NULL;
 1222 else if (!(extra16->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
 1223 printf("\n16 bit: JIT compiler does not support: %s\n", current->pattern);
 1224 pcre16_free_study(extra16);
 1225 pcre16_free(re16);
 1226 re16 = NULL;
 1228 extra16->flags |= PCRE_EXTRA_MARK;
 1229 } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO16))
 1230 printf("\n16 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
 1232 #ifdef SUPPORT_PCRE32
 1233 if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
 1234 convert_utf8_to_utf32(current->pattern, regtest_buf32, NULL, REGTEST_MAX_LENGTH32);
 1236 copy_char8_to_char32(current->pattern, regtest_buf32, REGTEST_MAX_LENGTH32);
 1238 re32 = NULL;
 1239 if (!(current->start_offset & F_NO32))
 1240 re32 = pcre32_compile(regtest_buf32,
 1241 current->flags & ~(PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD | disabled_flags),
 1242 &error, &err_offs, tables(0));
 1244 extra32 = NULL;
 1245 if (re32) {
 1246 error = NULL;
 1247 extra32 = pcre32_study(re32, study_mode, &error);
 1248 if (!extra32) {
 1249 printf("\n32 bit: Cannot study pattern: %s\n", current->pattern);
 1250 pcre32_free(re32);
 1251 re32 = NULL;
 1253 if (!(extra32->flags & PCRE_EXTRA_EXECUTABLE_JIT)) {
 1254 printf("\n32 bit: JIT compiler does not support: %s\n", current->pattern);
 1255 pcre32_free_study(extra32);
 1256 pcre32_free(re32);
 1257 re32 = NULL;
 1259 extra32->flags |= PCRE_EXTRA_MARK;
 1260 } else if (((utf && ucp) || is_ascii_pattern) && !(current->start_offset & F_NO32))
 1261 printf("\n32 bit: Cannot compile pattern \"%s\": %s\n", current->pattern, error);
 1264 error = NULL; counter++;
 1265 extra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &error); if ((counter & 0x3) != 0) {
 1266 if (!extra) { #ifdef SUPPORT_PCRE8
 1267 printf("\nCannot study pattern: %s\n", current->pattern); setstack8(NULL);
 1268 current++; #endif
 1269 continue; #ifdef SUPPORT_PCRE16
 1270 setstack16(NULL);
 1272 #ifdef SUPPORT_PCRE32
 1273 setstack32(NULL);
 1277 if (!(extra->flags & PCRE_EXTRA_EXECUTABLE_JIT)) { #ifdef SUPPORT_PCRE8
 1278 printf("\nJIT compiler does not support: %s\n", current->pattern); return_value8[0] = -1000;
 1279 current++; return_value8[1] = -1000;
 1280 continue; for (i = 0; i < 32; ++i)
 1281 ovector8_1[i] = -2;
 1282 for (i = 0; i < 32; ++i)
 1283 ovector8_2[i] = -2;
 1284 if (re8) {
 1285 mark8_1 = NULL;
 1286 mark8_2 = NULL;
 1287 extra8->mark = &mark8_1;
 1289 if ((counter & 0x1) != 0) {
 1290 setstack8(extra8);
 1291 return_value8[0] = pcre_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
 1292 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32);
 1294 return_value8[0] = pcre_jit_exec(re8, extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
 1295 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_1, 32, getstack8());
 1296 memset(&dummy_extra8, 0, sizeof(pcre_extra));
 1297 dummy_extra8.flags = PCRE_EXTRA_MARK;
 1298 if (current->start_offset & F_STUDY) {
 1299 dummy_extra8.flags |= PCRE_EXTRA_STUDY_DATA;
 1300 dummy_extra8.study_data = extra8->study_data;
 1302 dummy_extra8.mark = &mark8_2;
 1303 return_value8[1] = pcre_exec(re8, &dummy_extra8, current->input, strlen(current->input), current->start_offset & OFFSET_MASK,
 1304 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector8_2, 32);
 1308 counter++; #ifdef SUPPORT_PCRE16
 1309 if ((counter & 0x3) != 0) return_value16[0] = -1000;
 1310 setstack(extra); return_value16[1] = -1000;
 1311 for (i = 0; i < 32; ++i)
 1312 ovector16_1[i] = -2;
 1313 for (i = 0; i < 32; ++i) for (i = 0; i < 32; ++i)
 1314 ovector1[i] = -2; ovector16_2[i] = -2;
 1315 return_value1 = pcre_exec(re, extra, current->input, strlen(current->input), current->start_offset, current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector1, 32); if (re16) {
 1316 mark16_1 = NULL;
 1317 mark16_2 = NULL;
 1318 if ((current->flags & PCRE_UTF16) || (current->start_offset & F_FORCECONV))
 1319 length16 = convert_utf8_to_utf16(current->input, regtest_buf16, regtest_offsetmap16, REGTEST_MAX_LENGTH16);
 1321 length16 = copy_char8_to_char16(current->input, regtest_buf16, REGTEST_MAX_LENGTH16);
 1322 extra16->mark = &mark16_1;
 1323 if ((counter & 0x1) != 0) {
 1324 setstack16(extra16);
 1325 return_value16[0] = pcre16_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
 1326 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32);
 1328 return_value16[0] = pcre16_jit_exec(re16, extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
 1329 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_1, 32, getstack16());
 1330 memset(&dummy_extra16, 0, sizeof(pcre16_extra));
 1331 dummy_extra16.flags = PCRE_EXTRA_MARK;
 1332 if (current->start_offset & F_STUDY) {
 1333 dummy_extra16.flags |= PCRE_EXTRA_STUDY_DATA;
 1334 dummy_extra16.study_data = extra16->study_data;
 1336 dummy_extra16.mark = &mark16_2;
 1337 return_value16[1] = pcre16_exec(re16, &dummy_extra16, regtest_buf16, length16, current->start_offset & OFFSET_MASK,
 1338 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector16_2, 32);
 1342 #ifdef SUPPORT_PCRE32
 1343 return_value32[0] = -1000;
 1344 return_value32[1] = -1000;
 1345 for (i = 0; i < 32; ++i)
 1346 ovector32_1[i] = -2;
 1347 for (i = 0; i < 32; ++i) for (i = 0; i < 32; ++i)
 1348 ovector2[i] = -2; ovector32_2[i] = -2;
 1349 return_value2 = pcre_exec(re, NULL, current->input, strlen(current->input), current->start_offset, current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART), ovector2, 32); if (re32) {
 1350 mark32_1 = NULL;
 1351 mark32_2 = NULL;
 1352 if ((current->flags & PCRE_UTF32) || (current->start_offset & F_FORCECONV))
 1353 length32 = convert_utf8_to_utf32(current->input, regtest_buf32, regtest_offsetmap32, REGTEST_MAX_LENGTH32);
 1355 length32 = copy_char8_to_char32(current->input, regtest_buf32, REGTEST_MAX_LENGTH32);
 1356 extra32->mark = &mark32_1;
 1357 if ((counter & 0x1) != 0) {
 1358 setstack32(extra32);
 1359 return_value32[0] = pcre32_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
 1360 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32);
 1361 } else
 1362 return_value32[0] = pcre32_jit_exec(re32, extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
 1363 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_1, 32, getstack32());
 1364 memset(&dummy_extra32, 0, sizeof(pcre32_extra));
 1365 dummy_extra32.flags = PCRE_EXTRA_MARK;
 1366 if (current->start_offset & F_STUDY) {
 1367 dummy_extra32.flags |= PCRE_EXTRA_STUDY_DATA;
 1368 dummy_extra32.study_data = extra32->study_data;
 1370 dummy_extra32.mark = &mark32_2;
 1371 return_value32[1] = pcre32_exec(re32, &dummy_extra32, regtest_buf32, length32, current->start_offset & OFFSET_MASK,
 1372 current->flags & (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY | PCRE_NOTEMPTY_ATSTART | PCRE_PARTIAL_SOFT | PCRE_PARTIAL_HARD), ovector32_2, 32);
 1376 /* printf("[%d-%d-%d|%d-%d|%d-%d|%d-%d]%s",
 1377 return_value8[0], return_value16[0],
 1378 ovector8_1[0], ovector8_1[1],
 1379 ovector16_1[0], ovector16_1[1],
 1380 ovector32_1[0], ovector32_1[1],
 1381 (current->flags & PCRE_CASELESS) ? "C" : ""); */
 1383 /* If PCRE_BUG is set, just run the test, but do not compare the results. /* If F_DIFF is set, just run the test, but do not compare the results.
 1384 Segfaults can still be captured. */ Segfaults can still be captured. */
 1386 if (return_value1 >= 0) { is_successful = 1;
 1387 return_value1 *= 2; if (!(current->start_offset & F_DIFF)) {
 1388 err_offs = 0; #if defined SUPPORT_UTF && ((defined(SUPPORT_PCRE8) + defined(SUPPORT_PCRE16) + defined(SUPPORT_PCRE32)) >= 2)
 1389 for (i = 0; i < return_value1; ++i) if (!(current->start_offset & F_FORCECONV)) {
 1390 if (ovector1[i] != ovector2[i]) { int return_value;
 1391 printf("\nOvector[%d] value differs(%d:%d): '%s' @ '%s' \n", i, ovector1[i], ovector2[i], current->pattern, current->input);
 1392 err_offs = 1; /* All results must be the same. */
 1393 #ifdef SUPPORT_PCRE8
 1394 if ((return_value = return_value8[0]) != return_value8[1]) {
 1395 printf("\n8 bit: Return value differs(J8:%d,I8:%d): [%d] '%s' @ '%s'\n",
 1396 return_value8[0], return_value8[1], total, current->pattern, current->input);
 1397 is_successful = 0;
 1400 #ifdef SUPPORT_PCRE16
 1401 if ((return_value = return_value16[0]) != return_value16[1]) {
 1402 printf("\n16 bit: Return value differs(J16:%d,I16:%d): [%d] '%s' @ '%s'\n",
 1403 return_value16[0], return_value16[1], total, current->pattern, current->input);
 1404 is_successful = 0;
 1405 } else
 1407 #ifdef SUPPORT_PCRE32
 1408 if ((return_value = return_value32[0]) != return_value32[1]) {
 1409 printf("\n32 bit: Return value differs(J32:%d,I32:%d): [%d] '%s' @ '%s'\n",
 1410 return_value32[0], return_value32[1], total, current->pattern, current->input);
 1411 is_successful = 0;
 1412 } else
 1414 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
 1415 if (return_value8[0] != return_value16[0]) {
 1416 printf("\n8 and 16 bit: Return value differs(J8:%d,J16:%d): [%d] '%s' @ '%s'\n",
 1417 return_value8[0], return_value16[0],
 1418 total, current->pattern, current->input);
 1419 is_successful = 0;
 1422 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
 1423 if (return_value8[0] != return_value32[0]) {
 1424 printf("\n8 and 32 bit: Return value differs(J8:%d,J32:%d): [%d] '%s' @ '%s'\n",
 1425 return_value8[0], return_value32[0],
 1426 total, current->pattern, current->input);
 1427 is_successful = 0;
 1428 } else
 1430 #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE32
 1431 if (return_value16[0] != return_value32[0]) {
 1432 printf("\n16 and 32 bit: Return value differs(J16:%d,J32:%d): [%d] '%s' @ '%s'\n",
 1433 return_value16[0], return_value32[0],
 1434 total, current->pattern, current->input);
 1435 is_successful = 0;
 1436 } else
 1438 if (return_value >= 0 || return_value == PCRE_ERROR_PARTIAL) {
 1439 if (return_value == PCRE_ERROR_PARTIAL) {
 1440 return_value = 2;
 1442 return_value *= 2;
 1444 #ifdef SUPPORT_PCRE8
 1445 return_value8[0] = return_value;
 1447 #ifdef SUPPORT_PCRE16
 1448 return_value16[0] = return_value;
 1451 return_value32[0] = return_value;
 1453 /* Transform back the results. */
 1454 if (current->flags & PCRE_UTF8) {
 1455 #ifdef SUPPORT_PCRE16
 1456 for (i = 0; i < return_value; ++i) {
 1457 if (ovector16_1[i] >= 0)
 1458 ovector16_1[i] = regtest_offsetmap16[ovector16_1[i]];
 1459 if (ovector16_2[i] >= 0)
 1460 ovector16_2[i] = regtest_offsetmap16[ovector16_2[i]];
 1463 #ifdef SUPPORT_PCRE32
 1464 for (i = 0; i < return_value; ++i) {
 1465 if (ovector32_1[i] >= 0)
 1466 ovector32_1[i] = regtest_offsetmap32[ovector32_1[i]];
 1467 if (ovector32_2[i] >= 0)
 1468 ovector32_2[i] = regtest_offsetmap32[ovector32_2[i]];
 1473 for (i = 0; i < return_value; ++i) {
 1474 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE16
 1475 if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector16_1[i] || ovector8_1[i] != ovector16_2[i]) {
 1476 printf("\n8 and 16 bit: Ovector[%d] value differs(J8:%d,I8:%d,J16:%d,I16:%d): [%d] '%s' @ '%s' \n",
 1477 i, ovector8_1[i], ovector8_2[i], ovector16_1[i], ovector16_2[i],
 1478 total, current->pattern, current->input);
 1479 is_successful = 0;
 1482 #if defined SUPPORT_PCRE8 && defined SUPPORT_PCRE32
 1483 if (ovector8_1[i] != ovector8_2[i] || ovector8_1[i] != ovector32_1[i] || ovector8_1[i] != ovector32_2[i]) {
 1484 printf("\n8 and 32 bit: Ovector[%d] value differs(J8:%d,I8:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
 1485 i, ovector8_1[i], ovector8_2[i], ovector32_1[i], ovector32_2[i],
 1486 total, current->pattern, current->input);
 1487 is_successful = 0;
 1490 #if defined SUPPORT_PCRE16 && defined SUPPORT_PCRE16
 1491 if (ovector16_1[i] != ovector16_2[i] || ovector16_1[i] != ovector16_1[i] || ovector16_1[i] != ovector16_2[i]) {
 1492 printf("\n16 and 16 bit: Ovector[%d] value differs(J16:%d,I16:%d,J32:%d,I32:%d): [%d] '%s' @ '%s' \n",
 1493 i, ovector16_1[i], ovector16_2[i], ovector16_1[i], ovector16_2[i],
 1494 total, current->pattern, current->input);
 1495 is_successful = 0;
 1500 } else
 1501 #endif /* more than one of SUPPORT_PCRE8, SUPPORT_PCRE16 and SUPPORT_PCRE32 */
 1503 /* Only the 8 bit and 16 bit results must be equal. */
 1504 #ifdef SUPPORT_PCRE8
 1505 if (return_value8[0] != return_value8[1]) {
 1506 printf("\n8 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
 1507 return_value8[0], return_value8[1], total, current->pattern, current->input);
 1508 is_successful = 0;
 1509 } else if (return_value8[0] >= 0 || return_value8[0] == PCRE_ERROR_PARTIAL) {
 1510 if (return_value8[0] == PCRE_ERROR_PARTIAL)
 1511 return_value8[0] = 2;
 1513 return_value8[0] *= 2;
 1515 for (i = 0; i < return_value8[0]; ++i)
 1516 if (ovector8_1[i] != ovector8_2[i]) {
 1517 printf("\n8 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
 1518 i, ovector8_1[i], ovector8_2[i], total, current->pattern, current->input);
 1519 is_successful = 0;
 1524 #ifdef SUPPORT_PCRE16
 1525 if (return_value16[0] != return_value16[1]) {
 1526 printf("\n16 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
 1527 return_value16[0], return_value16[1], total, current->pattern, current->input);
 1528 is_successful = 0;
 1529 } else if (return_value16[0] >= 0 || return_value16[0] == PCRE_ERROR_PARTIAL) {
 1530 if (return_value16[0] == PCRE_ERROR_PARTIAL)
 1531 return_value16[0] = 2;
 1533 return_value16[0] *= 2;
 1535 for (i = 0; i < return_value16[0]; ++i)
 1536 if (ovector16_1[i] != ovector16_2[i]) {
 1537 printf("\n16 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
 1538 i, ovector16_1[i], ovector16_2[i], total, current->pattern, current->input);
 1539 is_successful = 0;
 1544 #ifdef SUPPORT_PCRE32
 1545 if (return_value32[0] != return_value32[1]) {
 1546 printf("\n32 bit: Return value differs(%d:%d): [%d] '%s' @ '%s'\n",
 1547 return_value32[0], return_value32[1], total, current->pattern, current->input);
 1548 is_successful = 0;
 1549 } else if (return_value32[0] >= 0 || return_value32[0] == PCRE_ERROR_PARTIAL) {
 1550 if (return_value32[0] == PCRE_ERROR_PARTIAL)
 1551 return_value32[0] = 2;
 1553 return_value32[0] *= 2;
 1555 for (i = 0; i < return_value32[0]; ++i)
 1556 if (ovector32_1[i] != ovector32_2[i]) {
 1557 printf("\n32 bit: Ovector[%d] value differs(%d:%d): [%d] '%s' @ '%s'\n",
 1558 i, ovector32_1[i], ovector32_2[i], total, current->pattern, current->input);
 1559 is_successful = 0;
 1566 pcre_free_study(extra); if (is_successful) {
 1567 pcre_free(re); #ifdef SUPPORT_PCRE8
 1568 if (!(current->start_offset & F_NO8) && ((utf && ucp) || is_ascii_input)) {
 1569 if (return_value8[0] < 0 && !(current->start_offset & F_NOMATCH)) {
 1570 printf("8 bit: Test should match: [%d] '%s' @ '%s'\n",
 1571 total, current->pattern, current->input);
 1572 is_successful = 0;
 1575 if (return_value8[0] >= 0 && (current->start_offset & F_NOMATCH)) {
 1576 printf("8 bit: Test should not match: [%d] '%s' @ '%s'\n",
 1577 total, current->pattern, current->input);
 1578 is_successful = 0;
 1582 #ifdef SUPPORT_PCRE16
 1583 if (!(current->start_offset & F_NO16) && ((utf && ucp) || is_ascii_input)) {
 1584 if (return_value16[0] < 0 && !(current->start_offset & F_NOMATCH)) {
 1585 printf("16 bit: Test should match: [%d] '%s' @ '%s'\n",
 1586 total, current->pattern, current->input);
 1587 is_successful = 0;
 1590 if (return_value16[0] >= 0 && (current->start_offset & F_NOMATCH)) {
 1591 printf("16 bit: Test should not match: [%d] '%s' @ '%s'\n",
 1592 total, current->pattern, current->input);
 1593 is_successful = 0;
 1597 #ifdef SUPPORT_PCRE32
 1598 if (!(current->start_offset & F_NO32) && ((utf && ucp) || is_ascii_input)) {
 1599 if (return_value32[0] < 0 && !(current->start_offset & F_NOMATCH)) {
 1600 printf("32 bit: Test should match: [%d] '%s' @ '%s'\n",
 1601 total, current->pattern, current->input);
 1605 if (return_value32[0] >= 0 && (current->start_offset & F_NOMATCH)) {
 1606 printf("32 bit: Test should not match: [%d] '%s' @ '%s'\n",
 1607 total, current->pattern, current->input);
 1608 is_successful = 0;
 1614 if (is_successful) {
 1615 #ifdef SUPPORT_PCRE8
 1616 if (mark8_1 != mark8_2) {
 1617 printf("8 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
 1618 total, current->pattern, current->input);
 1619 is_successful = 0;
 1622 #ifdef SUPPORT_PCRE16
 1623 if (mark16_1 != mark16_2) {
 1624 printf("16 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
 1625 total, current->pattern, current->input);
 1626 is_successful = 0;
 1629 #ifdef SUPPORT_PCRE32
 1630 if (mark32_1 != mark32_2) {
 1631 printf("32 bit: Mark value mismatch: [%d] '%s' @ '%s'\n",
 1632 total, current->pattern, current->input);
 1633 is_successful = 0;
 1638 #ifdef SUPPORT_PCRE8
 1639 if (re8) {
 1640 pcre_free_study(extra8);
 1641 pcre_free(re8);
 1644 #ifdef SUPPORT_PCRE16
 1645 if (re16) {
 1646 pcre16_free_study(extra16);
 1647 pcre16_free(re16);
 1650 #ifdef SUPPORT_PCRE32
 1651 if (re32) {
 1652 pcre32_free_study(extra32);
 1653 pcre32_free(re32);
 1658 successful++;
 1659 successful_row++;
 1660 printf(".");
 1661 if (successful_row >= 60) {
 1662 successful_row = 0;
 1663 printf("\n");
 1665 } else
 1666 successful_row = 0;
 1668 fflush(stdout); fflush(stdout);
 1669 current++; current++;
 1671 tables(1);
 1672 #ifdef SUPPORT_PCRE8
 1673 setstack8(NULL);
 1675 #ifdef SUPPORT_PCRE16
 1676 setstack16(NULL);
 1678 #ifdef SUPPORT_PCRE32
 1679 setstack32(NULL);
 1682 if (total == succesful) { if (total == successful) {
 1683 printf("\nAll JIT regression tests are successfully passed.\n"); printf("\nAll JIT regression tests are successfully passed.\n");
 1684 return 0; return 0;
 1685 } else { } else {
 1686 printf("\nSuccessful test ratio: %d%%\n", succesful * 100 / total); printf("\nSuccessful test ratio: %d%% (%d failed)\n", successful * 100 / total, total - successful);
 1687 return 1; return 1;
 Added in v.1308


text:
vloženo 03.09.2009 13:20:21
 Dobrý de, chtěla jsem Vás poprosit o radu ve věci odstoupení od darovací smlouvy. Mému manželovi zemřel dědeček, který vlastnil 1/2 nemovitosti. Jedná se o dům a zahradu. Druhou polovinu nemovitosti vlastnila babička, která je na živu. Vše se převádělo na manželova tatínka ( jak 1/2 dědictvím po dědeškovi, tak 1/2 darovací smlouvou od babičky), takže se stal tchán výlučným vlastníkem nemovitosti. Prošlo to již katastrálním úřadem, zapsáno to bylo asi před 14 dny. Tchán chce celou nemovitost darovat mému namželovi, jenže máme problém skrz daně. Z darovaného podílu od babičky by musel tchám teď platit daň z příjmu pokud by to na manžela převedl do dvou let od nabytí nemovitosti nebo do 5 let nabytí nemovitosti dle podmínek trv. byliště. Chci se zeptat, zda může babička od darovací smlouvy odstoupit ( se souhlasem všech zúčastněných) a darovat 1/2 nemovitosti mému manželovi (svému vnukovi) nebo to není možné? Děkuji Dana
 k Vašemu dotazu ze dne 3. září 2009 ve věci odstoupení od darovací smlouvy sdělujeme:
 Problematiku darovací smlouvy upravuje občanský zákoník v § 628 a násl. (zákon č. 40/1964 Sb., ve znění pozdějších předpisů). Úprava se týká pravidel darování; není řešena „možnost odstoupení od darovací smlouvy“. Občanský zákoník upravuje pouze možnost domáhání se vrácení daru. Podle § 630 dárce se může domáhat vrácení daru, jestliže se obdarovaný chová k němu nebo k členům jeho rodiny tak, že tím hrubě porušuje dobré mravy.
 vloženo 21.09.2009 12:18:56
 Dobrý den,prosila bych o radu při koupi staré nemovitosti,kterou chceme s přítelem koupit a vlastnit každý 1/2.Nyní ji chceme společně opravit,společně nést náklady na opravu a společně ji užívat.Nejsme manželé,žijeme spolu jako druh a družka.Každý máme ze svého původního manželství dvě děti.Jak lze ošetřit v kupní smlouvě,že v případě smrti jednoho z nás nechají dědici(tedy děti toho druhého) dožít v této nemovitosti a vypořádají si všichni 4 vše až po smrti nás obou? ( Po provedených úpravách zůstaneme bez prostředků a nebude možné dědice vyplatit). Děkuji za odpověď Hana
 k Vašemu dotazu ze dne 21. září 2009 v záležitosti možného dožití jednoho ze spoluvlastníků ve společně zakoupené nemovitosti v souvislosti s dědickým řízením sdělujeme:
 Nejvhodnějším řešením jak zajistit, aby jeden z Vás, pokud druhý zemře, mohl v nemovitosti, kterou jako podíloví spoluvlastníci zakoupíte a budete se v budoucnu podílet na její opravě a udržování, by bylo sepsat závěť. Tuto závěť musí sepsat každý z Vás samostatně, společná závěť by byla neplatná. Doporučujeme v této záležitosti využít služeb advokáta.
 vloženo 10.10.2009 17:57:02
 Poslanecká sněmovna přijala tak zvanou "chodníkovou novelu".Město rozhodlo,že bude cca 127,5 kilometrů chodníků rozděleno do čtyř skupin podle naléhavosti údržby. "Na chodnících v prvním pořadí důležitosti musí technické služby zahájit zmírnění závad ve schůdnosti do 12 hodin od spadu sněhu, ve druhé skupině do 36 hodin, ve třetí do 72 hodin a ve čtvrté – ručně - do 72 hodin. Dalších 159 kilometrů chodníků se v zimě udržovat nebude," .Je to správné rozhodnutí nebo se jedná o porušení zákonné normy? Pokud si vzpomínám, tak když za údržbu chodníků přilehlých k nemovitostem odpovídali jejich majitelé,byli ze strany magistrátu i pokutováni když nebyl chodník uklizen. Jan M.
 k Vašemu dotazu ze dne 12. října 2009, který se týká schůdnosti zasněžených a namrzlých chodníků, sdělujeme:
 Novelou zákona č. 13/1997 Sb., o pozemních komunikacích (novela zák. č. 97/2009 Sb.) byla sice stanovena obcím povinnost zajišťovat schůdnost chodníků, ale nikoliv absolutní. Podle § 27 odst. 5 cit.zák. obec (tj. též magistrát hl.m. Prahy) nezajišťuje schůdnost některých chodníků odstraňováním sněhu a náledí pro jejich malý dopravní význam. V těchto případech je povinností obce tyto úseky označit a svým nařízením je vymezit. Kromě uvedeného podle odst. 6 obec má stanovit nařízením rozsah, způsob a lhůty odstraňování závad a schůdnosti chodníků.
 Nařízení obce má podle zákona o obcích (zákon č. 128/2000 Sb. ve znění pozdějších předpisů), podle zákona o krajích (zákon č. 129/2000 Sb., ve znění pozdějších předpisů) a podle zákona o hl.m. Praze (zákon č. 131/2000 Sb., ve znění pozdějších předpisů) charakter obecně závazného právního předpisu.
 Jestliže magistrát hl.m. Prahy rozhoduje o tom, jak bude zajišťovat úklid sněhu a náledí na chodnících, tj. rozsah, způsob a lhůty odstraňování závad, je tato jeho působnost v mezích zákona o pozemních komunikacích i v mezích zákona o hl.m. Praze.
 vloženo 27.10.2009 11:20:46
 Dobrý den, prosím o radu ohledně převodu družstevního bytu do osobního vlastnictví.Bydlíme s manželem, který je plně invalidní v družstevním bytě a v letošním roce jsme požádali, tak jako naši sousedé o převod bytu do osobního vlastnictví. Družstvo nám ale odpovědělo, že máme doložit, že jsme o byt požádali podle zákona č. 74/1992 Sb. Žádnou písemnou nabídku od SBD jsme však nikdy neobrželi. Manžel tvrdí, že když jsme nepožádali v roce 1992 a později ani v promlčecí době pěti let o převod, tak že již na převod družstevního bytu do vlastnictví již nemáme nárok. Na členských schůzkách družstevníků nás ale předseda samosprávy opakovaně ujišťoval, že nemusíme o nic žádat, že převody bytů do vlastnictví nejsou možné do doby vyřešení vlastnictví stavebních parcel na kterých stojí náš dům. Děkuji za odpovědˇ. Anežka K.
 k Vašemu dotazu ze dne 27. října 2009, který se týká převodu družstevního bytu do osobního vlastnictví, sdělujeme:
 Předpokladem převedení družstevního bytu do osobního vlastnictví je vždy písemná výzva nájemce družstevního bytu adresovaná družstvu, nikoliv písemná nabídka SBD.
 Podle stávající právní úpravy (zák. č. 42/1992 Sb., o úpravě majetkových vztahů a vypořádání majetkových nároků v družstvech a zák. č. 72/1994 Sb., o vlastnictví bytů) byla dána nájemci družstevního bytu možnost požádat (písemná výzva) o převedení tohoto bytu do osobního vlastnictví v časově omezené lhůtě. V mnoha případech se tak ale nestalo.
 Novou právní úpravou, zákonem č. 345/2009 Sb., kterým se mění zákon o vlastnictví bytů, byla možnost vyzvat družstvo o převedení bytu do osobního vlastnictví časově prodloužena. Citovaný zákon je ze dne 9. září 2009 a nabývá účinnosti dnem 1. ledna 2010. Podle čl. II tohoto zákona nebyla-li uzavřena smlouva podle § 23 odst. 2 zákona č. 72/1994 Sb., do 1. července 2010, lze právo na uzavření smlouvy podle § 23 odst. 2 a 3 zákona č. 72/1994 Sb., uplatnit do 31. prosince 2020.
 Opakujeme, že podmínkou převedení družstevního bytu do osobního vlastnictví je vždy písemná výzva nájemce družstevního bytu adresovaná družstvu, nikoliv výzva družstva. Chráněno je zde právo nájemce bytu.
 Převod družstevního bytu do osobního vlastnictví není vázán na vypořádání majetkových vztahů k pozemku, na kterém dům stojí. Jedná se o samostatnou záležitost. Může se jednat o pozemek ve vlastnictví právnické nebo fyzické osoby, například též ve vlastnictví obce apod., pokud pozemek není ve vlastnictví SBD. Převod družstevního bytu do osobního vlastnictví může být bezplatný za předpokladu, že všechny závazky vůči družstvu jsou uhrazeny. Jinak tomu bude s pozemkem, může se např. jednak o bezplatný převod, pokud pozemek bude náležet státu, může se ale také jednat o úplatný převod pokud pozemek náleží např. obci nebo soukromé (právnické či fyzické) osobě.
 Přejeme Vám, aby se záležitost vyřešila k Vaší úplné spokojenosti.
 vloženo 31.12.2009 17:29:14
 Prateta mi darovala bezplatně družstevní práva k bytu. Podléhá tento převod zdanění?
 k Vašemu dotazu ze dne 4. ledna 2010, který se týká bezplatného darování družstevního práva k bytu, sdělujeme:
 Vlastnictví družstevního bytu náleží bytovému družstvu. Nájemcem družstevního bytu je člen družstva. Podle odst. 3) § 42 zákona č. 176/1990 Sb., o bytovém, spotřebním, výrobním a jiném družstevnictví člen může dohodou převést svá členská práva a povinnosti na příbuzné v řadě přímé, sourozence, manžela, bývalého manžela a na jiné osoby blízké, které s ním žijí ve společné domácnosti; převod členských práv a povinností na jiné osoby upravují stanovy příslušného družstva.
 Ve Vašem případě by zřejmě mělo jít o převod členských práv a povinností podle stanov družstva, nikoliv o bezplatné darování. Obraťte se proto na představenstvo bytového družstva.
 JUDr. Zdenka Biedermannová 8. ledna 2010


type: contracts

jurisdiction: EU

text:
 30.10.2014
 HR
 Službeni list Europske unije
 L 310/3
 ODLUKA ZAJEDNIČKOG ODBORA EGP-a
 br. 64/2014
 od 16. svibnja 2014.
 o izmjeni Priloga I. (Veterinarska i fitosanitarna pitanja) Sporazumu o EGP-u
 ZAJEDNIČKI ODBOR EGP-a,
 uzimajući u obzir Sporazum o Europskom gospodarskom prostoru („Sporazum o EGP-u”), a posebno njegov članak 98.,
 budući da:
 (1)
 Provedbenu odluku Komisije 2013/445/EU оd 29. kolovoza 2013. o izmjeni Priloga E Direktivi Vijeća 91/68/EEZ u pogledu obrazaca zdravstvenih certifikata za trgovinu ovcama i kozama unutar Unije te zdravstvenih zahtjeva povezanih s grebeži (1) treba uključiti u Sporazum o EGP-u.
 (2)
 Ova se Odluka odnosi na zakonodavstvo o živim životinjama koje nisu ribe ni životinje akvakulture. Zakonodavstvo u pogledu navedenih pitanja ne primjenjuje se na Island, kako je utvrđeno u stavku 2. uvodnog dijela poglavlja I. Priloga I. Sporazumu o EGP-u. Ova se Odluka stoga ne primjenjuje na Island.
 (3)
 Ova se Odluka odnosi na zakonodavstvo o veterinarskim pitanjima. Zakonodavstvo o veterinarskim pitanjima ne primjenjuje se na Lihtenštajn sve dok je primjena Sporazuma između Europske zajednice i Švicarske Konfederacije o trgovini poljoprivrednim proizvodima proširena na Lihtenštajn, kako je utvrđeno sektorskim prilagodbama Priloga I. Sporazumu o EGP-u. Ova se Odluka stoga ne primjenjuje na Lihtenštajn.
 (4)
 Prilog I. Sporazumu o EGP-u trebalo bi stoga na odgovarajući način izmijeniti,
 DONIO JE OVU ODLUKU:
 Članak 1.
 U točki 2. (Direktiva Vijeća 91/68/EEZ) u dijelu 4.1. poglavlja I. Priloga I. Sporazumu o EGP-u dodaje se sljedeća alineja:
 „—
 32013 D 0445: Provedbena odluka Komisije 2013/445/EU od 29. kolovoza 2013. (SL L 233, 31.8.2013., str. 48.).”
 Članak 2.
 Tekst Provedbene odluke 2013/445/EU na norveškom jeziku, koji se objavljuje u Dodatku o EGP-u Službenom listu Europske unije, vjerodostojan je.
 Članak 3.
 Ova Odluka stupa na snagu 17. svibnja 2014., pod uvjetom da su sve obavijesti iz članka 103. stavka 1. Sporazuma o EGP-u podnesene (2), ili na dan stupanja na snagu Odluke Zajedničkog odbora EGP-a o uključivanju Uredbe Komisije (EU) br. 630/2013 (3) u Sporazum o EGP-u, ovisno o tome koji je datum kasniji.
 Članak 4.
 Ova se Odluka objavljuje u odjeljku o EGP-u i u Dodatku o EGP-u Službenom listu Europske unije.
 Sastavljeno u Bruxellesu 16. svibnja 2014.
 Za Zajednički odbor EGP-a
 Predsjednik
 Gianluca GRIPPA
 (1) SL L 233, 31.8.2013., str. 48.
 (2) Ustavni zahtjevi nisu navedeni.
 (3) SL L 179, 29.6.2013., str. 60.


type: caselaw

text:
 12.5.2014
 HR
 Službeni list Europske unije
 C 142/56
 Rješenje Službeničkog suda (treće vijeće) od 27. veljače 2014. – Walton protiv Komisije
 (Predmet F-32/13) (1)
 ((Javna služba - Član privremenog osoblja - Otpremnina - Ostavka utvrđena presudom Prvostupanjskog suda Europskih zajednica - Utvrđenje datuma ostavke - Načelo pravomoćnosti - Odluke tijela za imenovanja koje postaju konačne u nedostatku podnošenja tužbe - Nepoštivanje prethodnog upravnog postupka - Očita nedopuštenost))
 2014/C 142/76
 Jezik postupka: francuski
 Stranke
 Tužitelj: Robert Walton (Oxford, Ujedinjena Kraljevina) (zastupnik: F. Moyse, avocat)
 Tuženik: Europska komisija (zastupnici: J. Currall i A.-C. Simon, agenti)
 Predmet
 Zahtjev za poništenje odbijanja zahtjeva tužitelja za dobivanje naknade neisplaćene plaće koju je Komisija trebala isplatiti s naslova otpremnine.
 Izreka rješenja
 1.
 Tužba se odbacuje kao očito nedopuštena.
 2.
 R. Walton snosi svoje troškove i nalaže mu se da snosi troškove Europske komisije.
 (1) SL C 207, 20.7.2013., str 58.


text:
8C_436/2007 16.06.2008
 8C_436/2007
 vertreten durch Fürsprecher Dr. Charles Wick, Kirchenfeldstrasse 68, 3005 Bern.
 M.________, geboren 1950, erlitt am 14. August 1995 einen Autounfall. Die Schweizerische Mobiliar Versicherungsgesellschaft (Mobiliar) erbrachte die Versicherungsleistungen. Am 23. Oktober 2000 sprach sie M.________ eine Invalidenrente basierend auf einem Invaliditätsgrad von 50 % sowie eine Integritätsentschädigung bei einem Integritätsschaden von 25 % zu. Diese Verfügung blieb unangefochten. Mit Verfügung vom 18. Juni 2004 und Einspracheentscheid vom 30. September 2004 kam die Mobiliar darauf zurück mit der Begründung, dass ihre Leistungspflicht per 31. März 2004 entfalle mangels adäquater Kausalität der geklagten Beschwerden mit dem Unfall; die ursprüngliche Verfügung vom 23. Oktober 2000 erweise sich diesbezüglich als zweifellos unrichtig.
 Die dagegen erhobene Beschwerde der Versicherten hiess das Verwaltungsgericht des Kantons Bern mit Entscheid vom 5. Juni 2007 gut und hob die wiedererwägungsweise Aufhebung der Rentenverfügung vom 23. Oktober 2000 im Einspracheentscheid vom 30. September 2004 auf. Soweit weitergehend wies es die Beschwerde ab.
 Die Mobiliar führt Beschwerde in öffentlich-rechtlichen Angelegenheiten mit dem Antrag, der angefochtene Entscheid sei in Bestätigung ihres Einspracheentscheidees vom 30. September 2004 aufzuheben; eventualiter sei der Entscheid aufzuheben und die Sache zur neuen Beurteilung an die Vorinstanz zurückzuweisen.
 Mit Eingaben vom 4. bzw. 10. April 2008 nehmen die Versicherte und der Unfallversicherer nochmals Stellung hinsichtlich der präzisierten Schleudertrauma-Praxis.
 Nach Art. 53 Abs. 2 ATSG kann der Versicherungsträger auf formell rechtskräftige Verfügungen oder Einspracheentscheide zurückkommen, wenn diese zweifellos unrichtig sind und ihre Berichtigung von erheblicher Bedeutung ist. Zweifellose Unrichtigkeit liegt vor, wenn kein vernünftiger Zweifel daran möglich ist, dass eine Unrichtigkeit vorliegt (Kieser, ATSG-Kommentar, N 20 zu Art. 53 mit Hinweis auf BGE 125 V 393).
 Das Bundesgericht hat sich zum Begriff der zweifellosen Unrichtigkeit jüngst im Urteil 5/07 vom 9. Januar 2008 geäussert, welches ebenfalls eine Rentenzusprechung bei Folgen eines Autounfalles mit Schleudertrauma betraf. Demnach genügt es für das Rückkommen auf eine formell rechtskräftige Verfügung über sozialversicherungsrechtliche Leistungsansprüche und insbesondere auf die Beurteilung des adäquaten Kausalzusammenhangs sowie der diesbezüglich massgeblichen Kriterien nicht, dass der Sozialversicherungsträger oder das Gericht einfach sein Ermessen an die Stelle desjenigen der ursprünglich verfügenden oder urteilenden Behörde setzt, sofern die damalige Ermessensausübung vertretbar war. Vielmehr muss die neue Ermessensausübung als die klarerweise einzig richtige erscheinen (Urteil U 5/07 vom 9. Januar 2008 E. 5.3.2.2).
 Der Unfallversicherer beruft sich zur Begründung seiner Beschwerde im Wesentlichen darauf, dass in der ursprünglichen Verfügung vom 23. Oktober 2000 die Klärung der Adäquanzfrage einer gesonderten Prüfung bedurft hätte, welche indessen, wenn sie tatsächlich erfolgt wäre, zur Verneinung der Adäquanz hätte führen müssen.
 Dieser Einwand ist nicht stichhaltig. Die Vorinstanz hat einlässlich und richtig dargelegt, dass die Voraussetzungen für die hier streitige Wiedererwägung nicht gegeben waren mangels zweifelloser Unrichtigkeit der damaligen Zusprechung von Rente und Integritätsentschädigung. Diese stützte sich auf die psychiatrische und neurologisch/neuropsychologische Begutachtung der Versicherten durch Dr. med. H.________ vom 4. Juni 1997 und Dr. med. R.________ vom 18. August 1997. Entscheidend ist dabei, dass sich der Gesundheitszustand der Versicherten gestützt auf dieses Gutachtens zuverlässig beurteilen liess und dass die Beschwerdeführerin mit Zusprechung von Rente und Integritätsentschädigung durch Verfügung vom 23. Oktober 2000 ("aufgrund von Art. 18 ff. UVG" und "aufgrund unserer Unterlagen") ihre Leistungspflicht anerkannte und damit implizit auch die Adäquanz der geklagten (psychischen) Beschwerden, welche dafür vorausgesetzt wird, als gegeben erachtet hat. Damit ist ein Zurückkommen auf die unangefochten gebliebene Verfügung vom 23. Oktober 2000 und insbesondere die Beurteilung der Adäquanz unter dem Titel der hier streitigen Wiedererwägung nicht zulässig (vgl. zur rechtskräftigen Verneinung der Adäquanz Urteile U 66/94 vom 4. November 1994, E. 3b, und U 210/00 vom 22. Oktober 2003, E. 3.4.2).
 Das Verfahren ist kostenpflichtig (Art. 65 BGG). Die Gerichtskosten werden dem Prozessausgang entsprechend der Beschwerdeführerin auferlegt (Art. 66 Abs. 1 Satz 1 BGG); des Weiteren hat sie der Beschwerdegegnerin eine Parteientschädigung zu bezahlen (Art. 68 Abs. 2 BGG).