Avatar
havlat82
Člen
Avatar
havlat82:

ahoj v unitě system je deklarovaná proměnná softfloat_excep­tion_mask. neví někdo, jakých může dosahovat hodnot? hledal jsem to marně celej včerejšek v oficiální dokumentaci. používám free pascal 2.6.2/lazarus.

 
Odpovědět 26.8.2013 10:24
Avatar
Martin Dráb
Redaktor
Avatar
Martin Dráb:

O jakou verzi Delhi jde? Právě jsem prohledal zdrojáky dostupné v XE2 a žádná tkaová proměnná tam neexistuje.

Zkus najít reference na tu proměnnou (místa, kde je použita), IDE by k tomu mělo poskytovat možnosti v kontextovém menu. Je ale možné, že neposkytují dostatek zdrojáků.

Jinak bych podezříval (z názvu), že ta proměnná zřejmě bude nějak určovat, které výjimky koprocesoru má Delphi vyhazovat (či ignorovat).

Nahoru Odpovědět 26.8.2013 12:01
2 + 2 = 5 for extremely large values of 2
Avatar
havlat82
Člen
Avatar
Odpovídá na Martin Dráb
havlat82:

odkaz na ofiko dokumentaci pro tuhle proměnnou..
http://www.freepascal.org/…on_mask.html

našel sem akorát proceduru float_raise
http://www.freepascal.org/…t_raise.html
ale do ní se dávaj hodnoty softfloat_excep­tion_flags jestli sem to správně pochopil. je možný, aby to byl alias?

 
Nahoru Odpovědět 26.8.2013 13:32
Avatar
havlat82
Člen
Avatar
Odpovídá na Martin Dráb
havlat82:

jo přes global browser/module browser sem se na to taky koukal.. jenže nevim jak to mám filtrovat.. je možný, že sem to i přehlíd. dá se browser nastavit aby zobrazil akorát konstanty?

 
Nahoru Odpovědět 26.8.2013 13:38
Avatar
Martin Dráb
Redaktor
Avatar
Martin Dráb:

Aha, já jsem nedočetl tvůj první příspěvek do konce, takže jsem se nedozvěděl, že se jedná o Freepascal.

Ono Freepascal bude mít některá rozhraní stejná/podobná jako starý Pascal/Delphi, budou dělat i to samé (nebo téměř to samé), aby se zachovávala kompatibilita a snadná portovatelnost. Ale vnitřní implementace může být dost odlišná. To samé platí třeba o ReactOS.

Nahoru Odpovědět 26.8.2013 13:47
2 + 2 = 5 for extremely large values of 2
Avatar
havlat82
Člen
Avatar
Odpovídá na Martin Dráb
havlat82:

Mo tak sem to profiltroval ještě jednou, podle mě to tam neni. ale to je stejně jedno. chci udělat range checking, aby neházel runtimy. ale tohle mi ten runtime přesně hodí. zkusil sem to vyřešit přes datovej typ variant.

type
zaznam_hodnoty=re­cord
popis: string;
case typ_hodnoty of
cely_cislo: (Z_rozsah: rozsah_Z_cisel; Z_hodnota: Int64);
prirozeny_cislo: (N_rozsah: rozsahN_cisel; N_hodnota: QWord);
realny_cislo: (R_rozsah: rozsah_R_cisel; R_hodnota: Extended);
end;

Pak sem napsal objekt, kterej spravoval ukazatel na tenhle záznam.
constructor rodicovskýho objektu:

constructor vytvor(hodnota: variant);

constructor potomka:
constructor vytvor(hodnota: Int64);

když sem to pak otestoval..

var c: Tcely_cisla;
begin
c.vytvor(1000);
end.

hodilo mi to runtime error 217. chyba segmentace něco s GDB.. Co to je GDB?
Když sem to krokoval spadlo mi to vždycky v jednom místě. a zobrazilo mi to stack call stalo se to,když mělo dojít k převodu typu variant na int64. přitom de normálně přiřazovat int64 hodnoty do proměnný typu variant a naopak. Satrapa (Pascal pro zelenáče) píše: "hodnota rozlišovací proměnné určuje, která z variant je právě aktivní.." Tak to mi vůbec nefunguje. čekal sem že když zadam rozl.hodnotu cele_cislo, ze mi překladač zakáže použít jiny položky záznamu než ty, který sem definoval u této rozl.hodnoty. ale von mi to povolí přiřadit.. sem z toho už trochu frustrovanaj.. :(

 
Nahoru Odpovědět 28.8.2013 1:18
Avatar
Martin Dráb
Redaktor
Avatar
Martin Dráb:

Freepascal už nějakou dobu nepoužívám, takže asi některé věci z novější syntaxe neznám. Každopádně jestli voláš ten konstruktor tak, jak ukazuješ v příkladu, tak mi to nepřijde zrovna validní. Mám dojem, že Pascal neumožňoval objekty alokovat na zásobníku, ale jen na haldě (tedy přes New). V Delphi se zase konstrukce dělá takto:

Promenna := TypObjektu.Konstruktor(parametry);

Chyba 217, co jsem alespoň vygooglil, má popis "invalid operation code", pod čímž si v tomto kontextu neumím nic představit. Range check to ale určitě není.

GDB je debugger, původně asi pocházející ze světa Unixu/Linuxu. Co jsem slyšel, tak ne moc user-friendly... asi to bude něco jako WinDbg ve Windows, se kterým se dost často pracuje prostřednictvím něceho jako Příkazový řádek, popř. se píšou skripty v takovém podivném jazyce.

Jinak v době překladu překladač nedokáže poznat (ne vždy), jaké položky toho variantního záznamu jsou aktuálně použitelné. Pro takové rozhodnutí musí znát hodnotu jedné položky toho záznamu, kterou ale nedokáže vždy správně předpovědět. Aby ji bylschopen nějak předvídat, je třeba použít ne úplně triviální algoritmy a řekl bych, že to tam ani neimplementovali.

Zvlášť když k tomu záznamu přistupuješ přes ukazatel. Co se týče různých optimalizací kódu při překladu a předvídání věcí příštích, ukazatelé jsou jedno z velkých zel, jelikož se v době překladu těžko předvídá, kam míří, zda dva ukazatele neodkazují na to samé místo a tak.

Nahoru Odpovědět 28.8.2013 12:20
2 + 2 = 5 for extremely large values of 2
Avatar
havlat82
Člen
Avatar
havlat82:

celej problem skončil, když sem zapojil unitu variants. no ted, abych hledal dokumentaci, k týhle unitě. páč v dokumentaci o RTL neni. Pravděpodobně budu muset využít FPDoc a ten teda neni zrovna user-friendly. Takže si na něj udělám batch. Otázka je jestli mi to pomůže, páč si myslim, že při nahrání unity se určitě provedou nějaký příkazy/nastavení a FPDoc vychytá všechno, co je v sekci interface ale ne to co je v hlavnim bloku unity.. :( New/Dispose lze použít v metodě/podprogramu. vyzkoušel sem si to. nebyl problém ani v tom variatnim záznamu. problem nastal, když sem se pokusil přiřadit hodnotu typu variant (ne variantní záznam) do položky v ukazateli na variantní zaznam, která byla jednoduchého typu. A po zapojení unity variants, tenhle problem zmizel. jak se zdá.. No ještě to otestuju a napíšu sem výsledek. co kdyby náhodou měl někdo podobnej problem.

 
Nahoru Odpovědět 29.8.2013 2:37
Avatar
havlat82
Člen
Avatar
havlat82:

No nakonec sem to vyřešil takhle:

const
minimum_Int64 = Low(Int64);
maximum_Int64 = High(Int64);

minimum_QWord = Low(QWord);
maximum_QWord = High(QWord);

type
cela_cisla = Int64;
prirozena_cisla = QWord;

limitni_funkce = (minimum, maximum);

rozsah_Z_cisel = function(limit: limitni_funkce): cela_cisla;
rozsahN_cisel = function(limit: limitni_funkce): prirozena_cisla;

typ_hodnoty = (cele_cislo, prirozene_cislo);

ukaz_hodnotu = ^zaznam_hodnoty;

zaznam_hodnoty = record
case typ_hodnoty of
cele_cislo: (Z_rozsah: rozsah_Z_cisel; Z: cela_cisla);
prirozene_cislo: (N_rozsah: rozsahN_cisel; N: prirozena_cisla);
end;

spravce_hodnoty = object
U: ukaz_hodnotu;
constructor vytvor;
destructor znic;
end;

spravce_celeho_cis­la = object(spravce_hod­noty)
constructor vytvor(h: cela_cisla);
function hodnota: cela_cisla;
function max: cela_cisla;
end;

spravce_priro­zeneho_cisla = object(spravce_hod­noty)
constructor vytvor(h: prirozena_cisla);
function hodnota: prirozena_cisla;
function max: prirozena_cisla;
end;

()+++++++++++++ IMPLEMENTACE FUUNKCI PRO KONTROLU ROZSAHU ++++++++++++++()
function rozsah_celych_ci­sel(limit: limitni_funkce): cela_cisla;
begin
case limit of
minimum: rozsah_celych_cisel := minimum_Int64;
maximum: rozsah_celych_cisel := maximum_Int64;
end;
end;

function rozsah_priroze­nych_cisel(li­mit: limitni_funkce): prirozena_cisla;
begin
case limit of
minimum: rozsah_priroze­nych_cisel := minimum_QWord;
maximum: rozsah_priroze­nych_cisel := maximum_QWord;
end;
end;

()+++++++++++++ IMPLEMENTACE SPRAVCE HODNOT +++++++++++++­+++++++++++++++()
constructor spravce_hodno­ty.vytvor;
begin
New(U);
end;

destructor spravce_hodno­ty.znic;
begin
Dispose(U);
end;

()+++++++++++++ IMPLEMENTACE SPRAVCE CELEHO CISLA +++++++++++++­+++++++++()
constructor spravce_celeho_cis­la.vytvor(h: cela_cisla);
begin
New(U);
U^.Z_rozsah := @rozsah_celych_ci­sel;
U^.Z := h;
end;

function spravce_celeho_cis­la.hodnota: cela_cisla;
begin
hodnota := U^.Z;
end;

function spravce_celeho_cis­la.max: cela_cisla;
begin
max := U^.Z_rozsah(ma­ximum);
end;

()+++++++++++++ IMPLEMENTACE SPRAVCE PRIROZENEHO CISLA +++++++++++++­++++()
constructor spravce_priro­zeneho_cisla.vyt­vor(h: prirozena_cisla);
begin
New(U);
U^.N_rozsah := @rozsah_priro­zenych_cisel;
U^.N := h;
end;

function spravce_priro­zeneho_cisla.hod­nota: prirozena_cisla;
begin
hodnota := U^.N;
end;

function spravce_priro­zeneho_cisla.max: prirozena_cisla;
begin
max := U^.N_rozsah(ma­ximum);
end;

var n: spravce_priro­zeneho_cisla;
begin
n.vytvor(1000);
writeln(n.hodnota);
writeln(n.max);
n.znic;
end.

Nemusim nahrávat unitu variants a funguje to tak jak má..

 
Nahoru Odpovědět 29.8.2013 4:28
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 9 zpráv z 9.