Diskuze: hodnoty softfloat_exception

havlat82

Člen

havlat82:26.8.2013 10:24

ahoj v unitě system je deklarovaná proměnná softfloat_exception_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

Martin Dráb

Tvůrce

Martin Dráb:26.8.2013 12:01

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

havlat82

Člen

havlat82:26.8.2013 13:32

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_exception_flags jestli sem to správně pochopil. je možný, aby to byl alias?

Nahoru Odpovědět

26.8.2013 13:32

havlat82

Člen

havlat82:26.8.2013 13:38

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

Martin Dráb

Tvůrce

Martin Dráb:26.8.2013 13:47

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

havlat82

Člen

havlat82:28.8.2013 1:18

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=record
popis: string;
case typ_hodnoty of
cely_cislo: (Z_rozsah: rozsah_Z_cisel; Z_hodnota: Int64);
prirozeny_cislo: (N_rozsah: rozsah_N_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

Martin Dráb

Tvůrce

Martin Dráb:28.8.2013 12:20

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

havlat82

Člen

havlat82:29.8.2013 2:37

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

havlat82

Člen

havlat82:29.8.2013 4:28

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;
rozsah_N_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: rozsah_N_cisel; N: prirozena_cisla);
end;

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

spravce_celeho_cisla = object(spravce_hodnoty)
constructor vytvor(h: cela_cisla);
function hodnota: cela_cisla;
function max: cela_cisla;
end;

spravce_prirozeneho_cisla = object(spravce_hodnoty)
constructor vytvor(h: prirozena_cisla);
function hodnota: prirozena_cisla;
function max: prirozena_cisla;
end;

()+++++++++++++ IMPLEMENTACE FUUNKCI PRO KONTROLU ROZSAHU ++++++++++++++()
function rozsah_celych_cisel(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_prirozenych_cisel(limit: limitni_funkce): prirozena_cisla;
begin
case limit of
minimum: rozsah_prirozenych_cisel := minimum_QWord;
maximum: rozsah_prirozenych_cisel := maximum_QWord;
end;
end;

()+++++++++++++ IMPLEMENTACE SPRAVCE HODNOT ++++++++++++++++++++++++++++()
constructor spravce_hodnoty.vytvor;
begin
New(U);
end;

destructor spravce_hodnoty.znic;
begin
Dispose(U);
end;

()+++++++++++++ IMPLEMENTACE SPRAVCE CELEHO CISLA ++++++++++++++++++++++()
constructor spravce_celeho_cisla.vytvor(h: cela_cisla);
begin
New(U);
U^.Z_rozsah := @rozsah_celych_cisel;
U^.Z := h;
end;

function spravce_celeho_cisla.hodnota: cela_cisla;
begin
hodnota := U^.Z;
end;

function spravce_celeho_cisla.max: cela_cisla;
begin
max := U^.Z_rozsah(maximum);
end;

()+++++++++++++ IMPLEMENTACE SPRAVCE PRIROZENEHO CISLA +++++++++++++++++()
constructor spravce_prirozeneho_cisla.vytvor(h: prirozena_cisla);
begin
New(U);
U^.N_rozsah := @rozsah_prirozenych_cisel;
U^.N := h;
end;

function spravce_prirozeneho_cisla.hodnota: prirozena_cisla;
begin
hodnota := U^.N;
end;

function spravce_prirozeneho_cisla.max: prirozena_cisla;
begin
max := U^.N_rozsah(maximum);
end;

var n: spravce_prirozeneho_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

Nejčastěji vyhledáváné

Diskuze: hodnoty softfloat_exception_mask