Portál AbcLinuxu, 4. května 2025 19:43
Aktuální verze jádra: 2.6.23-rc6. Citáty týdne: Andrew Morton, Linus Torvalds. 2007 Kernel Summit. Exportované symboly a interní API. Kdo napsal a schválil 2.6.23.
Aktuální předverze je (12. 9. 2007) 2.6.23-rc6, vydaná 10. září. Tentokrát je počet oprav relativně malý; částečně proto, že bylo minulý týden mnoho vývojářů na kernel summitu. Podrobnosti v dlouhém changelogu.
Do hlavního git repozitáře i nadále proudí patche - skoro určitě se před finálním vydáním dočkáme ještě -rc7.
Minulý týden nevyšly žádné -mm verze.
Starší jádra: 2.6.20.19 bylo vydáno 8. září s jednou bezpečnostní opravou v kódu IPv6.
2.4.35.2 vyšlo také 8. září; obsahuje povětšinou opravy týkající se kompilátorů. 2.4.36-pre1 vyšlo pro změnu 8. září; obsahuje několik oprav a patch umožňující zakázat procesům mapovat adresu NULL.
Takže provádím obrácené reverzní polské půlící vyhledávání [inverted reverse polish bisection search], abych zjistil, který patch preemptivně opravuje clockevents-fix-resume-logic.patch. Zkuste to s gitem, cucáci.
C++ je děsný jazyk. A ještě horší ho dělá skutečnost, že ho používá spousta podprůměrných programátorů, takže je možné z něj vygenerovat totální a naprosté srágory. Upřímně, i kdyby C nesloužilo k *ničemu* jinému než k odrazování C++ programátorů, tak by to pořád stálo za to.
Linux Kernel Developers' Summit 2007 [setkání vývojářů linuxového jádra] se konal 5. a 6. září v Cambridge ve Velké Británii. Přibližně 80 vývojářů diskutovalo v rámci této konference jen pro zvané o mnoha různých tématech týkajících se všech aspektů vývoje jádra. Jako obvykle byl přítomen i Jonathan Corbet z LWN, který napsal své postřehy z jednotlivých setkání.
Jaký by to byl kernel summit bez skupinové fotky? Na obrázku je většina účastníků před kolejí Downing College, kde bylo mnoho vývojářů také ubytováno:
Fotku si můžete prohlédnout ve třech rozlišeních:
Na četné žádosti byla připravena i verze s popisky, která má připsaná jména k co největšímu počtu tváří.
Natahovatelné jaderné moduly nemají automaticky přístup ke všem symbolům (funkcím a proměnným) definovaným v jádře. Přístup je omezen pouze na ty symboly, které byly výslovně exportovány pro použití v modulech. Důvodem pro tohle povolování [whitelist] je snaha udržet rozhraní pro moduly pod kontrolou, aby se nehrabaly v částech jádra, kde nemají co pohledávat. V praxi to však moc dobře nefunguje: současná jádra mají ve zdrojových kódech rozeseto více než 16 000 deklarací EXPORT_SYMBOL().
Není tedy nic překvapivého, že by někteří vývojáři chtěli počet exportovaných modulů snížit. Často je symbol vyřazen, ukáže-li se, že jej nepoužívá žádný z modulů, které jsou součástí jádra. Neexistuje však všeobecná shoda ohledně toho, jak by se mělo k tomuto procesu přistupovat; kvůli tomu se občas objeví debata o tom, nakolik by vlastně mělo být API pro moduly stabilní, a jaké ohledy se mají brát na moduly, jež nejsou součástí jádra.
Adrian Bunk nedávno poslal patch, který ruší export sys_open() a sys_read(). Tyto symboly (které implementují systémová volání open() a read()) už jsou na seznamu pro odstřel dlouho. Když jsou používány z jaderného prostoru, tak je snadné se dopustit katastrofických chyb. A neexistují skoro žádné situace, v rámci kterých by bylo otevírání a čtení souborů z jádra považováno za správné. Ale odstranění těchto exportů bylo až doteď obtížné - pořád byl v jádře kód, kvůli kterému musely být zachovávány.
V jádře 2.6.23 tomu brání už jen poslední kus kódu - zvukový ovladač wavefront, který sys_open() a sys_read() používá k natažení firmwaru do zařízení. Jádro už má léta řádné API pro práci s firmwary, takže by se žádný ovladač neměl snažit ho načítat sám přímo ze souborů. Aktuální vývojový strom ALSA obsahuje pro wavefront patch, který zařídí, že bude používat firmwarové API; jakmile bude tento patch začleněn, nebude už zmiňované symboly potřebovat žádný jaderný kód. Adrian, který neustále sleduje, co by šlo z jádra odstranit, si toho všiml a hned poslal patch.
Andrew Morton odpověděl takto:
Já myslím, že je lepší lidi nejprve varovat, když máme v plánu provést něco, kvůli čemu by kód, který není v jádře, mohl přestat fungovat. Občas dostávám zprávy typu "hele, ovladač X, který mám od Y, přestal fungovat". A často se jedná o open source věci. Nevidím důvod, proč bychom měli uživatele štvát víc než je nutné.
Andrew by byl radši, kdyby byly symboly po jeden vývojový cyklus označeny jako EXPORT_UNUSED_SYMBOL(), aby si vývojáři kódu, který není v jádře, mohli všimnout varování a opravit svůj kód. Rychle se však ukázalo, že je s tímto názorem mezi vývojáři v menšině. Zvláště otrávený byl Adrian, který si stěžoval, že zatímco jiní vývojáři smějí bez varování provádět změny, kvůli kterým nefungují skoro všechny existující moduly, jeho patch, který se dotkne jen několika málo modulů, musí procházet speciálním procesem. Řekl na to:
Andrew, definuj prosím pro API pravidla. Jinými slovy: pravidla pro přidávání, odstraňování a změny exportovaného kódu, která budou platit pro *každého*, nebo jdi s EXPORT_UNUSED_SYMBOL do háje.
Christoph Hellwig reagoval také zostra, což vedlo k tomuto zábavnému rozhovoru (možná ne tak zábavnému pro citlivější povahy). Chladnější hlavy uvedly několik argumentů proti varování:
Nevypadá to však, že by chtěl Andrew ustoupit. Nechce uživatele zbytečně otrávit:
Skutečnost je taková, že lidé používají i moduly, které nejsou přímo v jádře. Aby jejich počítače pořádně fungovaly, aby mohli dělat svoji práci, aby mohli dělat to, co chtějí.
Spousta z nich nejsou programátoři. Takže když si stáhnou nové jádro a zjistí, že modul, který používají, nefunguje kvůli něčemu, co jsme udělali my, naštvou se a my přijdeme o testera. To už se stalo mockrát.
Aby se tomuto problému zabránilo, chce symboly, které mají být odstraněny, označovat pomocí EXPORT_UNUSED_SYMBOL() (nebo EXPORT_UNUSED_SYMBOL_GPL()) na jeden vývojový cyklus. Exporty by také měly být označeny komentářem, který by říkal, kdy budou úplně odstraněny. Při každém vydání by se provedl rychlý grep, pomocí kterého by se zjistilo, které symboly mají být právě odstraněny:
Celkové náklady na takové řešení: možná deset minut práce při každém vydání a pár desítek bajtů navíc ve vmlinux. Myslím, že je to dobrá cena za několik dalších testerů a méně otrávených uživatelů. Toť vše.
Na jiném místě poznamenal, že pokud je varování na dostatečném počtu míst, někdo na něj někde zareaguje. Nezdá se však, že by se mu podařilo přesvědčit hodně vývojářů. Ale Andrew má díky své pozici možnost si tento postup vynutit. A většina ostatních si patrně myslí, že je snazší se mu v tomto případě podřídit. Výsledek bude stejný, jen to bude trvat trochu déle.
Ačkoliv vývojový cyklus jádra 2.6.23 ještě není uzavřen, už se blížíme ke konci, takže si můžeme říci o celkových statistikách nové verze. Do této chvíle (těsně po vydání 2.6.23-rc6) bylo do hlavního repozitáře jádra začleněno něco přes 6 200 sad změn. Pocházejí od 854 vývojářů - o něco nižší číslo než v případě 2.6.22. 350 z nich přispělo jedinou sadou změn.
Patche přidaly téměř 430 000 řádků, ale odstranily 406 000, což znamená, že jádro povyrostlo o 23 000 řádků - relativně malé číslo. Částečně to je zásluhou jaderného kata Adriana Bunka, který odstranil starý kód SpeedStep, několik ovladačů Open Sound System (OSS), podporu procesoru Rise a další věci - téměř 73 000 řádků. Jeff Garzik odsekal přes 41 000 řádků kódu síťových ovladačů a Jens Axboe se zbavil více než 25 000 řádků - většinou šlo o prehistorické ovladače CDROM.
Následuje seznam nejaktivnějších přispěvatelů do 2.6.23. Řazeno podle začleněných sad změn a změněných řádků:
Nejaktivnější vývojáři 2.6.23 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
Ingo Molnar je na prvním místě kvůli začlenění plánovače CFS - a následným opravám. Více než polovina jeho patchů byla přijata po vydání 2.6.23-rc1. Ralf Baechle a Paul Mundt přispěli mnoha změnami ve stromech architektur, Trond Myklebust pracoval na NFS a, ačkoliv měl David Miller hodně patchů v síťování, většina změn od něho se týkala stromu architektury SPARC. Čísla v tabulce řazené podle změněných řádků jsou ovlivněna odstraňováním kódu (vizte výše); Jens Axboe také pracoval na splice a začlenil obecný SCSI ovladač "bsg". Hirokazu Takata pracoval na architektuře m32r a James Smart přispěl změnami Fibre Channel. Jeremy Fitzhardinge začlenil jádro kódu Xen.
Následující tabulka ukazuje výsledky snahy o přiřazení patchů ke společnostem, které podpořily jejich vvoj. Je potřeba to brát s rezervou; mělo by to být z většiny správně, ale protože patche nemají žádnou kolonku "Za-vývoj-zaplatil:", tak je vždy potřeba trochu hádat.
Nejaktivnější zaměstnavatelé | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
Red Hat si drží první pozici v seznamu řazeném podle sad změn, i když podíl je o trochu menší. Podle změněných řádků porážejí vývojáři pracující ve vlastním čase (řádek "žádný") všechny komerční přispěvatele. Stojí za zmínku, že většina započítaných řádků byla ve skutečnosti odstraněna.
Pohled na řádky Signed-off-by: (podepsal) je také zajímavý - zvláště když se podíváme na podpisy lidí, kteří nejsou autory podepisovaných patchů. Získáme tak představu o tom, kdo pracuje jako vrátný. Tentokrát byl výpočet proveden trochu odlišně: pokud patch podepsal jak Linus Torvalds, tak Andrew Morton, Linus se nepočítal. Protože všechno, co přejde přes Andrewa, podepisuje i Linus; když nepočítáme tato automatická podepsání, dostaneme věrnější obrázek schvalovacího procesu.
vývojáři s nejvíce podpisy (celkem 5653) | ||
---|---|---|
Andrew Morton | 1247 | 21,6 % |
Linus Torvalds | 397 | 6,9 % |
David S. Miller | 381 | 6,6 % |
Greg Kroah-Hartman | 329 | 5,7 % |
Jeff Garzik | 287 | 5,0 % |
James Bottomley | 264 | 4,6 % |
Paul Mackerras | 223 | 3,9 % |
Mauro Carvalho Chehab | 150 | 2,6 % |
Len Brown | 128 | 2,2 % |
Ralf Baechle | 122 | 2,1 % |
Roland Dreier | 116 | 2,0 % |
Andi Kleen | 113 | 2,0 % |
Russell King | 101 | 1,8 % |
Jaroslav Kysela | 100 | 1,7 % |
John W. Linville | 70 | 1,2 % |
Tony Luck | 65 | 1,1 % |
Takashi Iwai | 63 | 1,1 % |
Jens Axboe | 58 | 1,0 % |
Martin Schwidefsky | 55 | 1,0 % |
Ingo Molnar | 51 | 0,9 % |
Občas se objeví dotaz, jak tato čísla vypadají u jednotlivých částí jádra. Jonathan Corbet upravil svoje skripty, aby tyto informace získal. Následují tabulky se souhrnem výsledků - podle společností:
příspěvky v subsystémech podle zaměstnavatelů | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
Z těchto čísel lze vyvodit, že vývojáři Red Hatu mají silné zastoupení v "jádře jádra" [core kernel], ale psaní dokumentace příliš neholdují. Hodně "nadšenců" se účastní práce na ovladačích - což není nijak překvapující. Akademici si rádi hrají se souborovými systémy, stejně jako společnosti Oracle a NetApp - opět nic překvapujícího.
Kromě toho, že jde o přibližná čísla, tak ještě před finálním vydáním 2.6.23, které je ještě nejméně tři týdny vzdálené, dojde ke změnám. Začleňovány by však měly být jen opravy, takže snad budou změny (při troše štěstí) malé. Na 2.6.23 je vidět, že máme aktivní vývojářskou komunitu s příspěvky od mnoha různých lidí - a nemálo firem, které je zaměstnávají.
(Dík patří Gregu Kroah-Hartmanovi za pomoc s přípravou skriptů použitých k vygenerování těchto statistik.)
V cecku to m.j. jde taky. Vzpomente si na vousaty priklad aplikace napsane jako prikaz for. Kultura a zdravy rozum zpusobuji, ze podobne vystrelky uz dnes vidime zridka. Zato v C++ se zkonstruovani objektu aplikace s overloadovanym operatorem funkcniho volani (misto volani main) povazuje nekterymi jedinci stale jeste za dobry (a jediny mozny) styl prace. Je to tim ze C++ je mladsi a slozitejsi. Ale lepsi se to.
Za spatnou povest C++ muzou prave silenci, kteri si mysli, ze musi vyuzit vsecky ficury uz v Hello World.
Jenže C++ opravdu není "C s featurami". Je to samostatný jazyk s odlišnou filosofií. Pokud napíšete Hello World jako
#include <stdio.h> int main() { printf("Hello, world!\n"); return 0; }
pak to sice C++ překladačem přeložíte, dokonce to bude i správně fungovat, ale není to programování v C++.
Proč myslíte? Mně na tom nic umělého nepřipadá:
#include <iostream> int main() { std::cout << "Hello, world!\n"; return 0; }
Svým způsobem je to možná i srozumitelnější než v tom C - hlavně pokud bychom pokročili kousek dál a do výstupu chtěli zahrnout třeba hodnoty nějakých číselných proměnných.
rozhodně nevznikne přirozenou cestou - musíte znát rozdíly a snažit se o to
xor
jako identifikátor nepoužil v žádném jazyce, protože mi nestojí za to pamatovat si, ve kterém jazyce je to rezervované slovo a ve kterém ne, tak taková potenciálně nebezpečná jména nepoužívám raději nikde.
double bz; void main() { struct bz { int fn;} printf("%d",sizeof(bz)); }vypise v C i v C++ neco jineho akorat v mem pripade to bylo ve velkem programu a zasmodrchane.
-Wall
.
Ten člověk, co psal, že C je bez problému C++ zdroják musel mít řádně vypito z láhve, a nebo - což je pravděpodobnější - věděl o tom hovno.
Bez ohledu na vaše silné výrazivo je to ovšem v naprosté většině případů pravda. Vážně byste jednou mohl zkusit argumentovat věcně, bez urážení oponentů a neustálého zdůrazňování, jaké jsou to nuly a jak ničemu nerozumějí. Pokud jste toho tedy schopen…
Přesná citace to sice je, ale ne z mého příspěvku. Takže pokud nemáte jinou, je mi líto…
Co se velkého kvantifikátoru týká, v běžné řeči nebývá zvykem ho implicitně používat v plném rozsahu. Nebo snad podle vás každý, kdo si povzdechne "lidi jsou svině", tím automaticky myslí všech šest miliard včetně sebe a toho, komu to říká? Asi ne… Proto také, pokud chceme v běžné řeči opravdu použít velký kvantifikátor, používáme pro zdůraznění každý, všichni apod. Ale to je stejně jedno, jak už jsem upozornil, příspěvek, na základě něhož mne pranýřujete, jsem nepsal já.
Jaké invektivy?
Už v dřívějších diskusích jsem si všiml, že nedokážete udržet diskusi ve věcné rovině a jakmile si s vámi někdo dovolí nesouhlasit, a co hůř, i po prvním okřiknutí si drze dovolí stát za svým názorem, okamžitě prokládáte své příspěvky poznámkami naznačujícími, jaký je ten člověk blbec, jak ničemu nerozumí, jak nikdy nic pořádného nenaprogramoval atd. Možná si to ani neuvědomujete, ale vězte, že je to nedůstojné a nechutné. Prosím vás proto, abyste toho nechal.
Ale já už si všiml, že jakmile někdo napíše, že C a C++ je totéž jen s malými rozdíly - že to znamená, že onen člověk prostě neumí pořádně ani C, ani C++. C a C++ jsou velmi odlišné jazyky s odlišnou filozofií, které jen stavěji na společném syntaktickém základu.
Nic takového jsem ovšem nenapsal. Pouze jsem napsal (nebo spíš podpořil kolegu, který to napsal první), že C je z hlediska syntaxe téměř podmnožinou C, protože těch odlišností, kdy se céčkový program nedá přeložit jako C++, je docela málo. A že vznikají buď tak, že se úmyslně snažíte takový program zkonstruovat, nebo že máte zatracenou smůlu (a mnohdy si za to můžete sám - jako třeba ve výše uvedené ukázce). To je prostě fakt - a kolik takových umělých ukázek tu zkonstruujete, to na věci nic nezmění.
Zajímavé. Proč mne tedy místo uvedení věcných argumentů hned na začátek příspěvku napadáte, že jsem nikdy nenapsal nic většího než pár řádků? A to se mi ani nechce dohledávat všechny ty povýšené pošklebky na mou adresu v minulé diskusi, kdy jsme se neshodli.
Stěžujete si, že tu na vás byli oškliví a že vás uráželi daleko hůř. Tomu docela dobře věřím. Ale dělal jsem to já? Zpochybňoval jsem snad vaši odbornou erudici? Psal jsem, že jste jakživ nic netriviálního nenaprogramoval? Nejsem si toho vědom. Takže pokud nejste schopen doložit že ano, znovu vás prosím, abyste se takových výpadů v komunikaci se mnou zdržel. Zkuste urážet a zesměšňovat jen ty, kdo se k vám chovají stejně, nedělejte to preventivně.
Protože bylo okamžitě z Vašich argumentů zřejmé, že obhajujete přístup, který lze použít jen u malých projektů.
Mně se osvědčil i u větších. Za prvé se snažím, aby těch globálních objektů bylo co nejméně (ne víc, než je nezbytně nutné). Za druhé zastávám zásadu, že každý modul by měl navenek poskytovat jen to, co je opravdu potřeba. Za třetí ten (programátor), kdo ty deklarace includuje, by se měl seznámit s tím, co includuje a na kolize dávat pozor. Za čtvrté se snažím udržet nějaké jmenné konvence, které by měly v co největší míře eliminovat možnost kolize mezi objekty různých typů (třeba proměnná vs. typ resp. tag struktury); ne že bych byl příznivcem takových těch prefixových orgií (t_
pro typy, m_
pro metody apod.), ale myslím si, že není takový problém najít rozumný kompromis. Myslím si, že jsou to poměrně rozumné zásady, které se dají uplatnit i u projektů, na kterých se podílí větší počet programátorů, a IMHO jsou v takových případech ještě důležitější než u projektu, který je dílem jednotlivce.
cc
a zkusím je přeložit, u kolika se mi to podle vás povede? Podle toho, co tu píšete, by to vypadalo, že tak s bídou deset. Já tvrdím, že spíš od devadesáti výš. A kdyby to bylo všech sto, ani trochu by mne to nepřekvapilo.
char* buffer;
buffer = malloc(20);
by Vám v C prošlo, ale v C++ to nepřeložíte.
Dále prototypy funkcí v C a v C++ mají jiný význam:
třeba
int funkce();
int main()
{
...
a = funkce();
...
};
projde v C bez varování a C to pochopí jako dostatečnou informaci, zatímco C++ si bude stěžovat.
A tak bych mohl pokračovat dál a dál - je toho opravdu dost, kde jsou rozdíly mezi C a C++. Takže záleží na tom, co je konkrétně ve zdrojovém kódu, zda budete mít problémy s přeložením, a nebo (což je daleko záludnější) s jinou funkčností téhož v C a v C++.
Proto říkám, že já osobně bych si neodvážil udělat překlad C zdrojového kódu naslepo do C++ - očekával bych zde záludné chyby a to i v případě, že by to bezchybně prošlo C++ kompilací.
Proto říkám, že já osobně bych si neodvážil udělat překlad C zdrojového kódu naslepo do C++ - očekával bych zde záludné chyby a to i v případě, že by to bezchybně prošlo C++ kompilací.
Sice jsem to výslovně nenapsal, ale to bych se samozřejmě neodvážil ani já. Jedna věc je (akademická) otázka, zda typický C zdroják funguje i jako C++, ale vzít cizí céčkový zdroják a vrazit ho bez kontroly coby C++ kód do C++ projektu, to je samozřejmě něco úplně jiného. Vzhledem k tomu, že se u vlastních zdrojákům určitým zavánějícím praktikám vyhýbám i v C (třeba té ukázce s implicitním přetypováním pointerů), řekl bych, že u mých zdrojáků by to zase takové riziko nebylo (ale zkontroloval bych je stejně). Ostatně kdo píše střídavě v C i C++, ten si ve vlastním zájmu zvykne se takovým problémovým konstrukcím vyhýbat.
Ta druhá ukázka v C++ projde, ale asi tuším, co jste měl na mysli - že v C ta deklarace reprezentuje jakoukoli funkci vracející int
, zatímco v C++ jen funkci bez parametrů.
Mimochodem, kdybyste si místo urážení oponentů ráčil přečíst, co píší, třeba byste si všiml, že prakticky totéž jako
C a C++ jsou velmi odlišné jazyky s odlišnou filozofií, které jen stavěji na společném syntaktickém základu.
jsem tu před pár hodinami napsal i já. Ale ono je jednodušší si honit triko, jak oponent nikdy nic nenapsal a vůbec nechápe, že je C++ něco jiného než C, že?
"struct bz"
a "bz"
jsou pojmenovány jinak. To že C++ ke každému struct/class
dělá i zbytečný a pomýlený typedef (a nestará se o to co tím rozbije) je pak logicky jenom jeho problém...
Spíš ho neumíte vy. Jinak byste věděl, že klíčové slovo struct
rozhodně nelze považovat za součást jména a identifikátorem je zde samotné bz
, i když samo o sobě nemůže sloužit jako specifikace typu.
P.S.: koukám, že jste převzal argumentační styl pana Ponkráce (když už nemůžeme oponenta přesvědčit argumenty, prohlásíme ho aspoň za blbce), tímto mu gratuluji ke skvělému pedagogickému úspěchu.
bz
a struct bz
jsou každý v jiném namespace.
Takový C programátor by spíš měl vědět, že
struct bz
' není identifikátorPatche přidaly téměř 430 000 řádků, ale odstranily 406 000, což znamená, že jádro povyrostlo o 23 000 řádků
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.