Interner Fehler C1537 - result Fehler???

[mr.warft]

Hallo Forum,

ich bin neu hier und beschäftige mich studienbedingt mit Delphi bzw. Object Pascal.

Ich habe ein Problem und komme einfach nicht dahinter was es sein könnte. Ich habe den Fehler schon eingegrenzt...zumindest denke ich das es daran liegt.

Delphi-Quellcode:

function TBigInteger.copy:TBigInteger;
var
   r : PBigInteger;
begin
     //r.BigInteger(BigIntegerToStr());
   new(r,BigInteger(BigIntegerToStr()));
   result := r^;
end;

An dieser Stelle wird mir ein interner Fehler C1537 gemeldet und ich habe schon 2Tage gegoogelt aber nichts darüber gefunden. Was ist der interne Fehler und was löst es aus bzw. wie kann ich diesen Fehler beseitigen.

Der Aufruf hin zu dieser Funktion erfolgt so:

Delphi-Quellcode:

function xyz (const a: TBigInteger; const  b : TBigInteger):TBigInteger;
var
   n,m: LongInt;

   xh,xl,yh,yl: TBigInteger;
   t3,t1,t2: TBigInteger;
   z1,z2,z3,z4,z5: TBigInteger;
begin
   inc(c);

   m := Max(a.bitLength(),b.bitLength());
   Debug('max: '+IntToStr(m));

   if (m <= 2) then
   begin
      result := a.multr(b);
   end else
   
   begin
   Debug('Durchgang: '+IntToStr(c));
   Debug('----------------');
   n := (m div 2);


   (****************** X ***********************)
   //BigInteger xH = x.shiftRight (n);
   xh := a.shrR(n);

und in shrR sieht der Code dann so aus:

Delphi-Quellcode:

function TBigInteger.shrR(n: Integer): TBigInteger;
var
   tmp: TBigInteger;
begin
   tmp := copy();
   tmp.shiftright(n);
   result := tmp.copy();
end;

Wo kann hier der Fehler sein?

Als Info: Unter FreePascal funktioniert dieser Code ohne Probleme. Ich benutze Borland Delphi 2005.

Hoffe das ihr mir helfen könnt.

[Muetze1]

Benutzt du alte Objekte von Pascal anstatt Klassen? Kannst du mal bitte die Deklaration von TBitInteger und PBigInteger posten?

[mr.warft]

Ja benutze ich ... der BigInteger ist eine Vorgabe von unseren Prof.

Hier der Code:

Delphi-Quellcode:

        { Objekttypdeklarationen (Bezeichner, Methoden) einer
          BigInteger-Zahl: }
        PBigInteger = ^TBigInteger; { Pointer auf eine BigInteger-Zahl }
        TBigInteger = OBJECT
                   PRIVATE
                     { Eine BigInteger-Zahl wird als Bin?rzahl beliebiger
                       L?nge dargestellt. Alle Bits werden als vorzeichen-
                       lose positive Zahl interpretiert. Das Vorzeichen
                       der Zahl wird separat gespeichert                   }
                     vz           : Tvorzeichen;
                     { Vorzeichen der Zahl : vzminus bei negativer Zahl,
                                             vznull bei Wert 0,
                                             vzplus bei positiver Zahl         }
                     wert         : Pwertfeld;
                     { Wert der Zahl (als nullterminierter Bytestring)
                       in Big-endian Speicherung: das h?chstwertige Bit
                       der Zahl steht in wert[0] und dort an der
                       kleinstm?glichen Bitposition. Das niedrigst-
                       wertige Bit der Zahl steht an Bitposition 0 in
                       wert[i-1], wenn die Zahl die Bytes
                       wert[0], ..., wert[i-1] belegt. Die restlichen
                       Bytes des zugewiesenen Speicherbereichs sind mit
                       dem Zeichen #0 aufgef?llt.
                       Der Wert 0 hat vorzeichen = 0 und wert[0] = 0.      }
                     bitanzahl    : INTEGER;
                     { Anzahl der Bits der Zahl.
                       Der Wert 0 hat bitanzahl = 1.                       }
                     byteanzahl   : INTEGER;
                     { Anzahl der von der Zahl belegten Bytes, d.h. die
                       Zahl belegt die Bytes
                       wert[0], ..., wert[byteanzahl-1].
                       Der Wert 0 hat byteanzahl = 1.                      }
                     hoechstesBit : ShortInt;
                     { h?chste verwendete Bitposition in wert[0].
                       Es ist 0 <= hoechstesBit <= 7.                      }
                     PROCEDURE Nullbytes_entfernen;
                     { stellt sicher, da? die BigInteger-Zahl in der oben
                       beschriebenen Weise in wert abgelegt ist, d.h. da?
                       die Zahl genau die Bytes
                       wert[0], ..., wert[byteanzahl-1]
                       (ohne f?hrende Nullbytes) belegt
                       und da? bei einem Wert <> 0 die Bedingung
                       wert[0] <> 0 erf?llt ist                            }
                     PROCEDURE powergeneral (a       : TBigInteger;
                                             b       : TBigInteger;
                                             c       : TBigInteger;
                                             mit_mod : BOOLEAN);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                           hoch
                                           den Wert der BigInteger-Zahl |b|
                                           MOD (falls mit_mod = TRUE ist)
                                           den Wert der BigInteger-Zahl |c|}
                     FUNCTION OddB : BOOLEAN;
                      { liefert TRUE, wenn der Wert der Zahl ungerade ist,
                        sonst FALSE                                        }
                   PUBLIC
                     CONSTRUCTOR BigInteger (Strwert : ANSIString);
                      { erzeugt eine BigInteger-Zahl, deren Repr?sentation
                        als Zeichenkette im Parameter Strwert
                        ?bergeben wird                                     }

                     CONSTRUCTOR BigIntegerI (Intwert : INTEGER);
                      { erzeugt eine BigInteger-Zahl, deren Repr?sentation
                        als INTEGER-Zahl im Parameter Intwert
                        ?bergeben wird                                     }

                     CONSTRUCTOR BigIntegerB (Bigwert : TBigInteger;
                                              vorz    : Tvorzeichen);
                      { erzeugt eine BigInteger-Zahl, deren Repr?sentation
                        als BigInteger-Zahl im Parameter Bigwert
                        ?bergeben wird, mit dem in vorz ?bergebenen
                        Vorzeichen;
                        bei vorz = vznull wird der Wert 0 erzeugt,
                        unabh?ngig vom Wert von Bigwert                    }

                     CONSTRUCTOR BigIntegerH (Ptrwert : Pwertfeld;
                                              Byteanz : INTEGER);
                      { erzeugt aus dem Wertfeld (Sedezimalwerte) in der
                        angegebenen L?nge, indiziert von 0 bis Byteanz - 1),
                        eine nichtnegative BigInteger-Zahl                 }

                     FUNCTION internerWert : Pwertfeld;
                       { liefert einen Pointer auf die interne
                         Repr?sentation (Komponente wert) der Zahl         }

                     FUNCTION vorzeichen : Tvorzeichen;
                      { liefert das Vorzeichen der Zahl                    }

                     FUNCTION BitLength : INTEGER;
                      { liefert die Bitanzahl der Zahl                     }

                     FUNCTION ByteLength : INTEGER;
                      { liefert die Byteanzahl der Zahl                    }

                     FUNCTION compare (bigzahl : TBigInteger) : Tcompare;
                      { vergleicht den eigenen Wert mit dem Wert der
                        BigInteger-Zahl bigzahl                            }

                     FUNCTION BigIntegerToStr : ANSIString;
                      { liefert den eigenen Wert als lange
                        Zeichenkette einschlie?lich des Vorzeichens        }

                     FUNCTION BigIntegerToHexstr : ANSIString;
                      { liefert den eigenen Wert als lange
                        Zeichenkette aus Sedezimalziffern einschlie?lich
                        des Vorzeichens                                    }

                     PROCEDURE SetI (i : BYTE);
                     { setzt die Zahl auf den Wert i                       }

                     PROCEDURE SetB (Bigwert : TBigInteger;
                                     vorz    : Tvorzeichen);
                      { setzt wert auf den Wert von Bigwert mit dem
                        in vorz ?bergebenen Vorzeichen;
                        bei vorz = vznull wird der Wert 0 erzeugt,
                        unabh?ngig vom Wert von Bigwert                    }

                     PROCEDURE add (a : TBigInteger;
                                    b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl a
                                           plus
                                           den Wert der BigInteger-Zahl b  }

                     PROCEDURE sub (a : TBigInteger;
                                    b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl a
                                           minus
                                           den Wert der BigInteger-Zahl b  }

                     PROCEDURE mult (a : TBigInteger;
                                     b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl a
                                           multiliziert mit
                                           dem Wert der BigInteger-Zahl b  }

                     PROCEDURE divB (a : TBigInteger;
                                     b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                           DIV
                                           den Wert der BigInteger-Zahl |b|;
                        der Wert der BigInteger-Zahl b muss <> 0 sein      }

                     PROCEDURE modB (a : TBigInteger;
                                     b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                           MOD
                                           den Wert der BigInteger-Zahl |b|}

                     PROCEDURE power (a : TBigInteger;
                                      b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                           hoch
                                           den Wert der BigInteger-Zahl |b|}

                     PROCEDURE powermod (a : TBigInteger;
                                         b : TBigInteger;
                                         c : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                           hoch
                                           den Wert der BigInteger-Zahl |b|
                                           MOD
                                           den Wert der BigInteger-Zahl |c|}

                     PROCEDURE shiftleft (i : INTEGER);
                       { schiebt bei i >= 0 wert um i Bitpositionen nach
                         links; f?hrende Bits entfallen dabei nicht;
                         von rechts werden 0-Bits nachgezogen              }

                     PROCEDURE IncB;
                        { erh?ht den Wert von wert um 1                    }

                     PROCEDURE DecB;
                        { vermindert den Wert von wert um 1                }

                     PROCEDURE ggT (a : TBigInteger;
                                    b : TBigInteger);
                     { bestimmt den gr??ten gemeinsamen Teiler von
                      |a| und |b| mit dem Euklidischen Algorithmus         }

                     PROCEDURE  invers (a         : TBigInteger;
                                        b         : TBigInteger;
                                        VAR a_inv : TBigInteger;
                                        VAR b_inv : TBigInteger);

                    { bestimmt den gr??ten gemeinsamen Teiler von
                      |a| und |b| mit dem Euklidischen Algorithmus
                      und ganze Zahlen a_inv und b_inv mit
                      a*a_inv + b*b_inv = ggT(a, b)                        }

                    PROCEDURE zufallszahl (Dezimalstellen : INTEGER;
                                           ungerade       : BOOLEAN);
                    { erzeugt eine Zufallszahl mit der angegebenen Anzahl
                      an Dezimalstellen                                    }

                    PROCEDURE generate_prim (Dezimalstellen : INTEGER);
                    { erzeugt eine Primzahl mit der angegebenen Anzahl
                      an Dezimalstellen                                    }

                    FUNCTION ist_prim (k : INTEGER) : BOOLEAN;
                    { ergibt TRUE, wenn der Wert der Zahl eine
                      Primzahl ist, sonst FALSE;
                      k gibt die Anzahl der Testiterationen an             }

Das ist ein bisschen mehr Code als verlangt aber das ist ja nicht schlimm.

[Dezipaitor]

Delphi-Quellcode:

function TBigInteger.copy:TBigInteger;
var
   r : PBigInteger;
begin
     //r.BigInteger(BigIntegerToStr());
   new(r,BigInteger(BigIntegerToStr()));
   result := r^;
end;

Das würde ich nicht so machen, besonders da hier ein Zeiger übrigbleibt.

Delphi-Quellcode:

function TBigInteger.copy : PBigInteger;
begin
   new(Result,BigInteger(BigIntegerToStr()));
end;

[Muetze1]

So war mein Beitrag auch, bis ich ihn erstmal auf die Basisfrage editiert habe. Grund ist, dass diese Object'e mit New angelegt werden. In deinem Code (sowie deinem auch), legt ihr mit New() aber nun nur den Pointer an, also weist diesem Speicher zu, das Objekt dahinter ist aber nach wie vor ungelegt bzw. nicht initialisiert.

Delphi-Quellcode:

function TBigInteger.copy:TBigInteger;
begin
   new(result,BigInteger(BigIntegerToStr()));
end;

[mr.warft]

Hallo Muetze1

so hatte ich das auch einmal Probiert gehabt aber da habe ich (wie jetzt auch) immer einen Fehler bekommen...

E2008 Inkompatible Typen --> und das genau in der Zeile von new(result,BigInteger(BigIntegerToStr()));.

Was passt dort nicht?

Danke für die Hilfe!!!!!

[Dezipaitor]

Hallo, liest jemand noch meine Beiträge?

[mr.warft]

natürlich werden deine lösungen gelesen.

Aber wenn ich das ändere...hoffe das alles so korrekt ist:

Delphi-Quellcode:

DESTRUCTOR TBigInteger.done;

BEGIN { TBigInteger.done }
  FreeMem (wert, byteanzahl + 1);
END   { TBigInteger.done };

{ ************************************************************************ }

procedure debug(txt:String);
begin
  //WriteLn(txt);
  FormEingabe.Memo1.Lines.Add(txt);
end;

function TBigInteger.multr (b : TBigInteger):TBigInteger;
var
   tmp: TBigInteger;
begin
   tmp := copy()^;
   tmp.mult(tmp,b);
   result := tmp.copy()^;
end;

function TBigInteger.addR(b: TBigInteger): TBigInteger;
var
   tmp: TBigInteger;
begin
   tmp := copy()^;
   tmp.add(tmp,b);
   result := tmp.copy()^;
end;

function TBigInteger.subR(b: TBigInteger): TBigInteger;
var
   tmp: TBigInteger;
begin
   tmp := copy()^;
   tmp.sub(tmp,b);
   result := tmp.copy()^;
end;

function TBigInteger.shlR(n: Integer): TBigInteger;
var
   tmp :TBigInteger;
begin
   tmp := copy()^;
   tmp.shiftleft(n);
   result := tmp.copy()^;
end;

function TBigInteger.shrR(n: Integer): TBigInteger;
var
   tmp: TBigInteger;
begin
   tmp := copy()^;
   tmp.shiftright(n);
   result := tmp.copy()^;
end;

function TBigInteger.copy : PBigInteger;
begin
   new(Result,BigInteger(BigIntegerToStr()));
end;

(*
function TBigInteger.copy:TBigInteger;
var
   r : PBigInteger;
begin
     //r.BigInteger(BigIntegerToStr());
   new(r,BigInteger(BigIntegerToStr()));
   result := r^;
end;
*)

dann bekomme ich eine "Zugriffsverletzung auf die Adresse xyz"

[hoika]

Hallo,

warum benutzt du nicht die normale Art, Objekte zu erzeugen.

Delphi-Quellcode:

function TBigInteger.Copy: TBigInteger;
var
  CopyClass: TBigInteger;
begin
  CopyClass:= TBigInteger.Create;
 // Daten zuweisen
  Result:= CopyClass;
end;

Heiko

[Apollonius]

Schau dir mal Beitrag 3 an. Es geht um Objects, nicht Classes.