"harter"-Tab im PB-Editor

[7x7]

Angeregt durch diesen Thread Befehl über mehrere Zeilen würde mich interessieren, ob es einen ähnlichen "Workaround" gibt, der verhindert, dass die Formatierfunktion im Editor mir bestimmte Code-Strukturen zerstört.

Ich möchte, dass mir eine -wie z.B.untenstehende- Assembler-Strukture nicht wieder an den Rand gesetzt wird. Ich bräuchte also so etwas wie einen "harten" Tab. Weiss da jemand ein Lösung dazu?

Code: Alles auswählen

;If adresse(weg)\z[1] > adresse(index(CoIdx))\z[1]
MOV eax,dword[p_y]
MOV ebx,dword[p_z]
MOV ecx,dword[eax]			;alter Weg
CMP ecx,dword[ebx]			;neuer Weg
JLE  @f						 

	 ;If k1(adresse(weg)\z[1]-1)<#MaxCount: Goto weiter2: EndIf
	 DEC  ecx					;adresse(weg)\z[1] -1
	 SAL  ecx,2
	 ADD  ecx,dword[a_K1]
	 CMP  dword[ecx],#MaxCount	;vorherige 1.Para zu selten?
	 JL   l_weiter2
!@@:


;--------
MaxCheck:
MOV  ecx,dword[a_K1]
CMP  dword[ecx+9*4],5	;Grenzwert Loc1
JNZ @f	

	 ;If adresse(weg)\z[2]=9: weg=Sprung2(weg): Goto weiter4: EndIf
	 MOV  eax,dword[p_y]		;@adresse(weg)\z[1]
	 CMP  dword[eax+4],9		; adresse(weg)\z[2]
	 JNZ  @f

		   MOV  ebx,dword[v_weg]
		   MOV  eax,dword[a_Sprung2]
		   SAL  ebx,2
		   MOV  eax,[eax+ebx]
		   MOV  dword[v_weg],eax
		   JMP  l_weiter4
!@@:

[Kiffi]

nicht wirklich das, was Du suchst, aber ich würde es als
externe PBI auslagern und mit IncludeFile() einbinden.

Grüße ... Kiffi

[Danilo]

So sollte es gehen, auch wenn es umständlich ist:

Code: Alles auswählen

;If adresse(weg)\z[1] > adresse(index(CoIdx))\z[1]
MOV eax,dword[p_y]
MOV ebx,dword[p_z]
MOV ecx,dword[eax]         ;alter Weg
CMP ecx,dword[ebx]         ;neuer Weg
JLE  @f                  
CompilerIf 1
    ;If k1(adresse(weg)\z[1]-1)<#MaxCount: Goto weiter2: EndIf
    DEC  ecx               ;adresse(weg)\z[1] -1
    SAL  ecx,2
    ADD  ecx,dword[a_K1]
    CMP  dword[ecx],#MaxCount   ;vorherige 1.Para zu selten?
    JL   l_weiter2
CompilerEndIf
!@@:


;--------
MaxCheck:
MOV  ecx,dword[a_K1]
CMP  dword[ecx+9*4],5   ;Grenzwert Loc1
JNZ @f   
CompilerIf 1
    ;If adresse(weg)\z[2]=9: weg=Sprung2(weg): Goto weiter4: EndIf
    MOV  eax,dword[p_y]      ;@adresse(weg)\z[1]
    CMP  dword[eax+4],9      ; adresse(weg)\z[2]
    JNZ  @f
    CompilerIf 1
        MOV  ebx,dword[v_weg]
        MOV  eax,dword[a_Sprung2]
        SAL  ebx,2
        MOV  eax,[eax+ebx]
        MOV  dword[v_weg],eax
        JMP  l_weiter4
    CompilerEndIf
CompilerEndIf
!@@:

Statt "CompilerIf 1" + "CompilerEndIf" solltest Du auch eigene, leere Macros nehmen können, z.B.:

Code: Alles auswählen

Macro Block    : : EndMacro
Macro EndBlock : : EndMacro

Dann diese 2 (eindeutigen) Namen in den IDE-Preferences bei -> "Indentation" zu den Schlüsselwörtern hinzufügen.

[STARGÅTE]

Ich möchte, dass mir eine -wie z.B.untenstehende- Assembler-Strukture nicht wieder an den Rand gesetzt wird.

Naja, von alleiner setzt sich der Code nicht wieder an den Rand, du musst ja dann irgendwas gedrückt haben?
Wenn du alles markiert hast und dann "auto-Increment" gedrückt hast, klar ...

Du kannst aber auch die ASM-Einrückung definieren.

Code: Alles auswählen

Schlüsselwort   Vor   Nach
 JLE             0     1
 !@@:           -1     0

Oder du definierst ein allgemeines Einrücken für ;{ ... ;} bereiche, dann würde dein Code so aussehen:

Code: Alles auswählen

Schlüsselwort   Vor   Nach
 ;{              0     1
 ;}             -1     0

Code: Alles auswählen

;If adresse(weg)\z[1] > adresse(index(CoIdx))\z[1]
MOV eax,dword[p_y]
MOV ebx,dword[p_z]
MOV ecx,dword[eax]         ;alter Weg
CMP ecx,dword[ebx]         ;neuer Weg
JLE  @f ;{                   

    ;If k1(adresse(weg)\z[1]-1)<#MaxCount: Goto weiter2: EndIf
    DEC  ecx               ;adresse(weg)\z[1] -1
    SAL  ecx,2
    ADD  ecx,dword[a_K1]
    CMP  dword[ecx],#MaxCount   ;vorherige 1.Para zu selten?
    JL   l_weiter2
!@@: ;}

[7x7]

Danke für die Vorschläge!

Habe mich für folgendes entschieden:

Code: Alles auswählen

Schlüsselwort   Vor   Nach
 ;+              1     0
 ;-              0    -1

Finde ich logisch und gut "lesbar", weil es am unauffälligsten wirkt!

Code: Alles auswählen

;If adresse(weg)\z[1] > adresse(index(CoIdx))\z[1]
MOV eax,dword[p_y]
MOV ebx,dword[p_z]
MOV ecx,dword[eax]         ;alter Weg
CMP ecx,dword[ebx]         ;neuer Weg
JLE  @f                  

    ;+
    ;If k1(adresse(weg)\z[1]-1)<#MaxCount: Goto weiter2: EndIf
    DEC  ecx               ;adresse(weg)\z[1] -1
    SAL  ecx,2
    ADD  ecx,dword[a_K1]
    CMP  dword[ecx],#MaxCount   ;vorherige 1.Para zu selten?
    JL   l_weiter2
    ;-
!@@:


; --------
MaxCheck:
MOV  ecx,dword[a_K1]
CMP  dword[ecx+9*4],5   ;Grenzwert Loc1
JNZ @f 
  
    ;+
    ;If adresse(weg)\z[2]=9: weg=Sprung2(weg): Goto weiter4: EndIf
    MOV  eax,dword[p_y]      ;@adresse(weg)\z[1]
    CMP  dword[eax+4],9      ; adresse(weg)\z[2]
    JNZ  @f

         ;+
         MOV  ebx,dword[v_weg]
         MOV  eax,dword[a_Sprung2]
         SAL  ebx,2
         MOV  eax,[eax+ebx]
         MOV  dword[v_weg],eax
         JMP  l_weiter4
         ;-
     ;-
!@@:

Dennoch würde ich die Möglichkeit eines "harten"-Tabs vorziehen. Vielleicht denkt einer der PB-Entwickler mal darüber nach, ob man evtl. ein [Shift]+[Tab] für sowas einbauen könnte.

[bobobo]

sowas kannste Du nahezu selber bauen.

Ich kenn zwar keinen "harten"Tab
aber ein "hartes"Leerzeichen
chr(160) .. kann man einfach mit gedrückter Alt-Taste und 160
auf dem Tastaturblock eingeben.
Dieses Zeichen wird vom pb-Kompiler allerdings als ungültig erkannt
und muss vor dem Kompilieren rausgenommen werden.
Aber dafür kannst Du Dir relativ flott was basteln was den aktuellen
Quelltext entsprechend vorbehandelt und als tool in der IDE
"vor dem Kompilieren/Starten" mit Parameter %COMPILEFILE
und Flag "warten bis zum Beenden" integriert wird.

ich habe da mal was vorbereitet

Code: Alles auswählen

fi.s=ProgramParameter(0)
If ReadFile(0,fi)
  While Eof(0)=0
    fu.s=ReadString(0)
    While Left(fu,1)=Chr(160)
      fu=Mid(fu,2,Len(fu)-1)
    Wend
    fo.s+fu+#CRLF$
  Wend
  CloseFile(0)
  CreateFile(0,fi)
  WriteStringN(0,fo)
  CloseFile(0)
EndIf

 

[7x7]

@bobobo
Diesen Weg halte ich nicht für so praktikabel. Bei tieferen Einrückungen könnte man damit schon sehr beschäftigt werden.
Dein Vorschlag bringt mich aber auf eine andere Idee, die ausserhalb dieses Themas liegt.