For Next Schleife mit Array

[rolaf]

Als Workaround für Ganzzahlen und maximal Integer als Step-Wert schlage ich mal einfach das hier vor:

Code: Alles auswählen

Dim Reihe.i(1)

#MAX_RECURSION = 10

Macro ForEx(Var, startValue, endValue, stepValue = 1)
	CompilerIf Defined(FOR_EX_STEP_VALUE, #PB_Array) = #False
		Global Dim FOR_EX_STEP_VALUE.i(#MAX_RECURSION)
		Global FOR_EX_STEP_VALUE_RECURSION = 0
	CompilerEndIf
	Var = startValue
	FOR_EX_STEP_VALUE(FOR_EX_STEP_VALUE_RECURSION) = stepValue
	FOR_EX_STEP_VALUE_RECURSION + 1
	While (Var <= endValue)
EndMacro

Macro NextEx(Var)
	Var + FOR_EX_STEP_VALUE(FOR_EX_STEP_VALUE_RECURSION - 1)
	Wend
	FOR_EX_STEP_VALUE_RECURSION - 1
EndMacro

ForEx(Reihe(0), 1, 10)
	ForEx(Reihe(1), 1, 10)
		Debug Str(Reihe(0)) + ", " + Str(Reihe(1))
	NextEx(Reihe(1))
NextEx(Reihe(0))

Hey NicTheQuick, klasse dein Workaround.

[NicTheQuick]

@NicTheQuick
Wenn Du schon hier liest, hättest Du die Bugs aber auch gleich melden können
Solange ich meine Lieblingsprogrammiersprache nicht pjurbesic sondern purebasic mit langem e ausspreche,
bin ich dafür nicht geeignet

Hm...
Na gut. Dann mache ich das gleich mal zu Hause. War eben noch wo anders, wo ich nicht mehr viel Zeit hatte, und jetzt sitze ich gerade im Zug. Ich versuch's später mal mit meinem Bröckchenenglisch.

[STARGÅTE]

Der Grund warum eine Quad unter x86 nicht erlaubt ist, ist der, dass eine Quad nicht in einen Register passen würde.
Einfache Schleifen werden vom Compiler aber meist so optimiert, dass die Laufvariable immer im Register bleibt, damit es schneller läuft.

[Nino]

Der Grund warum eine Quad unter x86 nicht erlaubt ist, ist der, dass eine Quad nicht in einen Register passen würde.
Einfache Schleifen werden vom Compiler aber meist so optimiert, dass die Laufvariable immer im Register bleibt, damit es schneller läuft.

Das ist keine Begründung. Wenn ich eine Integervariable als Zählvariable einer For/Next-Schleife verwende, ist's ja schön wenn der Compiler das optimiert. Aber wenn ich eine Quadvariable benutzen möchte, ist das meine Entscheidung. Wenn der Compiler das nicht optimieren kann, soll er's halt langsamer umsetzen. Aber die Schlussfolgerung: "Das kann ich nicht optimieren, also erlaube ich es gar nicht." ist unlogisch und für eine Hochsprache unangebracht. In einer While/Wend-Schleife kann man ja auch Quads (und sogar Floating-Point-Variablen) benutzen.
Das Problem scheint mir eher zu sein, dass die For/Next-Schleife in PureBasic primitiv implementiert ist (z.B. kann für 'Step' ja auch nur eine Konstante, und keine Variable angegeben werden).

Grüße, Nino

[ts-soft]

Die For Next Schleife hat als einzige Besonderheit, das sie nur Integer unterstützt und das
nach dem Next, der Wert 1 höher ist, als das Schleifenende. Durch diese Einfachheit, hat
sie auch den Vorteil der Geschwindigkeit. Für alle anderen Schleifenkonstrukte ist sie nicht
gedacht und dafür gibt es While : Wend und Repeat : Until!
Die For Next Schleife wäre überflüssig, wenn sie anders implementiert wäre, da alle Vorteile
unter den Tisch fallen.
Warum also sollte man das einbauen? Nur weil es geht?

For Next ist eine Zählschleife, da werden nur ganze Äppel gezählt und nicht die angebissenen

Gruß
Thomas

[Danilo]

Quads für For-Schleifen wurde schon gewünscht: Feature Requests and Wishlists - For and quads,
also einfach abwarten und alt werden.


EDIT:
Habe den For..Next Fehler von rolaf gemeldet: Compiler crash - For..Next with Array variable
(Kleinstmöglicher Code + "Compiler crash" hättest Du doch auch posten können, rolaf!?)

[rolaf]

Habe den For..Next Fehler von rolaf gemeldet: Compiler crash - For..Next with Array variable
(Kleinstmöglicher Code + "Compiler crash" hättest Du doch auch posten können, rolaf!?)

Danke und Nö.

[7x7]

Der Grund warum eine Quad unter x86 nicht erlaubt ist, ist der, dass eine Quad nicht in einen Register passen würde.
Einfache Schleifen werden vom Compiler aber meist so optimiert, dass die Laufvariable immer im Register bleibt, damit es schneller läuft.

Von solch einer Optimierung macht PureBasic aber keinen Gebrauch. Das ist generell auch nicht zu erwarten, da die Anzahl der Register sehr begrenzt sind und - compilertechnisch gesehen - alle Register immer wieder zur Abarbeitung des nächsten Befehls zur Verfügung stehen müssen.

Eine solche Optimierung wäre nur in sehr kleinen For/Next-Schleifen vorstellbar. Mit "klein" meine ich einen kleinen Schleifenkörper ohne komplexe Befehle, wo der Compiler vorher prüfen könnte, ob ein bestimmtes Register reserviert werden kann oder nicht. Eine solche Prüfung halte ich aber im Verhältnis zum erwartenden Ergebnis (meist "fail") für sinnlos.

[ts-soft]

Von solch einer Optimierung macht PureBasic aber keinen Gebrauch.

So so

/edit
Den Fehler in der dt. Hilfe hab ich jetzt hier: http://www.purebasic.fr/german/viewtopi ... 30#p298530 gemeldet.

[CSHW89]

Von solch einer Optimierung macht PureBasic aber keinen Gebrauch.

So so

Das dachte ich eigentlich auch. Allerdings muss ich da 7x7 recht geben:

Code: Alles auswählen

; For i = 0 To 9
  MOV    dword [v_i],0
_For1:
  MOV    eax,9
  CMP    eax,dword [v_i]
  JL    _Next2
; a(i) = i
  PUSH   dword [v_i]
  MOV    ebx,dword [v_i]
  MOV    ebp,dword [a_a]
  SAL    ebx,2
  POP    dword [ebp+ebx]
; Next
_NextContinue2:
  INC    dword [v_i]
  JNO   _For1
_Next2:
; ================================
; i = 0
  MOV    dword [v_i],0
; While (9 >= i)
_While3:
  MOV    ebx,dword [v_i]
  CMP    ebx,9
  JG    _Wend3
; a(i) = i
  PUSH   dword [v_i]
  MOV    ebx,dword [v_i]
  MOV    ebp,dword [a_a]
  SAL    ebx,2
  POP    dword [ebp+ebx]
; i + 1
  INC    dword [v_i]
; Wend
  JMP   _While3
_Wend3:

For und While resultieren zum selben Code, außer dass die Grenzenprüfung andersrum ist. Aber die Zählvariable wird in keinem Register gespeichert.

lg Kevin