Interner Fehler C1537 - result Fehler???

[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.