Question a Fred ou au pros de l'ASSEMBLEUR [répondu]

[Backup]

ça fait quelques temps, que je vois des membres mettre des "End"
dans une procedure !
il ne me serai jamais venu a l'idée de faire un truc pareil ;

ayant pas mal utilisé des Debuggeur Ass (Softice,ollydbg..etc)
j'ai souvent a tracé des procedures "Call- Return"

a mon sens lors d'un appel a une procedure , l'adresse de retour est empilé avant l'appel
puis dépilé pour le retour

question :
mettre un End ,ou un goto , empeche le prg purebasic
de faire le Endprocedure ... et donc , je suppose de dépiler l'adresse ! ??

alors , que deviens cette valeur empilé si l'on quitte le prg ?

la pile disparait avec le programme ?

n'est ce pas une mauvaise chose de mettre un END dans une procedure
tout comme il est évident de ne pas mettre un GOTO, dans une Procedure !

alors ? qu'en est il ?

[Fred]

PureBasic gère correctement ce cas de figure, ne t'en fais pas .

[flaith]

Je me suis posé la même question suite à ta réponse de l'autre sujet

si on a ce code :

Code : Tout sélectionner

Procedure foo()
  Protected nothing.i = 10
  
  If nothing = 10
    End
  EndIf
EndProcedure

Procedure.i foo2(nothing.i)
  If nothing2 = 10
    End
  EndIf
  
  ProcedureReturn nothing2*2
EndProcedure

foo()
foo2(10)

en asm ca donne :

Code : Tout sélectionner

; 
; PureBasic 4.50 (Windows - x86) generated code
; 
; (c) 2010 Fantaisie Software
; 
; The header must remain intact for Re-Assembly
; 
; :System
; KERNEL32
; :Import
; 
format MS COFF
; 
extrn _ExitProcess@4
extrn _GetModuleHandleA@4
extrn _HeapCreate@12
extrn _HeapDestroy@4
; 
extrn _memset
public _PB_Instance
public _PB_ExecutableType
public _PB_MemoryBase
public PB_Instance
public PB_MemoryBase
public _PB_EndFunctions

macro pb_public symbol
{
  public  _#symbol
  public symbol
_#symbol:
symbol:
}

macro    pb_align value { rb (value-1) - ($-_PB_DataSection + value-1) mod value }
macro pb_bssalign value { rb (value-1) - ($-_PB_BSSSection  + value-1) mod value }
public PureBasicStart
; 
section '.code' code readable executable align 8
; 
; 
PureBasicStart:
; 
  PUSH   dword I_BSSEnd-I_BSSStart
  PUSH   dword 0
  PUSH   dword I_BSSStart
  CALL  _memset
  ADD    esp,12
  PUSH   dword 0
  CALL  _GetModuleHandleA@4
  MOV    [_PB_Instance],eax
  PUSH   dword 0
  PUSH   dword 4096
  PUSH   dword 0
  CALL  _HeapCreate@12
  MOV    [PB_MemoryBase],eax
; 
; Procedure foo()
macro MP0{
_Procedure0:
  PUSH   ebx
  PS0=12
  XOR    eax,eax
  PUSH   eax                                                                                                                                                                                                                  
; Protected nothing.i = 10
  MOV    dword [esp],10
; 
; If nothing = 10
  MOV    ebx,dword [esp]
  CMP    ebx,10
  JNE   _EndIf2
; End
  JMP   _PB_EOP_NoValue
; EndIf
_EndIf2:
; EndProcedure
  XOR    eax,eax
_EndProcedure1:
  ADD    esp,4
  POP    ebx
  RET
}
; 
; Procedure.i foo2(nothing.i)
macro MP2{
_Procedure2:
  PUSH   ebx
  PS2=12
  XOR    eax,eax
  PUSH   eax                                                                                                                                                                                                                  
; If nothing2 = 10
  MOV    ebx,dword [esp]
  CMP    ebx,10
  JNE   _EndIf4
; End
  JMP   _PB_EOP_NoValue
; EndIf
_EndIf4:
; 
; ProcedureReturn nothing2*2
  MOV    ebx,dword [esp]
  ADD    ebx,ebx
  MOV    eax,ebx
  JMP   _EndProcedure3
; EndProcedure
  XOR    eax,eax
_EndProcedure3:
  ADD    esp,4
  POP    ebx
  RET    4
}
; 
; foo()
  CALL  _Procedure0
; foo2(10)
  PUSH   dword 10
  CALL  _Procedure2
; 
_PB_EOP_NoValue:
  PUSH   dword 0
_PB_EOP:
  CALL  _PB_EndFunctions
  PUSH   dword [PB_MemoryBase]
  CALL  _HeapDestroy@4
  CALL  _ExitProcess@4
_PB_EndFunctions:
  RET
; 
MP0
MP2
; 
section '.data' data readable writeable
; 
_PB_DataSection:
pb_public PB_DEBUGGER_LineNumber
  dd     -1
pb_public PB_DEBUGGER_IncludedFiles
  dd     0
pb_public PB_DEBUGGER_FileName
  db     0
_PB_ExecutableType: dd 0
align 4
align 4
s_s:
  dd     0
  dd     -1
align 4
; 
section '.bss' readable writeable
_PB_BSSSection:
align 4
; 
I_BSSStart:
_PB_MemoryBase:
PB_MemoryBase: rd 1
_PB_Instance:
PB_Instance: rd 1
; 
align 4
PB_DataPointer rd 1
align 4
align 4
align 4
align 4
I_BSSEnd:
section '.data' data readable writeable
SYS_EndDataSection:

Donc le end appel "_PB_EOP_NoValue" qui détruit le heap, soit toutes zones mémoires allouées mais pas la pile, ou alors l'appel de la commande "_PB_EndFunctions" le fait peut-être, merci d'avance pour tes lumières Fred

**EDIT** : j'suis tjrs aussi lent, déjà eu la réponse Fred

[Backup]

@fred

quand je pense que j'ai fait des contortions !
pour sortir de certaines de mes procedures
avec un test dans la boucle principale, pour quitter ou pas

alors que je pouvais inclure le End directement dans la procedure !!

tu pouvais pas le dire plus tot !!


ps : Merci Flaith !

[case]

en même temps il vas pas te dire tout ce que tu peux faire ,) et tant que c'est pas explicitement précisé qu'on peux pas, c'est qu'on peux !

[Backup]

en même temps il vas pas te dire tout ce que tu peux faire ,) et tant que c'est pas explicitement précisé qu'on peux pas, c'est qu'on peux !

sauf que si tu fais :
(a lancer en mode debug !)

Code : Tout sélectionner

Procedure toto ()
    Goto a: 
EndProcedure
a:
toto ()        

c'est pas marqué qu'on peux pas le faire
et pourtant ça va te générer un probleme de Ram
qui peux te planter une machine correcte !!

donc c'est pas marqué , mais mieux vaut ne pas le faire !

c'est comme lire des Data au dela du dernier, tu déborde dans la Ram
c'est pas spécifié non plus qu'il ne faut pas le faire , car il n'y a pas de garde fou pour Read ...

bref , avoir une réponse a ce sujet est toujours utile quoiqu'il en soit !







r

[bombseb]

quand je pense que j'ai fait des contortions !
pour sortir de certaines de mes procedures
avec un test dans la boucle principale, pour quitter ou pas

alors que je pouvais inclure le End directement dans la procedure !!

Je trouve pas ca très propre de quitter le programme directement dans une procédure...

Sinon pour la valeur empilée dans la pile, si tu fait un end, je pense que c'est l'os qui libère la ram utilisée par le prog, donc ca ne plante pas, mais bon c'est pas tres élégant je trouve

[Ollivier]

Salut Dobro,

J'adhère inutilement à ton purisme soudainement exprimé en la matière. C'est le système d'exploitation qui charge, exécute ou libère (de gré ou de force) un programme.

« End » est l'appel d'une fonction du système d'exploitation qui consiste à libérer la mémoire occupé par ton programme.

Il y a une époque où l'instruction Assembleur RET (RETurn) suffisait pour quitter un programme. En effet, du point de vue de la pile, le programme ancestral était au système d'exploitation de l'époque ce qu'aujourd'hui la procédure est au programme principal. Mais c'était il y a quelques années...

Ollivier

[Fred]

Dobro: T'es sur pour pour le Read ?

Code : Tout sélectionner

Read a
Read a

DataSection
  a:
  Data.l 10

Chez moi ca m'indique qu'on en lit trop (avec le debugger).

[Backup]

oui ! t'inquiete avec le debugger ça marche !

je parlais sans debuggeur ... comme compilé quoi ...
c'est pas indiqué dans la doc qu'il peux y avoir dépassement du buffer data ..
donc , pour en revenir au propos précedents ;
c'est pas parceque c'est pas marqué, qu'on peux le faire

pour ce probleme de dépassement j'en avait deja parlé ici : (en 2005 !! )
http://www.purebasic.fr/french/viewtopi ... hilit=data

avec cette exemple (a utiliser sans débugger ! )

Code : Tout sélectionner

; ceci demontre un depassement de buffer dans les Datas !
; qui peut ammener un gros plantage
; avec ceci il doit etre possible de faire un wiever de ram a peut de frais ! :-D
; voici donc le coeur de la RAM !!



OpenConsole()  ; on ouvre la console
ConsoleColor(10, 0) ; on choisi la couleur verte pour le text (j'aime bien !)

For u=1 To 500 ; on va boucler 500 fois alors qu'il n'y a que 5 Data a lire !!  :-)
    Read.s a$  ; on lit les data (les 5) mais ça va pas s'arreter !!!  :-D
    Print(a$) ; on affiche notre peche au data sur la console
Next u
 
q$=Input () ; on attend une touche pour avoir le temps de regarder le coeur de la RAM !




DataSection
    Data.s "a","b","c","d"," ce qui suit c'est quoi ?? :---> "
EndDataSection

j'avais eu une réponse sensé !
mais n'empeche que c'est le genre de truc qui devrai etre spécifié dans la doc

d'autant qu'on peut peut etre s'en servir et mettre la ram en vrac .... (injection ! ? ; espionage ?)