Perseus 2.6 - Caffeinated Cat

Zitat von Njahs

Spoiler anzeigen

[Blockierte Grafik: http://i.epvpimg.com/AsZTb.png]

Hm ja, da freue ich mich schon und es funktioniert nicht

Was habe ich falsche gemacht? Windows 7 64 Bit.

Grüße Njahs

Habe auch Win7 64bit, anscheinend funkt dein Virenscanner dazwischen.
Nachdem ich meinen gesamten Perseus-Ordner als Ausnahme bei avast hinzugefügt habe, ist alles wie am Schnürchen gelaufen.
Kannst ja auch mal testweise dein AV aussschalten und nochmal probieren, wenns dann funktioniert, weißt ja worans liegt

Bei mir funktioniert auch alles auf Win7 x64. Liegt also vermutlich nicht an einer falschen FASM version

Noch was: Ich hab jetzt eine new und free Funktion geschrieben, die dynamsichen nicht lokalen Speicher im Prozessheap alloziiert.
Das war eines der wichtigsten fehlenden Sachen. Jetzt kann man auch mit richtigen Strings loslegen. Aufgrund dessen hab ich auch nochmal die GetStringvarianten geändert, damit da nicht ein unnötiger String Platz in der exe verbraucht wird:

int GetProcessHeap() external KERNEL32;
void @HeapAlloc(int heap; int flags; word bytes) external KERNEL32;
word HeapFree(int heap; int flags; void @ptr) external KERNEL32;
void @HeapReAlloc(int heap; int flags; void @ptr; word newsize) external KERNEL32;






void @new(word bytes)
	return @HeapAlloc(GetProcessHeap(),0,bytes);
end


void @renew(void @ptr; word bytes)
	return @HeapReAlloc(GetProcessHeap(),0,@ptr,bytes);
end


void free(void @ptr)
	HeapFree(GetProcessHeap(),0,@ptr);
end






word StringIsAlpha(char Ch)
   if ('A' <= Ch & Ch <= 'Z') | ('A' <= Ch & Ch <= 'Z') | (Ch = '_') then
      return 0;
   end

   return 1;
end


word CharIsDigit(char Ch)
   if ('0' <= Ch & Ch <= '9') | (Ch = '$') then
      return 0;
   end


   return 1;
end


word StringLength(char @St)
   word P = 0;
   while St[P] != #0 do
      inc P;
   end


   return P;
end


word StringCompare(char @St1, @St2)
   word P = 0;
   while St1[P] = St2[P] do
      if St1[P] = #0 then
         return 0;
      end
      inc P;
   end


   return 1;
end


char @StringCopy(char @Dst, @Src)
   word P = 0;
   while Src[P] != #0 do
      Dst[P] = Src[P];
      inc P;
   end
   Dst[P] = #0;


   return @Dst;
end


char @StringJoin(char @Dst, @Src)
   StringCopy(@Dst[StringLength(@Dst)], @Src);
   return @Dst;
end




char @_GetStringEx(word N; byte signed; word P; void @buffer, @digit)
	asm mov eax,[ebp+8];
	asm mov ecx,[ebp+12];
	asm mov ebx,[ebp+16];
	asm mov edi,[ebp+20];
	asm mov esi,[ebp+24];

	asm xor edx,edx;
	asm cmp ecx,0;
	asm je @f;
	asm test eax,0x80000000;
	asm cmove ecx,edx;
	asm jz @f;
	asm mov byte[edi],'-';
	asm inc edi;
	asm neg eax;
	asm @@:;

	asm xor ecx,ecx;
	asm .loop1:;
	asm div ebx;
	asm push edx;
	asm inc ecx;
	asm xor edx,edx;
	asm cmp eax,0;
	asm jne .loop1;

	asm .loop2:;
	asm pop ebx;
	asm mov al,[esi+ebx];
	asm stosb;
	asm loop .loop2;
	asm xor al,al;
	asm stosb;

	return @buffer;
end


char @GetStringEx(word N; byte signed; word P)
	char @buffer = @new(12);
	char @digit = "0123456789ABCDEF";
	return @_GetStringEx(N,signed,P,@buffer,@digit);
end




char @GetString(word N)
   return @GetStringEx(N,1,10);
end




char @GetStringUnsigned(word N)
	return @GetStringEx(N,0,10);
end

Was stört ist, dass word 4 Byte sind. Wenn man etwas auf 2 Byte limitieren möchte oder in einem Array 2 Byte (=Word) breite Elemente hat, muss man das mit ASM machen oder dauernd mittels bitwise AND die vorderen 2 byte wegstreichen.. wofür gibts word, wenn es das gleiche wie int ist..

PS: Ich denke ich werde auch noch ne ordentliche string-Klasse machen, wenns geht.

Zitat von TheShadowAE

ganze funcLib

Code

int GetProcessHeap() external KERNEL32;
void @HeapAlloc(int heap; int flags; word bytes) external KERNEL32;
word HeapFree(int heap; int flags; void @ptr) external KERNEL32;
void @HeapReAlloc(int heap; int flags; void @ptr; word newsize) external KERNEL32;






void @new(word bytes)
	return @HeapAlloc(GetProcessHeap(),0,bytes);
end


void @renew(void @ptr; word bytes)
	return @HeapReAlloc(GetProcessHeap(),0,@ptr,bytes);
end


void free(void @ptr)
	HeapFree(GetProcessHeap(),0,@ptr);
end






word StringIsAlpha(char Ch)
   if ('A' <= Ch & Ch <= 'Z') | ('A' <= Ch & Ch <= 'Z') | (Ch = '_') then
      return 0;
   end

   return 1;
end


word CharIsDigit(char Ch)
   if ('0' <= Ch & Ch <= '9') | (Ch = '$') then
      return 0;
   end


   return 1;
end


word StringLength(char @St)
   word P = 0;
   while St[P] != #0 do
      inc P;
   end


   return P;
end


word StringCompare(char @St1, @St2)
   word P = 0;
   while St1[P] = St2[P] do
      if St1[P] = #0 then
         return 0;
      end
      inc P;
   end


   return 1;
end


char @StringCopy(char @Dst, @Src)
   word P = 0;
   while Src[P] != #0 do
      Dst[P] = Src[P];
      inc P;
   end
   Dst[P] = #0;


   return @Dst;
end


char @StringJoin(char @Dst, @Src)
   StringCopy(@Dst[StringLength(@Dst)], @Src);
   return @Dst;
end


[...]

Alles anzeigen

Ich empfehle, die Funktionen für StringCopy, StringCompare, etc nicht selber zu schreiben, sondern das kompilierte Programm gegen eine crt0-Implementierung zu linken. crt0 ist die Standardlibrary von C und enthält u.A. hochoptimierte Versionen für strcpy und außerdem malloc, das manchmal etwas effektiver ist, als HeadAlloc, etc.

strcpy etc sind in der Lib (genauso wie in der Funclib) sehr anfällig für Buffer Overflow etc. Ich schreib deswegen alles gerade neu. Ebenfalls hochoptimiert natürlich Das Linken ist in der Sprache einfach nicht vorgesehen und das ist finde ich das beste an der Sprache. Ich sehe alles im ASM-code. Die gesamte Exe wird assembliert und fertig ist es.
Das gibt auch kleiner Enddateien

PS:
Sowas wie StringInStr ist in der Lib glaub ich auch nicht oder?

EDIT:
Es gibt tatsächlich doch strstr^^

Hi,

Zitat

crt0 ist die Standardlibrary von C und enthält u.A. hochoptimierte Versionen für strcpy

ehrlich gesagt, dachte ich auch einmal so....

Aber schau mal hier(es geht um die Prozessorbefehle movsb und stosb), wenn du diesen Artikel nicht lesen kannst, renn mal schnell ins nächste Schreibwarengeschäft und lese dir die 2 Seiten in der c´t zu diesem Thema durch....Nur dieser Artikel ist den Preis für das Heft wert!
Da ist ein Sch*** optimiert, gerade im Gegenteil, die Compiler tun alles dafür, eine KORREKTE Antwort auf den Aufruf von memcpy() und strcpy() zu gewährleisten!
Die bisher gefertigten Prozessoren sind nämlich alles andere als fehlerfrei und somit müssen die Compiler "hunderte von Fallunterscheidungen" einbauen, um je nach Prozessor die Bugs zu fixen.
Was dazu führt, dass in den meisten Fällen die Antworten auf die o.g. Befehle zwar immer öfter korrekt ausgeführt werden, aber leider mit dem Handicap von massiv aufgeblähtem Code und langsamer Verarbeitung

Hi,
bitte, wie schon einmal angesprochen, die benötigten Files "unkomprimiert" (wegen mir in einer "Special-Edition" ) zur Verfügung stellen.
1. ist es suboptimal, Virenscanner "umzubiegen" damit fremde Exe´n keine "Fehlalarme" verursachen ("Alda, da is kein Virus oder Backdoor drin, ISCH SCHWÖR")
2. ist die FASM.dll von Haus aus nicht gepackt
Installer wäre nett, da gibt es eine Scriptsprache für....moment mal, gleich hab ichs...AutoIt

Sehr schön, das Update
Ich weiß zwar nicht mehr, was es alles für kleine Bugs gab, aber soweit ich das bis jetzt beurteilen kann gibt es die nicht mehr alle

Alles was ich bis jetzt zu meckern gefunden hab:
- Es ist keine Addition auf Pointer möglich!
- renew, free, stringui fehlen in der coreLib (oder wie heißen die?).
- Ich hätte die coreLib lieber im Ordner (sichtbar), damit ich gucken kann, welcher Funktionen es gibt, wie sie funktionieren und damit man etwas hinzufügen kann o.ä. wie man will. Die /c0 Option ist allerdings schonmal gut, so kann ich die immerhin die alte funcLib von mir benutzen um "free" etc. zu haben.
- ein Include-Hauptverzeichnis wär super. Dann muss man nicht immer den ganzen (relativen) Pfad zur funcLib etc. angeben.

Hi,
ich weiss nicht, ob mein "Problem" überhaupt hier hin gehört.
Beim Testen des OpenGl-Beispiels ist mir aufgefallen, dass alle 6 Cores meiner CPU auf Höchstleistung laufen?!
Daraufhin habe ich andere AutoIt-OpenGl-Beispiele ausprobiert und dort dieses Phänomen auch festgestellt.
Ist das bei euch auch so und an was liegt das?
System Win7-64
FX-6300
Radeon 7790
Catalyst-Treiber 13.12
OpenGL-Version 6.14.10.12618