XProfan

Michael
W.

Machbarkeits-Studie, no getestet


Proc MakeNumArr
    If Between(%pcount,3,5)
        Parámetros AnzX%,AnzY%,Size%,Rand%,Abst%
        Var posx% = Rand%
        Var PosY% = Rand%
        Declarar Valor$

        WhileLoop 0,AnzX% * AnzY% - 1
            Valor$ = Valor$ + Str$(posx%) + "|" + Str$(posy%) + "|"
            Inc Posx%, (size% + Abst%)

            Caso negativo (&Loop + 1) Mod (AnzX%)
                Posx% = Rand%
                Inc posy%,size% + Abst%
                Valor$ = Del$(Valor$,Len(Valor$),1)
                Valor$ = Valor$ + "\n"
            EndIf
        Wend

        Valor$ = Del$(Valor$,Len(Valor$),1)
        Volver Valor$

    ElseIf %pcount = 6

        Parámetros AnzX%,AnzY%,Size%,Rand%,Abst%
        Declarar tmp%,Arr&[]
        Var posx% = Rand%
        Var PosY% = Rand%

        WhileLoop 0,AnzX% * AnzY% - 1
            Arr&[&Loop * 2] = PosX%
            Arr&[(&Loop * 2) + 1] = PosY%
            Inc Posx%, (size% + Abst%)

            Caso negativo (&Loop + 1) Mod (AnzX%)
                Posx% = Rand%
                Inc posy%,size% + Abst%
            EndIf

        Wend
        Volver Arr&[]

    Más
        Volver "Fehler!"
    EndIf

ENDPROC

Declarar Test&[]
Imprimir MakeNumArr(4,3,96,4,10)
Test&[] = MakeNumArr(4,3,96,4,10,1)
Imprimir

WhileLoop 0,SizeOf(Test&[])-1
    Imprimir Test&[&Loop],
Wend

WaitInput
End


El erste Abfrage lautet en 3 a 5 Parámetro, entonces folgt aber Parámetros con 5 Parametern.
El zweite Abfrage esperado 6 Parámetro, es aber auch hier Parámetros con 5 Parametern angegeben.
Das erschließt se No.
Auf el 2. Blick son el 2 verschiedene Características. Also jede para se behandeln. String y ASM es frickelig.

Proc MakeNumArr_alt
        Parámetros AnzX%,AnzY%,Size%,Rand%,Abst%
        Declarar tmp%,Arr&[]
        Var posx% = Rand%
        Var PosY% = Rand%

        WhileLoop 0,AnzX% * AnzY% - 1
            Arr&[&Loop * 2] = PosX%
            Arr&[(&Loop * 2) + 1] = PosY%
            Inc Posx%, (size% + Abst%)

            Caso negativo (&Loop + 1) Mod (AnzX%)  'wert mod x; Rest si > X; negiert also: sólo ausführen, solange bajo X
                Posx% = Rand%
                Inc posy%,size% + Abst%
            EndIf

        Wend
        Volver Arr&[]
ENDPROC


Proc MakeNumArr
   Parámetros AnzX%,AnzY%,Size%,Rand%,Abst%
   Declarar Arr&[]

   Var posx% = Rand%
   Var PosY% = Rand%

   var schleifenende% = AnzX% * AnzY% - 1   '- AnzX, AnzY sólo oberhalb el Bucle
   var groesse% = size% + Abst%   '- size + Abst siempre

   var ArrSize = schleifenende% * 2 + 1

   SetSize Arr&[], ArrSize


   ASM,"MakeNumArr_intern",7
      JMP  Start
gr:
      DD   0
ra:
      DD   0
a_x:
      DD   0
x:
      DD   0
y:
      DD   0
Start:
      MOV  EBX, PAR1   'schleifenende% -- EBX
      MOV  EAX, PAR2   'groesse%
      MOV  [gr], EAX
      MOV  EAX, PAR3   'Rand%
      MOV  [ra], EAX

      MOV  EAX, PAR7   'AnzX%
      MOV  [a_x], EAX

      MOV  EAX, PAR4   'adr x
      MOV  [x], EAX
      MOV  EAX, PAR5   'adr y
      MOV  [y], EAX
      MOV  EDI, PAR6   'adr Arr	-- EDI

      XOR  ECX, ECX    '&loop
      DEC  ECX
schleife:
      INC  ECX
      CMP  ECX, EBX    'en schleifenende prüfen
      JA   Ende

      MOV  EDX, ECX
      SHL  EDX, 1	'Loop * 2

      MOV  ESI, [y]
      MOV  EAX, [ESI]
      MOV  [EDI + EDX + 4], EAX   'Arr&[(&Loop * 2) + 1] = PosY%

      MOV  ESI, [x]
      MOV  EAX, [ESI]
      MOV  [EDI + EDX], EAX   'Arr&[&Loop * 2] = PosX%
      MOV  EDX, [gr]
      ADD  EAX, EDX
      MOV  [ESI], EAX	' x + groesse

      XOR  EDX, EDX
      MOV  EAX, ECX
      INC  EAX
      PUSH EBX
      ;-- Mist, AnzX übersehen
      MOV  EBX, [a_x]
      DIV  EBX		'remainder en EDX
      POP  EBX

      CMP  EDX, 0
      JE   schleife   'si IF no ausgeführt voluntad se
                      ' sonst innerhalb des IF
      
      MOV  ESI, [x]
      MOV  EAX, [ra]
      MOV  [ESI], EAX   'Posx% = Rand%
      MOV  ESI, [y]
      MOV  EAX, [gr]
      ADD  [ESI], EAX
      jmp  schleife

Ende:
   ENDASM

   MakeNumArr_intern( schleifenende%, groesse%, Rand%, addr(posx%), addr(PosY%), addr(Arr&[]),  AnzX% )

   Volver Arr&[]
ENDPROC

Wenn el direkte Array-Zugriff no funzt, entonces simplemente incluso Speicher reservieren y anschließend umkopieren.

Hier una vez más el mem.inc - sin Objetos.
El Punkt-Schreibweise Yo beibehalten.


' debería eigentlich de XProfan 10 laufen

$IFNDEF FALSE
$DEFINE FALSE
DEF  %NULL   0
DEF  %FALSE  0
DEF  %TRUE   1
$ENDIF 'FALSE

$IFNDEF MEM_ALLOC
$DEFINE MEM_ALLOC
Declarar MEM_ALLOC_HANDLE1&
Declarar MEM_ALLOC_HANDLE2&
Declarar Mem.Error%

Proc MEM_ALLOC_START
   MEM_ALLOC_HANDLE1& = UseDLL("KERNEL32.DLL")
   MEM_ALLOC_HANDLE2& = UseDLL("ole32.dll")
   ImportFunc( MEM_ALLOC_HANDLE1&, "GetLastError",  "GetLastError" )	// GetLastError( )
   ImportFunc( MEM_ALLOC_HANDLE1&, "GlobalAlloc",   "GlobalAlloc" )	// GlobalAlloc( flags, Size )
   ImportFunc( MEM_ALLOC_HANDLE1&, "GlobalFree",    "GlobalFree" )	// GlobalFree( hMem )
   ImportFunc( MEM_ALLOC_HANDLE1&, "GlobalHandle",  "GlobalHandle" )	// GlobalHandle( pMem )
   ImportFunc( MEM_ALLOC_HANDLE1&, "GlobalLock",    "GlobalLock" )	// GlobalLock( hMem )
   ImportFunc( MEM_ALLOC_HANDLE1&, "GlobalReAlloc", "GlobalReAlloc" )	// GlobalReAlloc( hMem, Size, flags )
   ImportFunc( MEM_ALLOC_HANDLE1&, "GlobalSize",    "GlobalSize" )	// GlobalSize( hMem )
   ImportFunc( MEM_ALLOC_HANDLE1&, "GlobalUnlock",  "GlobalUnlock" )	// GlobalUnlock( hMem )
   ImportFunc( MEM_ALLOC_HANDLE1&, "RtlFillMemory", "FillMemory" )	// FillMemory( pDest, Len, Char )
   ImportFunc( MEM_ALLOC_HANDLE1&, "RtlMoveMemory", "MoveMemory" )	// MoveMemory( pDest, pSrc, Len )  // Überlappung erlaubt; langsam
   ImportFunc( MEM_ALLOC_HANDLE1&, "RtlZeroMemory", "ZeroMemory" )	// ZeroMemory( pDest, Len )
   ImportFunc( MEM_ALLOC_HANDLE2&, "CoTaskMemAlloc", "Ole32_Dim" )	// Ole32_Dim(1)
   ImportFunc( MEM_ALLOC_HANDLE2&, "CoTaskMemRealloc", "Ole32_ReDim" )	// Ole32_ReDim(2)
   ImportFunc( MEM_ALLOC_HANDLE2&, "CoTaskMemFree", "Ole32_Dispose" )	// Ole32_Dispose(1)
ENDPROC

Proc MEM_ALLOC_END
   Case MEM_ALLOC_HANDLE1& : FreeDLL MEM_ALLOC_HANDLE1&
   Case MEM_ALLOC_HANDLE2& : FreeDLL MEM_ALLOC_HANDLE2&
ENDPROC

/*     I  N  H  A  L  T
   Mem.CAlloc( Elemente&, ElementSize& )
      - Speicherblöcke ocupar/reservieren
        Reserviert "Elemente" veces "Elementgröße" Bytes como Speicherplatz y liefert el Speicherzeiger como Rückgabewert (oder 0 en Fehler).
        Der Speicher es ya con Nullen initialisiert.
        Ergebnis: Speicherzeiger oder 0
   Mem.New( Size& )
      - Speicher ocupar/reservieren
        Reserviert "Size" Bytes Speicherplatz y liefert el Speicherzeiger como Rückgabewert (oder 0 en Fehler).
        Der Speicher es ya con Nullen initialisiert.
        Ergebnis: Speicherzeiger oder 0
   Mem.Resize( pMem&, Size& )
      - Speichergröße ändern/redimensionieren
        Ändert el Speichergröße en el el Speicherzeiger zeigt.
        El Größe des angegebenen Speicherbereiches se en el neue Größe geändert (si ungleich).
        En uno Vergrößerung des Bereiches bleiben todos Daten obtener,
        en uno Verkleinerung sólo el vordere Teil. (!!!sin Gewähr!!!)
        Ergebnis: Liefert el neuen Speicherzeiger zurück.
   Mem.Libre( pMem& [,pMem& ...] )
      - Speicher liberación (auch mehrere Bereiche zugleich)
        Gibt el Speicherbereich en el el Speicherzeiger zeigt otra vez frei.
        Lo puede mehrere Parámetro para Editar angegeben voluntad.
        Ergebnis: Größe el freigegebenen Bereiche
   Mem.Claro( pMem& [,pMem& ...] )
      - Speicher con Nullen überschreiben
        Der angegebene (gesamte) Speicherbereich es con binären Nullen überschrieben.
        Für una Teilfüllung es Mem.Fill() a nutzen.
        Lo puede mehrere Parámetro para Editar angegeben voluntad.
        Ergebnis: Anzahl el bearbeiteten Bereiche
   Mem.Fill( pMem& [,Anzahl& [,FüllChars$]] )
      - Speicher con un Signo füllen
        Ist Anzahl = 0 Luego se Anzahl en Mem.Size(pMem) gesetzt.
        Der angegebene Speicherbereich es con Füllzeichen aufgefüllt.
        Ohne Füllzeichen es con Chr$(0) aufgefüllt.
        En una Signo se Kernel32.FillMemory() genutzt
        En más Signo se Kernel32.MoveMemory() genutzt
        Ergebnis: Liefert True, si Speicher gefüllt wurde
   Mem.Move( Ziel&, Quelle& [,Anzahl&] )
      - Speicherinhalte kopieren
        Der angegebene Quellbereich se en el Zielbereich kopiert.
        Ergebnis: Liefert True, si Speicher kopiert wurde
   Mem.Size( pMem& )
      - Größe des belegten Speichers ermitteln
        Ermittelt el Speichergröße en el el Speicherzeiger zeigt.
        Ergebnis: Liefert el Größe des Bereiches zurück.

   Mem.OleNew( Size& )
      - OLE-Speicher ocupar/reservieren
        Reserviert "Size" Bytes Speicherplatz y liefert el Speicherzeiger como Rückgabewert.
        Ist "Size" kleiner como 1, Luego se él en 1 gesetzt.
        Ergebnis: Speicherzeiger
   Mem.OleResize( pMem&, Size& )
      - Speichergröße ändern/redimensionieren
        Ändert el Speichergröße en el el Speicherzeiger zeigt.
        El Größe des angegebenen Speicherbereiches se en el neue Größe geändert.
        En uno Vergrößerung des Bereiches bleiben todos Daten obtener,
        en uno Verkleinerung sólo el vordere Teil. (!!!sin Gewähr!!!)
        Ergebnis: Liefert el neuen Speicherzeiger zurück.
   Mem.OleFree( pMem& [,pMem& ...] )
      - Speicher liberación (auch mehrere Bereiche zugleich)
        Gibt el Speicherbereich en el el Speicherzeiger zeigt otra vez frei.
        Lo puede mehrere Parámetro para Editar angegeben voluntad.
        Ergebnis: Boolean; Freigabe wurde durchgeführt
   Mem.OleClear( pMem&, Size& )
      - Speicher con Nullen überschreiben
        Der angegebene (gesamte) Speicherbereich es con binären Nullen überschrieben.
        Für una Teilfüllung es Mem.Fill() a nutzen.
        Ergebnis: Boolean; Überschreiben con Nullen durchgeführt
   Mem.OleFill( pMem&, Anzahl& [,FüllChars$]] )
      - Speicher con un Signo füllen
        Der angegebene Speicherbereich es con Füllzeichen aufgefüllt.
        Ohne Füllzeichen es con Chr$(0) aufgefüllt.
        En una Signo se Kernel32.FillMemory() genutzt
        En más Signo se Kernel32.MoveMemory() genutzt
        Ergebnis: Liefert True, si Speicher gefüllt wurde
   Mem.OleMove( Ziel&, Quelle&, Anzahl& )
      - Speicherinhalte kopieren
        Der angegebene Quellbereich se en el Zielbereich kopiert.
        Ergebnis: Liefert True, si Speicher kopiert wurde


 Syntax:                    I N H A L T
    Ptr& = Mem.CAlloc( nElem&, elSize& )
    Ptr& = Mem.New( Size& ) 			-- Mem.Dim(), Mem.Malloc()
    Ptr& = Mem.Resize( OldPtr&, NewSize& )	-- Mem.ReDim(), Mem.Realloc()
     sz& = Mem.Libre( [[Ptr1&],...] )		-- Mem.Disponer()
    cnt& = Mem.Claro( [[Ptr1&],...] )
     Ok% = Mem.Fill( pMem& [,Anzahl& [,FüllChars$]] )
     Ok% = Mem.Move( Ziel&, Quelle& [,Anzahl&] ) - Mem.Copy()
    Siz& = Mem.Size( Ptr& )			-- Mem.SizeOf()

    Ptr& = Mem.OleNew( Size& )			-- Mem.OleDim()
    Ptr& = Mem.OleResize( OldPtr&, NewSize& )	-- Mem.OleReDim()
     Ok% = Mem.OleFree( [[Ptr1&],...] )		-- Mem.OleDispose()
     Ok% = Mem.OleClear( Ptr&, Size& )
     Ok% = Mem.OleFill( pMem&, Anzahl& [,FüllChars$]] )
     Ok% = Mem.OleMove( Ziel&, Quelle&, Size& )	-- Mem.OleCopy()
*/


/* *************************************
   Mem.CAlloc( Elemente&, ElementSize& )
      - Speicherblöcke ocupar/reservieren
        Reserviert "Elemente" veces "Elementgröße" Bytes como Speicherplatz y liefert el Speicherzeiger como Rückgabewert (oder 0 en Fehler).
        Der Speicher es ya con Nullen initialisiert.
        Ergebnis: Speicherzeiger oder 0
*/
Proc Mem.CAlloc
   Parámetros nElem&, elSize&
   Declarar Size&
   If (nElem& = 0) or (elSize& = 0)
      Size& = 1
   Más
      Size& = nElem& * elSize&
   EndIf
   Volver Mem.New( Size& )
ENDPROC


/* *************************************
   Mem.New( Size& )
      - Speicher ocupar/reservieren
        Reserviert "Size" Bytes Speicherplatz y liefert el Speicherzeiger como Rückgabewert (oder 0 en Fehler).
        Der Speicher es ya con Nullen initialisiert.
        Ergebnis: Speicherzeiger oder 0
*/
Proc Mem.New
   Parámetros Size&
   Declarar pMem&, hMem&, flage&
   Mem.Error% = %TRUE

   Case Size& < 1 : Return %NULL

   flags& = $42   '~GMEM_MOVEABLE $2 | ~GMEM_ZEROINIT $40  '$42   (automáticamente con Null inicializar)
   hMem& = GlobalAlloc( flags&, Size& )

   Casenote hMem& : Volver %NULL   ' no genug Speicher

   pMem& = GlobalLock( hMem& )
   Casenote pMem& : Volver %NULL   ' no genug Speicher

   Mem.Error% = %FALSE
   Volver pMem&
ENDPROC
Proc Mem.Dim
   Parámetros Size&
   Volver Mem.New( Size& )
ENDPROC
Proc Mem.Malloc
   Parámetros Size&
   Volver Mem.New( Size& )
ENDPROC


/* *************************************
   Mem.Resize( pMem&, Size& )
      - Speichergröße ändern/redimensionieren
        Ändert el Speichergröße en el el Speicherzeiger zeigt.
        El Größe des angegebenen Speicherbereiches se en el neue Größe geändert (si ungleich).
        En uno Vergrößerung des Bereiches bleiben todos Daten obtener,
        en uno Verkleinerung sólo el vordere Teil. (!!!sin Gewähr!!!)
        Ergebnis: Liefert el neuen Speicherzeiger zurück.
*/
Proc Mem.Resize
   Parámetros pMem&, Size&
   Declarar hMem&, OldSize&, e&
   Mem.Error% = %FALSE
   If pMem&   ' --- Größe ändern ---
      hMem& = GlobalHandle( pMem& )
      Casenote hMem& : Mem.Error% = GetLastError()
      If hMem&
         OldSize& = GlobalSize( hMem& )
         Casenote OldSize& : Mem.Error% = GetLastError()
         If OldSize& <> Size&
            GlobalUnlock( hMem& )
            hMem& = GlobalReAlloc( hMem&, Size&, $2 )   '~GMEM_MOVEABLE $2
            Casenote hMem& : Mem.Error% = GetLastError()
            If hMem&
               pMem& = GlobalLock( hMem& )
               Casenote pMem& : Mem.Error% = GetLastError()
            EndIf
         EndIf
      EndIf
   Más   ' --- Speicher neu invertir ---
      pMem& = Mem.New( Size& )
   EndIf
   Volver pMem&
ENDPROC
Proc Mem.ReDim
   Parámetros pMem&, Size&
   Volver Mem.Resize( pMem&, Size& )
ENDPROC
Proc Mem.Realloc
   Parámetros pMem&, Size&
   Volver Mem.Resize( pMem&, Size& )
ENDPROC


/* *************************************
   Mem.Libre( pMem& [,pMem& ...] )
      - Speicher liberación (auch mehrere Bereiche zugleich)
        Gibt el Speicherbereich en el el Speicherzeiger zeigt otra vez frei.
        Lo puede mehrere Parámetro para Editar angegeben voluntad.
        Ergebnis: Größe el freigegebenen Bereiche
*/
Proc Mem.Libre
   Declarar PC&, pMem&, hMem&, size&, e&, cnt&
   cnt& = 0
   PC& = %PCount
   Mem.Error% = %FALSE
   WhileLoop 1, PC&
      pMem& = @&(&loop)
      If pMem&
         size& = Mem.Size( pMem& )
         hMem& = GlobalHandle( pMem& )
         Casenote hMem& : Mem.Error% = GetLastError()
         If hMem&
            e& = GlobalUnlock( hMem& )
            Casenote e& : Mem.Error% = GetLastError()
            If e&
               e& = GlobalFree( hMem& )
               Casenote e& : Mem.Error% = GetLastError()
               If e&
                  Inc cnt&, size&
               EndIf
            EndIf
         EndIf
      EndIf
   EndWhile
   Volver cnt&
ENDPROC
Proc Mem.Disponer   'hier entonces sólo una Zona liberación, sonst Por favor, Mem.Libre nutzen
   Parámetros pMem&
   Volver Mem.Libre( pMem& )
ENDPROC


/* *************************************
   Mem.Claro( pMem& [,pMem& ...] )
      - Speicher con Nullen überschreiben
        Der angegebene (gesamte) Speicherbereich es con binären Nullen überschrieben.
        Für una Teilfüllung es Mem.Fill() a nutzen.
        Lo puede mehrere Parámetro para Editar angegeben voluntad.
        Ergebnis: Anzahl el bearbeiteten Bereiche
*/
Proc Mem.Claro
   Declarar PC&, pMem&, size&, cnt&
   cnt = 0
   PC& = %PCount
   Mem.Error% = %FALSE
   WhileLoop 1, PC&
      pMem& = @&(&loop)
      If pMem&
         size& = Mem.Size( pMem& )
         If size&
            ZeroMemory( pMem&, size& )
            Inc cnt&
         EndIf
      EndIf
   EndWhile
   Volver cnt&
ENDPROC


/* *************************************
   Mem.Fill( pMem& [,Anzahl& [,FüllChars$]] )
      - Speicher con un Signo füllen
        Ist Anzahl = 0 Luego se Anzahl en Mem.Size(pMem) gesetzt.
        Der angegebene Speicherbereich es con Füllzeichen aufgefüllt.
        Ohne Füllzeichen es con Chr$(0) aufgefüllt.
        En una Signo se Kernel32.FillMemory() genutzt
        En más Signo se Kernel32.MoveMemory() genutzt
        Ergebnis: Liefert True, si Speicher gefüllt wurde
*/
Proc Mem.Fill
   Declarar pMem&, pFill&, Anzahl&, Count&, PC&, LFill&, Erg%
   PC& = %PCount
   Erg% = %FALSE
   Mem.Error% = %FALSE
   Select PC&
      CaseOf 1
         Parámetros pMem1&
         pMem& = pMem1&
         Casenote pMem& : Volver %FALSE
         Anzahl& = Mem.Size( pMem& )
         If Anzahl& > 0
            FillMemory( pMem&, Anzahl&, LFill& )
            Erg% = %TRUE
         EndIf
      CaseOf 2
         Parámetros pMem2&, Anzahl2&
         pMem = pMem2
         Casenote pMem& : Volver %FALSE
         Count& = Mem.Size( pMem& )
         Anzahl& = if( Anzahl2& > Count&, Count&, Anzahl2& )
         If Anzahl& > 0
            FillMemory( pMem&, Anzahl&, LFill& )
            Erg% = %TRUE
         EndIf
      CaseOf 3
         Parámetros pMem3&, Anzahl3&, FillChars$
         pMem& = pMem3&
         Casenote pMem& : Volver %FALSE
         Count& = Mem.Size( pMem& )
         Anzahl& = if( Anzahl3& > Count&, Count&, Anzahl3& )
         Case Anzahl& < 1 : Return %FALSE
         Count& = Len( FillChars$ )
         Erg% = %TRUE
         If Count& < 2
            Case Count& = 1 : LFill& = Ord( FillChars$ )
            FillMemory( pMem&, Anzahl&, LFill& )
         Más
            pFill& = Addr( FillChars$ )
            Mientras que Anzahl& > 0
               Case Count& > Anzahl& : Count& = Anzahl&
               MoveMemory( pMem&, pFill&, Count& )
               Inc pMem&, Count&
               Dec Anzahl&, Count&
            EndWhile
         EndIf
   EndSelect
   Volver Erg%
ENDPROC


/* *************************************
   Mem.Move( Ziel&, Quelle& [,Anzahl&] )
      - Speicherinhalte kopieren
        Der angegebene Quellbereich se en el Zielbereich kopiert.
        Ergebnis: Liefert True, si Speicher kopiert wurde
*/
Proc Mem.Move
   Declarar pZiel&, zLen&, pQuelle&, qLen&, Anzahl&, PC&
   PC& = %PCount
   Mem.Error% = %FALSE
   If PC& = 2
      Parámetros pZiel2&, pQuelle2&
      pZiel& = pZiel2&
      pQuelle& = pQuelle2&
   ElseIf PC& = 3
      Parámetros pZiel3&, pQuelle3&, Anzahl3&
      pZiel& = pZiel3&
      pQuelle& = pQuelle3&
      Anzahl& = Anzahl3&
   EndIf
   Case (pZiel& = 0) or (pQuelle& = 0) : Volver %FALSE
   zLen& = Mem.Size( pZiel& )
   qLen& = Mem.Size( pQuelle& )
   Case zLen& < qLen& : qLen& = zLen&
   Casenote qLen& : Volver %FALSE
   Case (Anzahl& < 1) or (Anzahl& > qLen&) : Anzahl& = qLen&
   MoveMemory( pZiel&, pQuelle&, Anzahl& )
   Volver %TRUE
ENDPROC
Proc Mem.Copy
   Parámetros pZiel&, pQuelle&, Anzahl&
   Volver Mem.Move( pZiel&, pQuelle&, Anzahl& )
ENDPROC

/* *************************************
   Mem.Size( pMem& )
      - Größe des belegten Speichers ermitteln
        Ermittelt el Speichergröße en el el Speicherzeiger zeigt.
        Ergebnis: Liefert el Größe des Bereiches zurück.
*/
Proc Mem.Size
   Parámetros pMem&
   Declarar hMem&, Size&
   Size& = 0
   Mem.Error% = %FALSE
   Casenote pMem& : Volver Size&
   hMem& = GlobalHandle( pMem& )
   Casenote hMem& : GetLastError()
   If hMem&
      size& = GlobalSize( hMem& )
      Casenote size& : Mem.Error% = GetLastError()
   EndIf
   Volver size&
ENDPROC
Proc Mem.SizeOf
   Parámetros pMem&
   Volver Mem.Size( pMem& )
ENDPROC


/* *************************************
   Mem.OleNew( Size& )
      - OLE-Speicher ocupar/reservieren
        Reserviert "Size" Bytes Speicherplatz y liefert el Speicherzeiger como Rückgabewert.
        Ist "Size" kleiner como 1, Luego se él en 1 gesetzt.
        Ergebnis: Speicherzeiger
*/
Proc Mem.OleNew
   Parámetros Size&
   Mem.Error% = %FALSE
   Volver Ole32_Dim( Size& )
ENDPROC
Proc Mem.OleDim
   Parámetros Size&
   Case Size& < 1 : Size& = 1
   Volver Mem.OleNew( Size& )
ENDPROC


/* *************************************
   Mem.OleResize( pMem&, Size& )
      - Speichergröße ändern/redimensionieren
        Ändert el Speichergröße en el el Speicherzeiger zeigt.
        El Größe des angegebenen Speicherbereiches se en el neue Größe geändert.
        En uno Vergrößerung des Bereiches bleiben todos Daten obtener,
        en uno Verkleinerung sólo el vordere Teil. (!!!sin Gewähr!!!)
        Ergebnis: Liefert el neuen Speicherzeiger zurück.
*/
Proc Mem.OleResize
   Parámetros Ptr&, Size&
   Casenote Ptr& : Volver Mem.OleNew( Size& )
   Case Size& < 1 : Size& = 1
   Volver Ole32_ReDim( Ptr&, Size& )
ENDPROC
Proc Mem.OleReDim
   Parámetros Ptr&, Size&
   Volver Mem.OleResize( Ptr&, Size& )
ENDPROC


/* *************************************
   Mem.OleFree( pMem& [,pMem& ...] )
      - Speicher liberación (auch mehrere Bereiche zugleich)
        Gibt el Speicherbereich en el el Speicherzeiger zeigt otra vez frei.
        Lo puede mehrere Parámetro para Editar angegeben voluntad.
        Ergebnis: Boolean; Freigabe wurde durchgeführt
*/
Proc Mem.OleFree
   Declarar PC%, pMem&
   PC% = %PCount
   Case PC% < 1 : Return %FALSE
   WhileLoop PC%
      pMem& = @&(&loop)
      Case pMem& : Ole32_Dispose(pMem&)
   EndWhile
   Volver %TRUE
ENDPROC
Proc Mem.OleDispose
   Declarar PC%, pMem&
   PC% = %PCount
   Case PC% < 1 : Return %FALSE
   WhileLoop PC%
      pMem& = @&(&loop)
      Case pMem& : Ole32_Dispose(pMem&)
   EndWhile
   Volver %TRUE
ENDPROC

/* *************************************
   Mem.OleClear( pMem&, Size& )
      - Speicher con Nullen überschreiben
        Der angegebene (gesamte) Speicherbereich es con binären Nullen überschrieben.
        Für una Teilfüllung es Mem.Fill() a nutzen.
        Ergebnis: Boolean; Überschreiben con Nullen durchgeführt
*/
Proc Mem.OleClear
   Parámetros Ptr&, Size&
   Mem.Error% = %TRUE
   Case (Ptr& = 0) or (Size& < 1) : Return %FALSE
   Mem.Error% = %FALSE
   ZeroMemory( Ptr&, Size& )
   Volver %TRUE
ENDPROC


/* *************************************
   Mem.OleFill( pMem&, Anzahl& [,FüllChars$]] )
      - Speicher con un Signo füllen
        Der angegebene Speicherbereich es con Füllzeichen aufgefüllt.
        Ohne Füllzeichen es con Chr$(0) aufgefüllt.
        En una Signo se Kernel32.FillMemory() genutzt
        En más Signo se Kernel32.MoveMemory() genutzt
        Ergebnis: Liefert True, si Speicher gefüllt wurde
*/
Proc Mem.OleFill
   Declarar pMem&, pFill&, Anzahl&, Count&, PC&, LFill&, Erg%
   PC& = %PCount
   Erg% = %FALSE
   Mem.Error% = %FALSE
   Select PC&
      CaseOf 2
         Parámetros pMem2&, Anzahl2&
         pMem = pMem2
         Casenote pMem& : Volver %FALSE
         Anzahl& = Anzahl2&
         If Anzahl& > 0
            FillMemory( pMem&, Anzahl&, LFill& )
            Erg% = %TRUE
         EndIf
      CaseOf 3
         Parámetros pMem3&, Anzahl3&, FillChars$
         pMem& = pMem3&
         Casenote pMem& : Volver %FALSE
         Anzahl& = Anzahl3&
         Case Anzahl& < 1 : Return %FALSE
         Count& = Len( FillChars$ )
         Erg% = %TRUE
         If Count& < 2
            Case Count& = 1 : LFill& = Ord( FillChars$ )
            FillMemory( pMem&, Anzahl&, LFill& )
         Más
            pFill& = Addr( FillChars$ )
            Mientras que Anzahl& > 0
               Case Count& > Anzahl& : Count& = Anzahl&
               MoveMemory( pMem&, pFill&, Count& )
               Inc pMem&, Count&
               Dec Anzahl&, Count&
            EndWhile
         EndIf
      Otherwise
         Mem.Error% = %FRUE
   EndSelect
   Volver Erg%
ENDPROC


/* *************************************
   Mem.OleMove( Ziel&, Quelle&, Anzahl& )
      - Speicherinhalte kopieren
        Der angegebene Quellbereich se en el Zielbereich kopiert.
        Ergebnis: Liefert True, si Speicher kopiert wurde
*/
Proc Mem.OleMove
   Parámetros pZiel&, pQuelle&, Anzahl&
   Case (pZiel& = 0) or (pQuelle& = 0) or (Anzahl& < 1) : Return %FALSE
   MoveMemory( pZiel&, pQuelle&, Anzahl& )
   Volver %TRUE
ENDPROC
Proc Mem.OleCopy
   Parámetros pZiel&, pQuelle&, Anzahl&
   Volver Mem.OleMove( pZiel&, pQuelle&, Anzahl& )
ENDPROC

$ENDIF 'MEM_ALLOC

Alle Sprachen
System: Windows 8/10, XProfan X4
Programmieren, das spannendste Detektivspiel der Welt.

27.05.2018 ▲

Jörg
Sellmeyer

¡Hola Michael,

danke, dass du dich veces así befasst hast. Im Grunde brauche Yo en el ganzen Wust sólo el eigentliche Bucle como ASM.

Das sähe entonces así de:

'sólo esta Procedimiento como ASM

Proc MakeNumArray

    Parámetros AnzX%,AnzY%,Size%,Rand%,Abst%,FunkAdd&
    Declarar tmp%,B#,BSize&
    BSize& = AnzX% * AnzY% * 4
    Dim B#,BSize&
    Var posx% = Rand%
    Var PosY% = Rand%

    WhileLoop 0,(BSize& - 8),8

        Largo B#,&Loop,PosX%
        Largo B#,(&Loop + 4), PosY%
        'idealerweise todavía con nem optionalen Funktionsaufruf
        'obwohl Yo como todavía nada weiß, Yo entonces a el
        'Rückgabewert el Función kommen se

        If FunkAdd& > 0

            'Hier entonces una Adresse uno Profanfunktion, si el va
            'Call(FunkAdd&,posx%,posy%,size%,size%)
            MakeButton(posx%,posy%,size%,size%)

        EndIf

        Inc Posx%, (size% + Abst%)

        Caso negativo (tmp% + 1) Mod (AnzX%)

            Posx% = Rand%
            Inc posy%,size% + Abst%

        EndIf

        Inc tmp%

    Wend

    Volver B#

ENDPROC

Proc MakeButton

    Parámetros x%,y%,b%,h%
    Var Texto$ = "Positionen" + Str$(x%) + "," + Str$(y%)
    Var hdl& = Crear("Button",%hwnd,Texto$,x%,y%,b%,h%)
    SetStyle hdl&,GetStyle(hdl&) | $2000'~BS_MULTILINE
    Volver hdl&

ENDPROC

Selección aleatoria
Var h& = Crear("Font","Western",14,0,0,0,0)
SetDialogFont h&
Declarar Zona#,AnzX%,AnzY%,gr%,rand%,Abstenciones%
gr% = 56
rand% = 40
abst% = 10
Ventana de Estilo 24
'Ventana 10,10 - (((Rnd(16) + 10) * (gr% + Abst%)) + (rand% * 2)+4),(((Rnd(5) + 10) * (gr% + Abst%)) + (rand% * 2)+4)
Ventana 700,500
Var func& = ProcAddr("MakeButton",4)
Anzx% = (gr% + Abst%)
AnzX% =  (Width(%hwnd) - (rand% * 2) + Abst%) \ Anzx%
Anzy% = (gr% + Abst%)
Anzy% =  (Height(%hwnd) - (rand% * 2) + Abst%) \ Anzy%
AnzY% = AnzY% *  2'n1 * 2 porque lo Paare de Werten son y yo sólo el número los objetos angeben voluntad
Dim Zona#,AnzX%*AnzY%*4
Var Tick& = &GetTickcount
Bereich# = MakeNumArray(AnzX%,AnzY%,gr%,rand%,Abstenciones%,func&)
Imprimir &GettickCount - Tick&
'WhileLoop 0,SizeOf(Zona#)-8,8
'  Imprimir Largo(Zona#,&Loop),
'  Imprimir Largo(Zona#,&Loop+4),
'Wend
Localizar 1,1

Mientras que 1

    WaitInput

    If Upper$(ClassOf(%getfocus)) = "BUTTON"

        Case %mousepressed:Imprimir ItemID(%getfocus),

    EndIf

Wend

Zu el Funktionsparametern oben:
Der erste Teil se ausgeführt, si la Parameterzahl 3-5 es. En 3 son Rand% y Abstand% entonces 0. En 4 es sólo Abstand 0.
En 6 Parametern, se el zweite Teil aufgerufen. Der 6. Parámetro es entonces quasi sólo el Flag y kann cualquier ser.

Windows XP SP2 XProfan X4
... und hier mal was ganz anderes als Profan ...

28.05.2018 ▲

Michael
W.

'Call(FunkAdd&,posx%,posy%,size%,size%)

PUSH size%
PUSH size%
PUSH posy%
PUSH posx%
MOV EBX, FunkAdd&
CALL [EBX]
POP EAX ;Funktionsergebnis

Natürlich alles en Umwegen. Roland hatte dazu auch una Posting gesetzt. Finde lo ahora en el Schnelle no.
Dort fue un direkte Profano-Rutina angesprungen worden. Aber encima ProcAddr bekommst Usted el Adresse. Dort kann entonces auch una feste Parameteranzahl gewählt voluntad. Verdoppeln puede ser de paso intern.

System: Windows 8/10, XProfan X4
Programmieren, das spannendste Detektivspiel der Welt.

29.05.2018 ▲

Infinity-Profan
WinXP, SP3, Core(TM) i7-3770 @ 3.40GHz

[offtopic]Muss me necesariamente aktuelles XProfan (X4?) en Ruhe ansehen! ASM sin Zusatztools es super. Como wäre auch veces otra vez una XPSE-Actualización toll para "natives Profan" (nProfan) por XProfan-Inline-ASM.[/offtopic]

29.05.2018 ▲

Michael
W.

[OFFTOPIC]@IF:

[/OFFTOPIC]

'sólo esta Procedimiento como ASM

Aufruf:
MakeNumArray( AnzX%, AnzY%, Size%, Rand%, Abst%, ProcAddr("MakeButton",4) )

Proc MakeNumArray
    Parámetros AnzX%,AnzY%,Size%,Rand%,Abst%,FunkAdr&
    Declarar B#,BSize&
    BSize& = AnzX% * AnzY% * 4
    Dim B#,BSize&
    Var posx% = Rand%
    Var PosY% = Rand%

    'intern definiert erspare Yo el Aufbau des Speichers
    ASM "MakeNumArr_a",?
       // Par1  = Addr(B#)      - Adresse des Speicherstarts
       // Par2  = Addr(PosX%)   - Valor se geändert voluntad, also como Adresse
       // Par3  = Addr(PosY%)   - Valor se geändert voluntad, also como Adresse
       // Par4  = Schleifenende - reiner Valor, el restos aquí en EBX para schnellen Vergleich
       // Par5  = AnzX          - direkten Valor speichern
       // Par6  = AnzY          - direkten Valor speichern
       // Par7  = Size          - direkten Valor speichern
       // Par8  = Rand          - direkten Valor speichern
       // Par9  = Abst          - direkten Valor speichern
       // Par10 = FunkAdd&      - ProcAddr("MakeButton",4)
       JMP Start
pPosX: DD   0
pPosY: DD   0
vAnzX: DD   0
vAnzY: DD   0
vSize: DD   0
vRand: DD   0
vAbst: DD   0
vSuA:  DD   0
vTMP:  DD   0
Start:
       MOV  EDI, Par1  // Array - EDI
       MOV  EAX, PAR2  // Addr(PosX%)
       MOV  [pPosX], EAX
       MOV  EAX, PAR3  // Addr(PosY%)
       MOV  [pPosY], EAX
       MOV  EBX, Par4 'Schleifenende -- EBX
       MOV  EAX, Par5  // AnzX%
       MOV  [vAnzX], EAX
       MOV  EAX, Par6  // AnzY%
       MOV  [vAnzY], EAX
       MOV  EAX, Par7  // Size%
       MOV  [vSize], EAX
       MOV  EDX, EAX   // Size + ...
       MOV  EAX, Par8  // Rand%
       MOV  [vRand], EAX
       MOV  EAX, Par9  // Abst%
       MOV  [vAbst], EAX
       ADD  EDX, EAX   // ... + Abst
       MOV  [vSuA], EDX  // el Summe antes del bucle forma
       MOV  EDX, Par10  // Funktionsadresse oder Null

       // beim letzten Ejemplo wurde oben gezählt, 
       // el geschieht ahora beim Indexzugriff.
       // Hier se igual el Schleifenende geprüft
       XOR  ECX, ECX
       MOV  [vTMP], ECX  // sicherheitshalber auch TMP en Null conjunto
schleife:		//     WhileLoop 0,(BSize& - 8),8
       CMP  ECX, EBX    // en schleifenende prüfen
       JA   Ende        // si größer, entonces fuera (en igual also todavía una Durchlauf)

       MOV  ESI, [pPosX]  // Zeiger holen
       MOV  EAX, [ESI]    // Variableninhalt PosX después de EAX
       MOV  [EDI + ECX], EAX   // Largo B#,&Loop = PosX%
       ADD  ECX, 4

       MOV  ESI, [pPosY]  // Zeiger holen
       MOV  EAX, [ESI]    // Variableninhalt PosY después de EAX
       MOV  [EDI + ECX], EAX   // Largo B#,(&Loop + 4), PosY%
       ADD  ECX, 4


       // --- If FunkAdr& > 0
       XOR  EAX, EAX  // como algo con Funktionsergebnis angestellt se, hier una Vorgabewert
       CMP  EDX, 0
       JZ   No_Func

       // Parámetro rückwärts en el Stapel
       MOV  EAX, [vSize]  // Value
       PUSH EAX
       PUSH EAX
       MOV  ESI, [pPosY]  // Zeiger
       MOV  EAX, [ESI]    // Inhalt
       PUSH EAX
       MOV  ESI, [pPosX]  // Zeiger
       MOV  EAX, [ESI]    // Inhalt
       PUSH EAX
       CALL [EDX]
No_Func:
       // hier kann EAX ausgewertet voluntad
       // --- EndIf


       PUSH EDX  // el Funktionszeiger sichern

       MOV  ESI, [pPosX]  // Zeiger holen
       MOV  EAX, [ESI]    // Variableninhalt PosX después de EAX
       MOV  EDX, [vSuA]  // el Summe de (Size+Abst)
       ADD  EAX, EDX     // PosX + (Size+Abst)
       MOV  [ESI], EAX   // Valor zurückschreiben


       XOR  EDX, EDX
       MOV  EAX, [vTMP]
       INC  EAX
       PUSH EBX     // Schleifenende sichern
       MOV  EBX, [vAnzX]
       DIV  EBX     // es: EDX:EAX / EBX = wert en EAX, Rest es en EDX
       POP  EBX     // Schleifenende restaurieren

       CMP  EDX, 0
       JE   over_IF


       // --- If-Part
       MOV  ESI, [pPosX]  // Zeiger holen   // Posx% = Rand%
       MOV  EAX, [vRand]
       MOV  [ESI], EAX   // Valor zurückschreiben

       MOV  ESI, [pPosY]  // Zeiger holen   // Inc posy%,size% + Abst%
       MOV  EAX, [ESI]    // Variableninhalt PosY después de EAX
       MOV  EDX, [vSuA]  // el Summe de (Size+Abst)
       ADD  EAX, EDX     // PosY + (Size+Abst)
       MOV  [ESI], EAX   // Valor zurückschreiben
       // --- EndIf


over_IF:
       MOV  EAX, [vTMP]
       INC  EAX
       MOV  [vTMP], EAX
// oder        INC [vTMP] ??? (más bien en Nummer sicher)

       POP  EDX  // el Funktionszeiger restaurieren
       JMP  schleife

Ende:
    EndASM
    MakeNumArr_a( Addr(B#), Addr(PosX%), Addr(PosY%), (BSize& - 8), AnzX%, AnzY%, Size%, Rand%, Abst%, FunkAdr& )

    Volver B#
ENDPROC

Mein Gott, wann Yo el zuletzt así ausführlich kommentiert. Könnte mich liso otra vez daran gewöhnen.

System: Windows 8/10, XProfan X4
Programmieren, das spannendste Detektivspiel der Welt.

29.05.2018 ▲

Jörg
Sellmeyer

Uff - como muss Yo mich primero durchackern. ASM es para mich siempre todavía como chinesisch. Aber ahora tener Yo veces quasi ne Übersetzung meines eigenen Codes. Como kann Yo qué con anfangen. Vielen Dank!

XProfan X3
Windows XP SP2 XProfan X4
... und hier mal was ganz anderes als Profan ...

30.05.2018 ▲