C-Code in VB.NET umwandeln

[N. N. (drnicolas)]

Ich will eine in C vorhandene Funktion in VB.NET umwandeln

static byte calc_new_checksum(size_t nbytes)
{
    byte cksum=0;
  byte p =0;
  while(nbytes-- > 0)
    cksum += p;
  cksum = -cksum;
  return cksum;
}
Den Code habe ich nach zahllosen Versuchen automatisch inn VB.NET 
übersetzen lassen.
Wenn ich das probiere, dann bekomme ich Überlauffehler.
Wie kriege ich das hin.
Mein Probelm liegt wahrscheinlich schon darin, dass meine Quelldaten in 
einem Byte-Array liegen und nicht vorzeichenbehaftet sind.

[Rufus Τ. F. (rufus)]

N. N. schrieb:
> Den Code habe ich nach zahllosen Versuchen automatisch inn VB.NET
> übersetzen lassen.
> Wenn ich das probiere, dann bekomme ich Überlauffehler.

Zeig' Deinen Vb.net-Code.

[Dirk B. (dirkb2)]

Da kannst du auch gleich ein 0 zurück geben (oder zuweisen)

N. N. schrieb:
> Mein Probelm liegt wahrscheinlich schon darin, dass meine Quelldaten in
> einem Byte-Array liegen und nicht vorzeichenbehaftet sind.

Wo ist das denn?

[Framulestigo (Gast)]

Hab ich's jetzt an den Augen?
Oder summiert der C-Code nicht einfach nur nullen n-mal auf?

[N. N. (drnicolas)]

Sehr richtig bemerkt. Sorry, ich hatte den Originalcode schon wg. 
Fehlermeldungen des Übersetzers versucht zu vereinfachen.

static byte calc_new_checksum(const void* pBytes,size_t nbytes)
{
  assert(pBytes && nbytes > 0);
  byte cksum=0;
  const byte* p = reinterpret_cast<const byte*>(pBytes);
  while(nbytes-- > 0)
    cksum += *p++;
  cksum = -cksum;
  return cksum;
}

[Nullator (Gast)]

...
return 0;

[Nullator (Gast)]

// Sorry, war zu spät.

[c-hater (Gast)]

N. N. schrieb:

> Ich will eine in C vorhandene Funktion in VB.NET umwandeln
>
> static byte calc_new_checksum(size_t nbytes)
> {
>     byte cksum=0;
>   byte p =0;
>   while(nbytes-- > 0)
>     cksum += p;
>   cksum = -cksum;
>   return cksum;
> }

Diese Funktion ergibt nicht wirklich irgendeinen Sinn. So, wie sie da 
steht, hätte man auch genausogut schreiben können:

> static byte calc_new_checksum(size_t nbytes)
> {
>   return 0;
> }

Und weil das so ist, würde ein korrekte Umsetzung (selbst eine doofe 
automatisierte) nach VB.net keine Problem mit einem Überlauf bekommen...

[cppbert3 (Gast)]

Addiere alle bytes in deinem array in einem byte (welches wohl 
ueberlaeuft) und liefert das Ergebnis negativ zurueck - portieren 
brauchst du da nicht viel

[Dirk B. (dirkb2)]

N. N. schrieb:
> Sorry, ich hatte den Originalcode schon wg.
> Fehlermeldungen des Übersetzers versucht zu vereinfachen.

In C++ gibt es da nicht so viel, was man weglassen kann.

Addiere den Inhalt deines Datem-Arrays auf.
Danach bildest du den negative Wert davon.

Wie ist byte bei dir definiert (typedef)
(irgendwas mit signed char  ???)

[N. N. (drnicolas)]

Das stammt aus einem readme.txt:

"
All binary data records are checksummed and the single byte checksum is
appended following each record. The checksum is a simple XOR of every 
byte of
the data record for firmware versions before 3.00, and the negative of a
simple sum of every byte of the data record for firmware versions after 
3.00.

See calc_old_checksum and calc_new_checksum() functions

"
Wenn ich alle Bytes addiere, dann kann auf jeden Fall eine Summe >255 
rauskommen, oder ?
Ich bin mir weder sicher wie lang dieser Header ist, noch ob ich 
vielleicht doch die sog. "old_checksum" benötige

[N. N. (drnicolas)]

Hier wird eine Menge #included:
#include <tchar.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <minmax.h>

#include <assert.h>

#include <io.h>
#include <fcntl.h>
#include <time.h>

#include <sys/types.h>
#include <sys/stat.h>

[c-hater (Gast)]

cppbert3 schrieb:

> Addiere alle bytes in deinem array in einem byte (welches wohl
> ueberlaeuft) und liefert das Ergebnis negativ zurueck - portieren
> brauchst du da nicht viel

Doch, natürlich. VB.net kennt nämlich leider keine Möglichkeit, die 
Überlaufprüfungen zu deaktivieren. In C# wäre das einfacher, da könnte 
man den Code fast 1:1 übernehmen und müßte ihn nur noch in ein

unchecked
{
 ...
}

verfrachten.

In VB kann man das leider nur dadurch lösen, dass man mit einem 
breiteren Datentypen operiert und sachgerecht maskiert.

Kein Ahnung, warum Winzigweich nicht auch VB.net so ein nettes 
Schlüsselwort gegönnt hat...

[Nullator (Gast)]

N. N. schrieb:
> Wenn ich alle Bytes addiere, dann kann auf jeden Fall eine Summe >255
> rauskommen, oder ?

Das wird wohl nicht klappen (Überlauf).
Ich habe keine Ahnung von VB.NET, vermute aber mal, dass man in den 
Compileroptionen so etwas wie Checks auf Overflow/Underflow findet und 
entsprechend deaktivieren kann (wenn man es denn "genau so" wie im 
gezeigten Code machen will). Wenn du nicht den Überlauf "ausnutzen" 
willst, überlege dir mal, was du stattdessen tun könntest (Tipp: 
Nachsehen, ob der neue Wert noch in cksum passt; auf den Rest kommst 
selbst).

[Nullator (Gast)]

Gilt dann aber natürlich für das ganze Projekt.

[Framulestigo (Gast)]

Ist zwar schon über 10 Jahre her mit VB, aber als Ansatz (!Ohne Dein 
"reinterpret_cast"):

Shared Function Chksum(ByRef array As Byte(), ByVal len As Integer) As Byte
        Dim i As Integer, result As Integer = 0

        For i = len - 1 To 0 Step -1
            result = -result + array(i)
            result = result And &HFF
        Next
        Return result
    End Function

[Horst (Gast)]

N. N. schrieb:
> Ich will eine in C vorhandene Funktion in VB.NET umwandeln

Jetzt mal ernsthaft? Wie kommt man auf so eine kranke Idee?

[c-hater (Gast)]

Horst schrieb:
> N. N. schrieb:
>> Ich will eine in C vorhandene Funktion in VB.NET umwandeln
>
> Jetzt mal ernsthaft? Wie kommt man auf so eine kranke Idee?

Ich finde, schon die Tatsache, C einfach nicht zu mögen, wäre ein 
absolut hinreichender Grund...

[N. N. (drnicolas)]

Das wird es wohl am ehesten sein. Ich habe nun mal wesentlich mehr 
Erfahrung mit VB als mit C. Da schien es mir mit VB.NET einfacher.

Es geht letztlich darum, eine alte Opern-Source-Software 
nachzuvollziehen und die inzwischen in der Firmware verwirklichten 
Features zu nutzen.