Calculatrice de Jours & (dll source FASM)

[kernadec]

bonjour
Tout est dans le titre

ATTENTION la librairie Calendar.dll fonctionne qu'avec une version 32bits de PureBasic

Je rencontre a nouveau des petits soucis avec AVAST
et la décompression d'une librairie avec PB 5.20LTS sous Windows XP SP3 (x86)
la solution a été de déclarer "calendar.dll" en exclusion globale

Si la version source n'arrive pas à décompresser l'archive : créer un exécutable

Sinon voilà le lien pour la librairie : http://mikhajduk.houa.org/EN/index.php?f=Links
"Menu"
- "Projects"
- "Calendar Function Library"

Sur le site ce trouve le source FASM de la librairie, Alors j'avais essayé
de la faire tourner sous PB en mode procédure assembleur, pour avoir le cross plateforme.
mais je n'ai pas réussi a l'intégrer dans ce code...car je suis un débutant en langage assembleur.

Cordialement
Ps: Remerciement à "MikoÅ‚aj Hajduk" pour sa librairie de 10 millions d'années

Code : Tout sélectionner

;####################################################################################
'ATTENTION la librairie Calendar.dll fonctionne qu'avec une version 32bits de PureBasic
; Calculatrice de Jours - kernadec - 10-2013  Version 2014.1.6 avec années avant J.C.
; PB 5.00 - 5.20LTS - Windows XP (x86) & Seven 32 
;####################################################################################

Enumeration
  #window
EndEnumeration

Enumeration
  #font0
  #font1
  #font2
EndEnumeration

Enumeration
  #gadget11
  #gadget12
  #gadget13
  #gadget14
  #gadget15
  #gadget16
  #gadget17
  #gadget18
  #gadget19
  #gadget20
  #gadget21
  #gadget23
  #gadget22
  #gadget24
  #gadget26
  #gadget29
  #gadget27
  #gadget30
  #gadget31
  #gadget33
  #gadget25
  #gadget32
  #gadget34
  #gadget28
  #gadget35
  #gadget36
  #gadget37
  #gadget38
EndEnumeration

Structure calcul
  njour.l
  n1jour.l
  njour_or.l
  jour_mois$
  Nbjour2GJ.l
  Nbjour2date$
  greg2jul$
  jul2greg$
EndStructure

Global Dim result.calcul(1)
Global Dim Jours.s(6)
Global Dim mois.s(12)
Global Dim saint.s(366)
Global Dim semaine(53,1)
Global Dim Bissextile(1)
Global YMD_DLL, Gregorian.l, LeapYearFlag.l,article$, Y.l, M.l, D.l, Yg.l, Mg.l, Dg.l, Yj.l, Mj.l, Dj.l, n.l
gregorian=1

;path$ = "C:\PureBasic\"
path$ = GetCurrentDirectory()


YMD_DLL=OpenLibrary(#PB_Any, path$+"calendar.dll")

If YMD_DLL = #False  ; test librairie Calendar.dll
  Resultat = MessageRequester("ATTENTION","La Librairie CALENDAR.DLL est Absente!"+Chr(10)+"Voulez Vous l'Importer depuis l'Archive ?",#PB_MessageRequester_YesNo)
  If Resultat = 6 
    Declare ExpandBinaryfile(fichier.s)
    CatchImage(0,?calendar_dll_Start)
    ExpandBinaryfile(path$+"Calendar.dll")
    info$ + "La librairie  ** Calendar.dll **  a été Décompactée "+Chr(10)+" dans le repetoire " +path$
    YMD_DLL=OpenLibrary(#PB_Any, path$+"calendar.dll")
  Else               
    info$ + "CALENDAR.DLL est Absente! le Programme est Terminé"
    MessageRequester("Information",info$,#PB_MessageRequester_Ok)
    End
  EndIf
EndIf


Restore Jour
For i=0 To 6
  Read.s jours.s(i)
Next i
Restore mois
For i=1 To 12
  Read.s mois.s(i)
Next i
Restore fetes
For i=1 To 366
  Read.s saint.s(i)
Next i

Macro Fete(n)
  
  If Left(saint(n),1)="A" Or Left(saint(n),1)="E" Or Left(saint(n),1)="I" Or Left(saint(n),1)="O" Or Left(saint(n),1)="U" Or Left(saint(n),1)="I" Or Left(saint(n),1)="Y" Or Left(saint(n),1)="H"
    If Left(saint(n),1)=" "
      article$ = ""
    Else
      article$ = " Fête d' "
    EndIf 
  Else 
    If Left(saint(n),1)=" "
      article$ = ""
    Else
      article$ = " Fête de "
    EndIf 
  EndIf
  
EndMacro

Macro Calculs_Fevrier(a,b,c,dat)
  
  If GetGadgetState(b) = 2 And GetGadgetState(a) = 31                                        ;no exist
    If      Bissextile(dat) = 0 : SetGadgetText(a, "28") : SetGadgetState(a,28)
      Else  : Bissextile(dat) = 1 : SetGadgetText(a, "29") : SetGadgetState(a,29) : EndIf : EndIf                                                  
  If GetGadgetState(b) = 2 And GetGadgetState(a) = 30                                        ;no exist
    If      Bissextile(dat) = 0 : SetGadgetText(a, "28") : SetGadgetState(a,28)
      Else  : Bissextile(dat) = 1 : SetGadgetText(a, "29") : SetGadgetState(a,29) : EndIf : EndIf    
  If GetGadgetState(b) = 2 And GetGadgetState(a) = 29 
    If      Bissextile(dat) = 0 : SetGadgetText(a, "28") : SetGadgetState(a,28)
      Else  : Bissextile(dat) = 1 : SetGadgetText(a, "29") : SetGadgetState(a,29) : EndIf 
  EndIf 
  
EndMacro

Procedure Affiche_resultats( dat, g)
  
  ;Debug "Nombre Ordinal du Jour de l'année = "+Str(result(dat)\njour_or)
  ;Debug "Jour et Mois de l'année à partir d'un nombre ordinal = "+result(dat)\jour_mois$
  ;Debug "Nombre de Jours = "+Str(result(dat)\Nbjour2GJ)
  ;Debug "Reconversion nb Jour en Date = "+result(dat)\Nbjour2date$
  ;Debug "Conversion de Date Gregorian en Julien = "+result(dat)\greg2jul$
  ;Debug "Conversion de Date Julian en Gregorian = "+result(dat)\jul2greg$
  ;Debug "Nombre de Jours entre date= "+Str(result(1)\Nbjour2GJ-result(0)\Nbjour2GJ)
  
  If dat = 0                                                              ; affiche le jour
    If (GetGadgetState(#gadget11) =>1 And GetGadgetState(#gadget11) <= 31)  And  (GetGadgetState(#gadget12) =>1 And GetGadgetState(#gadget12) <= 12)     ;test wheel inc / dec trop rapide
      ; Debug "Le "+Str(GetGadgetState(#gadget11))+"/"+Str(GetGadgetState(#gadget12))+"/"+Str(GetGadgetState(#gadget13))+" est un "+Jours(result(dat)\njour)
      If GetGadgetState(#gadget12) = 4 Or GetGadgetState(#gadget12) = 6 Or GetGadgetState(#gadget12) = 9 Or GetGadgetState(#gadget12) = 11
        If GetGadgetState(#gadget11) = 31 ; test  les mois de 30  jours
        Else
          SetGadgetText(#gadget26, Jours(result(dat)\njour))
        EndIf 
      Else
        SetGadgetText(#gadget26, Jours(result(dat)\njour))
      EndIf
    EndIf
  Else                                                                    ; affiche le jour
    If (GetGadgetState(#gadget14) =>1 And GetGadgetState(#gadget14) <= 31)  And  (GetGadgetState(#gadget15) =>1 And GetGadgetState(#gadget15) <= 12)     ;test wheel inc / dec trop rapide
      ; Debug "Le "+Str(GetGadgetState(#gadget14))+"/"+Str(GetGadgetState(#gadget15))+"/"+Str(GetGadgetState(#gadget16))+" est un "+Jours(result(dat)\njour)
      If GetGadgetState(#gadget15) = 4 Or GetGadgetState(#gadget15) = 6 Or GetGadgetState(#gadget15) = 9 Or GetGadgetState(#gadget15) = 11
        If GetGadgetState(#gadget14) = 31 ; test  les mois de 30  jours
        Else
          SetGadgetText(#gadget29, Jours(result(dat)\njour))
        EndIf 
      Else
        SetGadgetText(#gadget29, Jours(result(dat)\njour))
      EndIf
    EndIf
  EndIf
  ;
  If Bissextile(dat) = 1                                                        ; affiche prénoms des fêtes 
    If result(dat)\njour_or = 60
      fete(result(dat)\njour_or)
      SetGadgetText(g, article$ + saint(366))   ; 29 février saint auguste a été changé de place dans le tableau de (60) vers (366)
    ElseIf result(dat)\njour_or > 60
      fete(result(dat)\njour_or - 1)
      SetGadgetText(g, article$ + saint(result(dat)\njour_or - 1))
    Else
      fete(result(dat)\njour_or)
      SetGadgetText(g, article$ + saint(result(dat)\njour_or))
    EndIf
  EndIf 
  If Bissextile(dat) = 0
    If GetGadgetState(#gadget12) = 2 
      fete(result(dat)\njour_or)
      SetGadgetText(g, article$ + saint(result(dat)\njour_or))
    EndIf
    If GetGadgetState(#gadget12) = 4 Or GetGadgetState(#gadget12) = 6 Or GetGadgetState(#gadget12) = 9 Or GetGadgetState(#gadget12) = 11
      If GetGadgetState(#gadget11) = 31 ; test  les mois de 30  jours  
      Else
        fete(result(dat)\njour_or)
        SetGadgetText(g, article$ + saint(result(dat)\njour_or))
      EndIf 
    EndIf
    If GetGadgetState(#gadget12) = 1 Or GetGadgetState(#gadget12) = 3 Or GetGadgetState(#gadget12) = 5 Or GetGadgetState(#gadget12) = 7 Or GetGadgetState(#gadget12) = 8 Or GetGadgetState(#gadget12) = 10 Or GetGadgetState(#gadget12) = 12
      fete(result(dat)\njour_or)
      SetGadgetText(g, article$ + saint(result(dat)\njour_or))
    EndIf
  EndIf
  If Bissextile(dat) = 0 
    If GetGadgetState(#gadget15) = 2 
      fete(result(dat)\njour_or)
      SetGadgetText(g, article$ + saint(result(dat)\njour_or))
    EndIf
    If GetGadgetState(#gadget15) = 4 Or GetGadgetState(#gadget15) = 6 Or GetGadgetState(#gadget15) = 9 Or GetGadgetState(#gadget15) = 11
      If GetGadgetState(#gadget14) = 31 ; test  les mois de 30  jours  
      Else
        fete(result(dat)\njour_or)
        SetGadgetText(g, article$ + saint(result(dat)\njour_or))
      EndIf 
    EndIf
    If GetGadgetState(#gadget15) = 1 Or GetGadgetState(#gadget15) = 3 Or GetGadgetState(#gadget15) = 5 Or GetGadgetState(#gadget15) = 7 Or GetGadgetState(#gadget15) = 8 Or GetGadgetState(#gadget15) = 10 Or GetGadgetState(#gadget15) = 12
      fete(result(dat)\njour_or)
      SetGadgetText(g, article$ + saint(result(dat)\njour_or))
    EndIf
  EndIf
  ;
  If dat = 0                                                                           ; affiche en date julien 1
    SetGadgetText(#gadget17,result(dat)\greg2jul$)                     
    SetGadgetText(#gadget32,mois(Val(StringField(result(dat)\jour_mois$, 2,"/"))))     ; affiche mois
    
    ; calcul du numéro de la semaine ISO à partir d'un nombre ordinal
    If result(dat)\n1jour = 0
      SetGadgetText(#gadget33,"Semaine "+Str(Int((result(dat)\njour_or-2)/7)+1))
    EndIf
    If result(dat)\n1jour = 1
      SetGadgetText(#gadget33,"Semaine "+Str(Int((result(dat)\njour_or-1)/7)+1))
    EndIf
    If result(dat)\n1jour = 2
      SetGadgetText(#gadget33,"Semaine "+Str(Int((result(dat)\njour_or)/7)+1))
    EndIf
    If result(dat)\n1jour = 3
      SetGadgetText(#gadget33,"Semaine "+Str(Int((result(dat)\njour_or-6)/7)+1))
    EndIf
    If result(dat)\n1jour = 4
      SetGadgetText(#gadget33,"Semaine "+Str(Int((result(dat)\njour_or-5)/7)+2))
    EndIf
    If result(dat)\n1jour = 5
      SetGadgetText(#gadget33,"Semaine "+Str(Int((result(dat)\njour_or-4)/7)+2))
    EndIf
    If result(dat)\n1jour = 6
      SetGadgetText(#gadget33,"Semaine "+Str(Int((result(dat)\njour_or-3)/7)+1))
    EndIf
    
    SetGadgetText(#gadget34, "Nombre Ordinal "+Str(result(dat)\njour_or))              ; affiche Jour Ordinal
  EndIf
  
  If dat = 1                                                                           ; affiche en date julien 2
    SetGadgetText(#gadget18,result(dat)\greg2jul$)                   
    SetGadgetText(#gadget36,mois(Val(StringField(result(dat)\jour_mois$, 2,"/"))))     ; affiche mois
    
    ; calcul du numéro de la semaine ISO à partir d'un nombre ordinal
    If result(dat)\n1jour = 0
      SetGadgetText(#gadget37,"Semaine "+Str(Int((result(dat)\njour_or-2)/7)+1))
    EndIf
    If result(dat)\n1jour = 1
      SetGadgetText(#gadget37,"Semaine "+Str(Int((result(dat)\njour_or-1)/7)+1))
    EndIf
    If result(dat)\n1jour = 2
      SetGadgetText(#gadget37,"Semaine "+Str(Int((result(dat)\njour_or)/7)+1))
    EndIf
    If result(dat)\n1jour = 3
      SetGadgetText(#gadget37,"Semaine "+Str(Int((result(dat)\njour_or-6)/7)+1))
    EndIf
    If result(dat)\n1jour = 4
      SetGadgetText(#gadget37,"Semaine "+Str(Int((result(dat)\njour_or-5)/7)+2))
    EndIf
    If result(dat)\n1jour = 5
      SetGadgetText(#gadget37,"Semaine "+Str(Int((result(dat)\njour_or-4)/7)+2))
    EndIf
    If result(dat)\n1jour = 6
      SetGadgetText(#gadget37,"Semaine "+Str(Int((result(dat)\njour_or-3)/7)+1))
    EndIf
    
    SetGadgetText(#gadget38, "Nombre Ordinal "+Str(result(dat)\njour_or))              ; affiche Jour Ordinal
  EndIf
  
  If GetGadgetState(#gadget13) = 0                                                     ;pas d'année zéro
    result(0)\Nbjour2GJ  = 0 
    SetGadgetText(#gadget17,"0")
    SetGadgetText(#gadget20,"  Pas de calculs - Année zéro inexistante")
  Else
    result(0)\Nbjour2GJ = CallFunction(YMD_DLL, "DateToAbsDayNum",GetGadgetState(#gadget13),GetGadgetState(#gadget12),GetGadgetState(#gadget11), Gregorian)
  EndIf
  
  If GetGadgetState(#gadget16) = 0                                                     ;pas d'année zéro
    result(1)\Nbjour2GJ  = 0
    SetGadgetText(#gadget18,"0")   
    SetGadgetText(#gadget20,"  Pas de calculs - Année zéro inexistante")
  Else
    result(1)\Nbjour2GJ = CallFunction(YMD_DLL, "DateToAbsDayNum",GetGadgetState(#gadget16),GetGadgetState(#gadget15),GetGadgetState(#gadget14), Gregorian)
  EndIf
  
  If result(0)\Nbjour2GJ  <> 0 And result(1)\Nbjour2GJ <> 0                           ; affiche différence en jours
    SetGadgetText(#gadget20,Str(result(1)\Nbjour2GJ)+"  -  "+Str(result(0)\Nbjour2GJ)+"  =  "+Str(result(1)\Nbjour2GJ-result(0)\Nbjour2GJ)+"  Jours" )
  EndIf
  
EndProcedure

Procedure calendar(Y, M, D, dat)
  
  If M > 12 : M = 1                         ; test avant calcul en cas d' erreur mois du spingadget avec wheel and fleche actif
  ElseIf M < 1  : M = 12
  EndIf
  If D <= 0 : D = 1 : EndIf                ; test avant calcul en cas d' erreur jour du spingadget avec wheel and fleche actif
  
  ;Cette fonction calcule le jour de la semaine pour la date donnée
  result(dat)\njour = CallFunction(YMD_DLL, "DayOfWeek",Y, M, D, Gregorian)
  
  ;Cette fonction calcule le nom du jour premier janvier de l'année
  result(dat)\n1jour = CallFunction(YMD_DLL, "DayOfWeek",Y, 1, 1, Gregorian)
  
  ;Cette fonction calcule le nombre ordinal du jour dans l'année
  result(dat)\njour_or = CallFunction(YMD_DLL, "MDToDayNum",M, D, Bissextile(dat))
  
  n = result(dat)\njour_or
  ;Cette fonction calcule à partir d'un nombre ordinal le jour dans l'année.
  Result3 = CallFunction(YMD_DLL, "DayNumToMD",n, Bissextile(dat), @M, @D)
  result(dat)\jour_mois$=Str(D)+"/"+Str(M)
  
  ;Cette fonction convertit la date en nombre absolu de jour (pour le calendrier choisi)
  result(dat)\Nbjour2GJ = CallFunction(YMD_DLL, "DateToAbsDayNum",Y, M, D, Gregorian)
  
  n = result(dat)\Nbjour2GJ
  ;Cette fonction convertit le nombre absolu de jour "N(epsilon) {1,2,...2^32}" à la date appropriée (pour le calendrier choisi).
  Result5 = CallFunction(YMD_DLL, "AbsDayNumToDate",n, Gregorian, @Y, @M, @D)
  result(dat)\Nbjour2date$ = Str(D)+"/"+Str(M)+"/"+Str(Y)
  
  Yg=Y:Mg=M:Dg=D
  ;Cette fonction convertit la date grégorienne à la date appropriée Julian
  Result6 = CallFunction(YMD_DLL, "GregorianToJulian",Yg, Mg, Dg, @Yj, @Mj, @Dj)
  result(dat)\greg2jul$ = Str(Dj)+"/"+Str(Mj)+"/"+Str(Yj)
  
  ;Cette fonction convertit la date julienne à la date appropriée grégorien.
  Result7 = CallFunction(YMD_DLL, "JulianToGregorian",Yj, Mj, Dj, @Yg, @Mg, @Dg)
  result(dat)\jul2greg$ = Str(Dg)+"/"+Str(Mg)+"/"+Str(Yg)
  
EndProcedure

Procedure Calculs_Jour(a,b,c,co,dat)
  
  Bissextile(dat) = CallFunction(YMD_DLL, "IsLeapYear",GetGadgetState(c), Gregorian)
  For i = 0 To 5                                         
    SetGadgetColor(#gadget11 + i, #PB_Gadget_FrontColor, RGB(0,0,0))
  Next i
  SetGadgetColor(a, #PB_Gadget_FrontColor , co)                           ; texte spingadget rouge actif
  
  If GetGadgetState(b)  = 2 And Bissextile(dat) = 0: Jm = 28
  ElseIf GetGadgetState(b)  = 2 And Bissextile(dat) = 1 : Jm = 29
  ElseIf GetGadgetState(b)  = 4 Or  GetGadgetState(b) = 6  Or GetGadgetState(b) = 9 Or GetGadgetState(b) = 11 : Jm = 30
  ElseIf GetGadgetState(b)  = 1 Or  GetGadgetState(b) = 3  Or GetGadgetState(b) = 5 Or GetGadgetState(b) = 7 Or  GetGadgetState(b) = 8  Or GetGadgetState(b) = 10 Or GetGadgetState(b) = 12 : Jm = 31
  EndIf
  If GetGadgetState(a) > Jm :SetGadgetState(a,1)                                       ;test roue +
  EndIf
  If GetGadgetState(a) < 1  :SetGadgetState(a,Jm)                                      ;test roue -
  Else
    If Len(Str(GetGadgetState(a))) < 2 : SetGadgetText(a,"0"+Str(GetGadgetState(a)))   ;affichage du 0
    Else     
      SetGadgetText(a,Str(GetGadgetState(a)))
    EndIf
  EndIf
  
  Calculs_Fevrier(a,b,c,dat)                                                     ;second test wheel inc / dec trop rapide
  
  If GetGadgetState(#gadget13) <> 0 And GetGadgetState(#gadget16) <> 0                 ;pas d'an zero
    If GetGadgetState(a) =>1 And GetGadgetState(a) <= 31                    ;test wheel inc / dec trop rapide
      calendar(GetGadgetState(c), GetGadgetState(b), GetGadgetState(a),dat)
    EndIf
  EndIf
  
EndProcedure

Procedure Calculs_Mois(a,b,c,co,dat)
  
  Bissextile(dat) = CallFunction(YMD_DLL, "IsLeapYear",GetGadgetState(c), Gregorian)
  For i = 0 To 5
    SetGadgetColor(#gadget11 + i, #PB_Gadget_FrontColor, RGB(0,0,0))
  Next i
  SetGadgetColor(b, #PB_Gadget_FrontColor , co)                            ; texte spingadget rouge actif
  
  
  If GetGadgetState(b) = 2 And Bissextile(dat) = 0
    If GetGadgetState(a) > 28 :SetGadgetText(a, "28") : SetGadgetState(a,28)
    EndIf
  ElseIf GetGadgetState(b) = 2 And Bissextile(dat) = 1
    If GetGadgetState(a) > 29 :SetGadgetText(a, "29") : SetGadgetState(a,29)
    EndIf
  ElseIf GetGadgetState(b) = 4 Or  GetGadgetState(b) = 6  Or GetGadgetState(b)=9 Or GetGadgetState(b) = 11
    If GetGadgetState(a) = 31 :SetGadgetText(a, "30") : SetGadgetState(a,30)
    EndIf
  EndIf
  
  If GetGadgetState(b) > 12 :SetGadgetState(b,1):  SetGadgetText(b,"01")               ;test roue +
  ElseIf GetGadgetState(b) < 1  :SetGadgetState(b,12):  SetGadgetText(b,"12")         ;test roue -
  Else
    If Len(Str(GetGadgetState(b))) < 2 : SetGadgetText(b,"0"+Str(GetGadgetState(b)))   ;affichage du 0
    Else     
      SetGadgetText(b,Str(GetGadgetState(b)))
    EndIf
  EndIf
  
  Calculs_Fevrier(a,b,c,dat)                                                     ;second test wheel inc / dec trop rapide
  
  If GetGadgetState(#gadget13) <> 0 And GetGadgetState(#gadget16) <> 0                 ;pas d'an zero
    If GetGadgetState(b) =>1 And GetGadgetState(b) <= 12                    ;test wheel inc / dec trop rapide
      calendar(GetGadgetState(c), GetGadgetState(b), GetGadgetState(a),dat)
    EndIf
  EndIf
  
EndProcedure

Procedure Calculs_Annee(a,b,c,co,dat)
  
  For i = 0 To 5
    SetGadgetColor(#gadget11 + i , #PB_Gadget_FrontColor, RGB(0,0,0))
  Next i
  SetGadgetColor(c, #PB_Gadget_FrontColor , co)                            ; texte spingadget rouge actif
  
  SetGadgetText (c,Str(GetGadgetState(c)))
  
  ;Cette fonction détermine si l'année donnée est bissextile dans le calendrier choisi
  Bissextile(dat) = CallFunction(YMD_DLL, "IsLeapYear",GetGadgetState(c), Gregorian)
  
  If GetGadgetState(b) = 2 And Bissextile(dat) = 0
    If GetGadgetState(a) > 28 :SetGadgetText(a, "28") : SetGadgetState(a,28)
    EndIf
  ElseIf GetGadgetState(b) = 2 And Bissextile(dat) = 1
    If GetGadgetState(a) > 29 :SetGadgetText(a, "29") : SetGadgetState(a,29)
    EndIf
  ElseIf GetGadgetState(b) = 4 Or  GetGadgetState(b) = 6  Or GetGadgetState(b)=9 Or GetGadgetState(b) = 11
    If GetGadgetState(a) = 31 :SetGadgetText(a, "30") : SetGadgetState(a,30)
    EndIf
  EndIf
  If GetGadgetState(b) > 12 :SetGadgetState(b,1)                                       ;test roue +
  ElseIf GetGadgetState(b) < 1  :SetGadgetState(b,12)                                 ;test roue -
  Else
    If Len(Str(GetGadgetState(b))) < 2 : SetGadgetText(b,"0"+Str(GetGadgetState(b)))   ;affichage du 0
    Else     
      SetGadgetText(b,Str(GetGadgetState(b)))
    EndIf
  EndIf
  
  Calculs_Fevrier(a,b,c,dat)                                                   ;second test wheel inc / dec trop rapide
  
  If GetGadgetState(#gadget13) <> 0 And GetGadgetState(#gadget16) <> 0                 ;pas d'an zero
    calendar(GetGadgetState(c), GetGadgetState(b), GetGadgetState(a),dat)
  EndIf
  
EndProcedure


If OpenWindow(#window, 0, 0, 400, 290, Space(24)+"CALCULATRICE DE JOURS", #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget)
  
  colorwin=RGB(230,230,230)
  SetWindowColor(#window,colorwin)
  
  Police$ = "arial"
  LoadFont       (#font0, Police$ ,16,#PB_Font_Bold)
  LoadFont       (#font1, Police$ ,12,#PB_Font_Bold)
  LoadFont       (#font2, Police$ ,10,#PB_Font_Bold)
  
  SetGadgetFont  (#PB_Default, FontID(#font0))
  SpinGadget     (#gadget11, 20, 65, 58, 28, 0, 32,#PB_Spin_Numeric)
  SetGadgetState (#gadget11, 6) : SetGadgetText(#gadget11, Str(Day(Date())))          ; définit la valeur initiale du jour
  SpinGadget     (#gadget12, 84, 65, 58, 28, 0, 13,#PB_Spin_Numeric)
  SetGadgetState (#gadget12, 10) : SetGadgetText(#gadget12, Str(Month(Date())))       ; définit la valeur initiale du mois
  SpinGadget     (#gadget13, 148, 65, 88, 28, -9999, 9999,#PB_Spin_Numeric)
  SetGadgetState (#gadget13, 2013) : SetGadgetText(#gadget13,Str(Year(Date())))       ; définit la valeur initiale de l'année
  SpinGadget     (#gadget14, 20, 180, 58, 28, 0, 32,#PB_Spin_Numeric)
  SetGadgetState (#gadget14, 6) : SetGadgetText(#gadget14, Str(Day(Date())))          ; définit la valeur initiale du jour
  SpinGadget     (#gadget15, 84, 180, 58, 28, 0, 13,#PB_Spin_Numeric)
  SetGadgetState (#gadget15, 10) : SetGadgetText(#gadget15, Str(Month(Date())))       ; définit la valeur initiale du mois
  SpinGadget     (#gadget16, 148, 180, 88, 28, -9999, 9999,#PB_Spin_Numeric)
  SetGadgetState (#gadget16, 2013) : SetGadgetText(#gadget16,Str(Year(Date())))       ; définit la valeur initiale de l'année
  
  SetActiveGadget(#gadget11)
  SetGadgetColor (#gadget11, #PB_Gadget_FrontColor , #Red)
  
  ;Texte -------------------------------------------------------------
  TextGadget     (#gadget17, 256,  65, 125, 28, "",#PB_Text_Border|#PB_Text_Right)   ; date initiale julian
  SetGadgetColor (#gadget17, #PB_Gadget_BackColor,RGB(234,234,234))
  TextGadget     (#gadget18, 256, 180, 125, 28, "",#PB_Text_Border|#PB_Text_Right)   ; date Finale julian
  SetGadgetColor (#gadget18, #PB_Gadget_BackColor, RGB(234,234,234))
  
  SetGadgetFont  (#PB_Default, FontID(#font1))
  ContainerGadget(#gadget19, 18, 240, 365, 30, #PB_Container_Raised )
  SetGadgetColor (#gadget19, #PB_Gadget_BackColor,RGB(200,240,140))
  TextGadget     (#gadget20, 15, 3, 346, 28, "0")                           ; nombre total de jours
  SetGadgetColor (#gadget20, #PB_Gadget_BackColor,RGB(200,240,140))
  CloseGadgetList()
  
  ContainerGadget(#gadget21, 18, 10, 365, 32, #PB_Container_Raised )
  SetGadgetColor (#gadget21, #PB_Gadget_BackColor,RGB(200,235,255))
  TextGadget     (#gadget22, 5,  4, 440, 28, "Date  Initiale  en Gregorien   */*   Date en Julien")  ;titre 1
  SetGadgetColor (#gadget22, #PB_Gadget_BackColor,RGB(200,235,255))
  CloseGadgetList()
  
  ContainerGadget(#gadget23, 18, 125, 365, 32,#PB_Container_Raised )
  SetGadgetColor (#gadget23, #PB_Gadget_BackColor,RGB(250,225,160))
  TextGadget     (#gadget24, 5, 4, 440, 28, "Date  Finale  en Gregorien   */*   Date en Julien")     ;titre 2
  SetGadgetColor (#gadget24, #PB_Gadget_BackColor,RGB(250,225,190))
  CloseGadgetList()
  
  SetGadgetFont  (#PB_Default, FontID(#font2))
  
  ContainerGadget(#gadget25, 19,  45, 362, 16 )
  SetGadgetColor (#gadget25, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget26, 2,  0, 75, 16, "")                             ; affiche jour 1
  SetGadgetColor (#gadget26, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget27, 72,  0, 292, 16, "" )                          ; affiche fête 1
  SetGadgetColor (#gadget27, #PB_Gadget_BackColor,colorwin)
  CloseGadgetList()
  
  ContainerGadget(#gadget28, 19,  160, 362, 16 )
  SetGadgetColor (#gadget28, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget29, 2, 0, 75, 16, "")                              ; affiche jour 2
  SetGadgetColor (#gadget29, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget30, 72, 0, 292, 16, "" )                           ; affiche fête 2
  SetGadgetColor (#gadget30, #PB_Gadget_BackColor,colorwin)
  CloseGadgetList()
  
  ContainerGadget(#gadget31, 19,  97, 362, 16 )
  SetGadgetColor (#gadget31, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget32, 4, 0, 75, 16, "" )                             ; affiche mois 1
  SetGadgetColor (#gadget32, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget33, 80, 0, 80, 16, "" )                            ; affiche numéro semaine 1
  SetGadgetColor (#gadget33, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget34, 165, 0, 130, 16, "" )                          ; affiche nombre ordinal 1
  SetGadgetColor (#gadget34, #PB_Gadget_BackColor,colorwin)
  CloseGadgetList()
  
  ContainerGadget(#gadget35, 19,  212, 362, 16 )
  SetGadgetColor (#gadget35, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget36, 4, 0, 75, 16, "" )                             ; affiche mois 2
  SetGadgetColor (#gadget36, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget37, 80, 0, 80, 16, "" )                            ; affiche numéro semaine 2
  SetGadgetColor (#gadget37, #PB_Gadget_BackColor,colorwin)
  TextGadget     (#gadget38, 165, 0, 130, 16, "" )                          ; affiche nombre ordinal 2
  SetGadgetColor (#gadget38, #PB_Gadget_BackColor,colorwin)
  CloseGadgetList()
  
  SetGadgetFont  (#PB_Default, #PB_Default)
  
  ; Spingadget affiche date par défaut
  Calculs_Jour(#gadget14,#gadget15,#gadget16,#Red,1)                        ; date 2
  Affiche_resultats(1,#gadget30)
  Calculs_Jour(#gadget11,#gadget12,#gadget13,#Red,0)                        ; date 1
  Affiche_resultats(0,#gadget27)
  StickyWindow(#window, 1)
  
  Repeat
    Event =              WaitWindowEvent()                                  ;SpinGadget wheel mouse
    Select Event
      Case #PB_Event_Gadget
        Select EventGadget()
          Case #gadget11   
            Calculs_Jour(#gadget11,#gadget12,#gadget13,#Red,0)
            Affiche_resultats(0,#gadget27)
          Case #gadget12
            Calculs_Mois(#gadget11,#gadget12,#gadget13,#Red,0)
            Affiche_resultats(0,#gadget27)
          Case #gadget13
            Calculs_Annee(#gadget11,#gadget12,#gadget13,#Red,0)
            Affiche_resultats(0,#gadget27)
          Case #gadget14
            Calculs_Jour(#gadget14,#gadget15,#gadget16,#Red,1)
            Affiche_resultats(1,#gadget30)
          Case #gadget15
            Calculs_Mois(#gadget14,#gadget15,#gadget16,#Red,1)
            Affiche_resultats(1,#gadget30)
          Case #gadget16
            Calculs_Annee(#gadget14,#gadget15,#gadget16,#Red,1)
            Affiche_resultats(1,#gadget30)
        EndSelect
    EndSelect
  Until Event = #PB_Event_CloseWindow
EndIf
CloseLibrary(YMD_DLL)
End




DataSection
  jour:
  Data.s "Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi"   
  mois:
  Data.s "Janvier","Février","Mars","Avril","Mai","Juin","Juillet","Août","Septembre","Octobre","Novembre","Décembre"
  
  fetes:
  Data.s " Fête du Jour de l'An","Basile","Geneviève","Odilon","Edouard","Mélaine","Raymond","Lucien","Alix","Guillaume"
  Data.s "Pauline","Tatiana","Yvette","Nina","Rémi","Marcel","Roseline","Prisca","Marius","Sébastien"
  Data.s "Agnès","Vincent","Banard","François de Sales"," Conversion de Paul","Paule","Angèle","Thomas d'Aquin"
  Data.s "Gildas","Martine","Marcelle","Ella","la Présentation","Blaise","Véronique","Agathe","Gaston","Eugènie"
  Data.s "Jacqueline","Apolline","Arnaud","Notre Dame de Lourdes","Félix","Béatrice","Valentin","Claude"
  Data.s "Julienne","Alexis","Bernadette","Gabin","Aimée","Damien","Isabelle","Lazare","Modeste","Roméo"
  Data.s "Nestor","Honorine","Romain","Aubin","Charles le Bon","Guénolé","Casimir","Olive","Colette"
  Data.s "Félicité","Jean de Dieu","Françoise","Vivien","Rosine","Justine","Rodrigue","Mathilde","Louise"
  Data.s "Bénédicte","Patrice","Cyrille","Joseph","du Printemps / Rameaux","Clémence","Léa","Victorien","Catherine"
  Data.s "l' Annonciation","Larissa","Habib","Gontran","Gwladys","Amédée","Benjamin","Hugues","Sandrine","Richard"
  Data.s "Isidore","Irène","Marcellin","Jean-Baptiste de la Salle","Julie","Gautier","Fulbert","Stanislas"
  Data.s "Jules","Ida","Maxime","Paterne","Benoît-Joseph","Anicet","Parfait","Emma","Odette","Anselme"
  Data.s "Alexandre","Georges","Fidèle","Marc","Alida","Zita","Valérie","Catherine de Sienne","Robert"
  Data.s " Fête du travail","Boris","Philippe / Jacques","Sylvain","Judith","Prudence","Gisèle","l' Armistice de 1945"
  Data.s "Pacôme","Solange","Estelle","Achille","Rolande","Matthias","Denise","Honoré","Pascal","Eric","Yves"
  Data.s "Bernardin","Constantin","Emile","Didier","Donatien","Sophie","Bérenger","Augustin","Germain","Aymar"
  Data.s "Ferdinand","la Visitation de la Sainte Vierge","Justin","Blandine","Kévin","Clotilde","Igor","Norbert"
  Data.s "Gilbert","Médard","Diane","Landry","Barnabé","Guy","Antoine de Padoue","Elisée","Germaine"
  Data.s "Jean-François / Régis","Hervé","Léonce","Romuald","Silvère","l' Eté","Alban","Audrey","Jean-Baptiste"
  Data.s "Prosper","Anthelme","Fernand","Irénée","Pierre / Paul","Martial","Thierry","Martinien","Thomas"
  Data.s "Florent","Antoine","Mariette","Raoul","Thibault","Amandine","Ulrich","Benoît","Olivier","Henri / Joël"
  Data.s " Fête Nationale","Donald","Notre Dame du Mont Carmel","Charlotte","Frédéric","Arsène","Marina"
  Data.s "Victor","Marie-Madeleine","Brigitte","Christine","Jacques","Anne / Joachin","Nathalie","Samson"
  Data.s "Marthe","Juliette","Ignace de Loyola","Alphonse","Julien / Eymard","Lydie","Jean-Marie Vianney","Abel"
  Data.s "la Transfiguration","Gaétan","Dominique","Amour","Laurent","Claire","Clarisse","Hippolyte","Evrard"
  Data.s "l' Assomption","Armel","Hyacinthe","Hélène","Jean-Eudes","Bernard","Christophe","Fabrice","Rose de Lima"
  Data.s "Barthélémy","Louis","Natacha","Monique","Augustin","Sabine","Fiacre","Aristide","Gilles","Ingrid"
  Data.s "Grégoire","Rosalie","Raïssa","Bertrand","Reine","la Nativité","Alain","Inès","Adelphe","Apollinaire"
  Data.s "Aimé","la Croix Glorieuse","Roland","Edith","Renaud","Nadège","Emilie","Davy","Matthieu","Maurice"
  Data.s "l' Automne","Thècle","Hermann","Côme / Damien","Vincent de Paul","Venceslas","Michel / Gabriel / Raphaël"
  Data.s "Jérôme","Thérèse de l' Enfant Jésus","Léger","Gérard","François d'Assise","Fleur","Bruno"
  Data.s "Serge","Pélagie","Denis","Ghislain","Firmin","Wilfried","Géraud","Juste","Thérèse d'Avila","Edwige"
  Data.s "Baudoin","Luc","René","Adeline","Céline","Elodie","Jean de Capistran","Florentin","Crépin","Dimitri"
  Data.s "Emeline","Jude","Narcisse","Bienvenu","Quentin","la Toussaint"," Fête des Défunts","Hubert","Charles","Sylvie"
  Data.s "Bertille","Carine","Geoffroy","Théodore","Léon","l' Armistice de 1918","Christian","Brice","Sidoine"
  Data.s "Albert","Marguerite","Elisabeth","Aude","Tanguy","Edmond","la Présence de Marie","Cécile","Clément"
  Data.s "Flora","Catherine","Delphine","Sévrin","Jacques de la Marche","Saturnin","André","Florence","Viviane"
  Data.s "François-Xavier","Barbara","Gérald","Nicolas","Ambroise","l' Immaculée Conception","Pierre Fourier"
  Data.s "Romaric","Daniel","Jeanne-Françoise de Chantal","Lucie","Odile","Ninon","Alice","Gaël","Gatien"
  Data.s "Urbain","Théophile","l' Hiver","Françoise-Xavière","Armand","Adèle","Noël","Etienne","Jean"," Fête des Innocents"
  Data.s "David","Roger","Sylvestre","Auguste"
EndDataSection

;######################################################
;http://mikhajduk.houa.org/EN/Links.php
;  (C) Mikołaj Hajduk, 16.06.2008.
;######################################################
Procedure ExpandBinaryfile(fichier.s)
  If CreateFile(0,fichier)
    Lg= ?calendar_dll_End-?calendar_dll_Start
    WriteData(0,?calendar_dll_Start,Lg)
    CloseFile(0)
  EndIf
  ProcedureReturn
EndProcedure
;  IncludeBinary "Calendar.dll" [?Calendar_dll_Start , ?Calendar_dll_End]
;{ Size = 3584 bytes
DataSection
  ; PureBin2Data header
  Data.l 3584
  Data.b 0
  ; Data
  Calendar_dll_Start:
  Data.l $00805A4D,$00000001,$00100004,$0000FFFF,$00000140,$00000000,$00000040,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000080,$0EBA1F0E,$CD09B400,$4C01B821,$685421CD,$70207369,$72676F72,$63206D61,$6F6E6E61
  Data.l $65622074,$6E757220,$206E6920,$20534F44,$65646F6D,$240A0D2E,$00000000,$00000000,$00004550,$0004014C,$485912B8,$00000000
  Data.l $00000000,$210E00E0,$4301010B,$00000000,$00000000,$00000000,$00002000,$00000000,$00000000,$00400000,$00001000,$00000200
  Data.l $00000001,$00000000,$00000004,$00000000,$00005000,$00000400,$0000984B,$00000002,$00001000,$00001000,$00010000,$00000000
  Data.l $00000000,$00000010,$00003000,$000000F4,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00004000,$0000000E,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$7461642E,$00000061
  Data.l $00000048,$00001000,$00000200,$00000400,$00000000,$00000000,$00000000,$C0000040,$646F632E,$00000065,$0000034A,$00002000
  Data.l $00000400,$00000600,$00000000,$00000000,$00000000,$60000020,$6164652E,$00006174,$000000F4,$00003000,$00000200,$00000A00
  Data.l $00000000,$00000000,$00000000,$40000040,$6C65722E,$0000636F,$0000000E,$00004000,$00000200,$00000C00,$00000000,$00000000
  Data.l $00000000,$02000040,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$1E1F1C1F,$1F1F1E1F,$1F1E1F1E,$1E1F1D1F,$1F1F1E1F,$1F1E1F1E,$001F0000,$005A003B
  Data.l $00970078,$00D400B5,$011100F3,$014E0130,$001F0000,$005B003C,$00980079,$00D500B6,$011200F4,$014F0131,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $B8E58955,$00000001,$000CC2C9,$9CE58955,$75FF5253,$1075FF14,$FF0C75FF,$22E80875,$85000001,$BB1174C0,$00000007,$C083D231
  Data.l $F7D21105,$05EB92F3,$FFFFFFB8,$9D5B5AFF,$0010C2C9,$9CE58955,$45F75253,$FFFFFE0C,$8B2975FF,$C0850845,$03792274,$83D8F740
  Data.l $74000C7D,$BBD2310F,$00000064,$D285F3F7,$D0890274,$0B72E8D1,$07EBE8D1,$FFFFFFB8,$0F06EBFF,$B60FC093,$9D5B5AC0,$0008C2C9
  Data.l $9CE58955,$45F75253,$FFFFFE10,$833A75FF,$7201087D,$087D8334,$832E770C,$72010C7D,$105D8B28,$C15B1C8D,$558B02E3,$84B60F08
  Data.l $400FFF13,$0C453900,$E3D10F77,$5384B70F,$00401016,$EB0C4503,$FFFFB805,$5B5AFFFF,$0CC2C99D,$E5895500,$5251539C,$FE0C45F7
  Data.l $75FFFFFF,$087D8343,$B83D7201,$0000016D,$390C4503,$30770845,$8D0C5D8B,$E3C15B1C,$000CB903,$B70F0000,$10164B94,$55390040
  Data.l $E2027708,$10458BF1,$4D8B0889,$8BD12908,$08891445,$05EBC031,$FFFFFFB8,$5B595AFF,$10C2C99D,$E5895500,$5251539C,$FE1445F7
  Data.l $75FFFFFF,$1475FF79,$E80875FF,$FFFFFEE4,$74FFF883,$53C38969,$FF1075FF,$1DE80C75,$83FFFFFF,$5674FFF8,$83084D8B,$017F00F9
  Data.l $A8C18141,$8300592B,$7400147D,$78C18303,$7500F983,$016C2D07,$34EB0000,$B8C38949,$0000016D,$E9C1E1F7,$01C80102,$147D83D8
  Data.l $501D7400,$C889D231,$000019BB,$89F3F700,$C82958C1,$0102E9C1,$02C083C8,$C03102EB,$9D5B595A,$0010C2C9,$9CE58955,$83525153
  Data.l $0F00087D,$0000EE84,$0C45F700,$FFFFFFFE,$00E1850F,$C9310000,$4808458B,$000C7D83,$F8836474,$8B1B7701,$03C7145D,$0000000C
  Data.l $8B1EC083,$0389185D,$A6D3DFB9,$00ACE9FF,$E8830000,$BBD23102,$00023AB1,$048DF3F7,$80048D80,$9104E0C1,$8EAC3D92,$26720000
  Data.l $2D64C183,$00008EAC,$008EAC3D,$83177200,$AC2D64C1,$3D00008E,$00008EAC,$C1830872,$8EAC2D64,$D2310000,$0005B5BB,$C1F3F700
  Data.l $C10102E0,$6DFA8141,$72000001,$6DEA8125,$41000001,$016DFA81,$16720000,$016DEA81,$81410000,$00016DFA,$81077200,$00016DEA
  Data.l $FF424100,$E8510C75,$FFFFFD98,$FF1875FF,$52501475,$FFFE2CE8,$0C7D83FF,$83037400,$E98178E9,$00592BA8,$7F00F983,$458B4901
  Data.l $31088910,$B805EBC0,$FFFFFFFF,$9D5B595A,$0014C2C9,$6AE58955,$1075FF01,$FF0C75FF,$4EE80875,$85FFFFFE,$FF1374C0,$75FF1C75
  Data.l $1475FF18,$E850006A,$FFFFFECC,$FFB805EB,$C9FFFFFF,$550018C2,$006AE589,$FF1075FF,$75FF0C75,$FE1BE808,$C085FFFF,$75FF1374
  Data.l $1875FF1C,$6A1475FF,$99E85001,$EBFFFFFE,$FFFFB805,$C2C9FFFF,$00000018,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00003078,$00000001,$00000008,$00000008,$00003028
  Data.l $00003048,$00003068,$000021D8,$00002145,$000020E5,$0000200C,$000022E4,$00002044,$00002317,$00002090,$00003085,$00003095
  Data.l $000030A5,$000030B0,$000030BA,$000030CC,$000030D7,$000030E9,$00010000,$00030002,$00050004,$00070006,$656C6143,$7261646E
  Data.l $6C6C642E,$73624100,$4E796144,$6F546D75,$65746144,$74614400,$416F5465,$61447362,$6D754E79,$79614400,$546D754E,$00444D6F
  Data.l $4F796144,$65655766,$7247006B,$726F6765,$546E6169,$6C754A6F,$006E6169,$654C7349,$65597061,$4A007261,$61696C75,$476F546E
  Data.l $6F676572,$6E616972,$54444D00,$7961446F,$006D754E,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00002000,$0000000E,$30D030C1,$0000311A,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Data.l $00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000,$00000000
  Calendar_dll_End:
EndDataSection ;}

[PAPIPP]

Bonjour Kernadec
Tout d'abord merci pour ce prg
La meilleure solution pour obtenir la DLL à partir du PRG ASM
C’est de télécharger la dernière version de fasm : http://flatassembler.net/
Et de compiler le prg calendar.asm (il est en format DLL) avec fasmw ( fasm pour window)
La DLL sera créée.
Cela fonctionne parfaitement.
A+
ps : pour éviter les petits soucis avec AVAST au téléchargement, je déactive avast pendant 10 mn (gestion des agents avast)

[kernadec]

bonjour
ATTENTION la librairie Calendar.dll fonctionne qu'avec une version 32bits de PureBasic

[Mise à jour du code précédent]

j'avais encore quelques tours de molette récalcitrants avec les SpinGadgets,
je pense avoir réglé certaines maladresses avec la fonction " Elseif " et les retours gadget.


@ PAPIPP Merci pour Ta réponse

Pour la librairie, je me suis mal exprimé en fait ce que je voulais dire,
C'est qu'étant donné que Purebasic gère en natif les lignes de codes assembleur
avec l'utilisation en début de ligne du symbole " ! ".

Cette option me permettrais d’éviter d'utiliser la librairie "Calendar.dll" qui est propre au système Windows.
C'est pour cela que j'aurais aimé la reconvertir en format de lignes assembleur pour PureBasic
et ainsi obtenir un code source compatible au moins pour sous Linux.

mais je suis débutant en assembleur, Car n'est pas chose facile d'intégrer dans les procédures PureBasic
du code assembleur avec des appels et des retours de paramètres dans les registre FASM "eax" etc..
Et mes tentatives sont restées vaines.

Donc pour mettre en images mes propos.
je post le code "asm" avec des " ; ?? " pour les lignes qui devraient êtres modifiées

Sinon le source assembleur peut être téléchargé sur ce site : http://mikhajduk.houa.org/EN/index.php?f=Links

ATTENTION la librairie Calendar.dll fonctionne qu'avec une version 32bits de PureBasic

Cordialement

Code : Tout sélectionner

; Calendar functions library written With FASM assembler.
;  
; Abilities:
;       * works With dates from the interval of 11 million years:
;               - from 1 Jan 5843880 BCE To 3 Aug 5915100 For the Julian calendar,
;               - from 30 Dec 5844001 BCE To 17 Jan 5915222 For the Gregorian calendar,
;       * convenient conversions between Julian And Gregorian calendars For dates
;         from supported time interval,
;       * calculation of the day of the week For the given date,
;       * calculation of the number of the day in the year,
;       * determining If the given year is leap in chosen calendar,
;       * calculation of the "absolute" day number For the given Date (it could be
;         used To calculation of the distance between two dates).         
;
; (C) Mikolaj Hajduk, 16.06.2008.
;
;! format PE GUI 4.0 DLL
;! entry DllEntryPoint
;! 
;! include 'win32a.inc'
;! 
; Definitions of the used constants.
Global YMD_DLL, Gregorian.l, LeapYearFlag.l,N.l, Y.l, M.l, D.l, Yg.l, Mg.l, Dg.l, Yj.l, Mj.l, Dj.l, n.l,t.l
Global C1,C4,C100,k,J,G

Declare DayOfWeekAsm( Y, M, D, Gregorian)
Declare IsLeapYear( Y, Gregorian)
Declare MDToDayNum( M, D, LeapYearFlag)
Declare DayNumToMD( n, LeapYearFlag, M, D)
Declare DateToAbsDayNum( Y, M, D, Gregorian)
Declare AbsDayNumToDate( N, Gregorian, Y, M, D)
Declare GregorianToJulian( Yg, Mg, Dg, Yj, Mj, Dj)
Declare JulianToGregorian( Yj, Mj, Dj, Yg, Mg, Dg)


Dim Jours.s(6)

Path$ = GetCurrentDirectory() 

; ?? !C1      = 365                   ; Number of days in a normal year.

; ?? !C4      = 4*C1 + 1              ; Number of days in the 4-year cycle (base cycle of the Julian
                                ; calendar).
                                 
; ?? !C100    = 25*C4 - 1             ; Number of days in a "normal" century in the Gregorian calendar
                                ; (i.e. century ending With a normal, 365-day, year).

; ?? !C400    = 4*C100 + 1            ; Number of days in the complete 400-year cycle of the Gregorian
                                ; calendar. 

; ?? !k       = 30
 
; ?? !J       = 194796                ; The constants J And G are equal To the numbers of the complete years

; ?? !G       = 194800                ; of the Julian And Gregorian calendars respectively contained in the 
                                 ; time interval given by "Great Cycle" T.
 
;! 
;! section '.data' Data readable writeable
;! 
; Table containing lengths of months of a normal Year (first 12 elements) And a leap year 
; (Next 12 elements).
;
;! MonthLen        db 31,  28,  31,  30,  31,  30,  31,  31,  30,  31,  30,  31
;!                 db 31,  29,  31,  30,  31,  30,  31,  31,  30,  31,  30,  31
;! 
; Table containing values of the function 'DaySum' For every pair (month number, leap year flag).
;
;! DaySum          dw  0,  31,  59,  90, 120, 151, 181, 212, 243, 273, 304, 334
;!                 dw  0,  31,  60,  91, 121, 152, 182, 213, 244, 274, 305, 335

DataSection
MonthLen:
Data.b 31,  28,  31,  30,  31,  30,  31,  31,  30,  31,  30,  31
Data.b 31,  29,  31,  30,  31,  30,  31,  31,  30,  31,  30,  31
DaySum:
Data.w 0,  31,  59,  90, 120, 151, 181, 212, 243, 273, 304, 334
Data.w 0,  31,  60,  91, 121, 152, 182, 213, 244, 274, 305, 335
EndDataSection

Restore jour
For i=0 To 6
  Read.s jours.s(i) 
Next i

DataSection
jour:
Data.s "Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi"
EndDataSection



Y=2011
M=6
D=24
gregorian=1



Result0 = DayOfWeekAsm( Y, M, D, Gregorian)
;IsLeapYear( Y, Gregorian)
jourCible$=Jours(Result0)
    
Debug "Le "+Str(D)+"/"+Str(M)+"/"+Str(Y)+" est un "+JourCible$   
 
;! section '.code' code readable executable
;! 
;! proc    DllEntryPoint, hinstDLL, fdwReason, lpvReserved
;!         mov     eax, TRUE
;!         ret
;! endp
! 
; DWORD DayOfWeekAsm(DWORD Y, DWORD M, DWORD D, DWORD Gregorian)
;
; This function calculates the day of the week For the given date. Each day of the week is identified by number:
; 0 - Sunday, 1 - Monday, 2 - Tuesday, 3 - Wednesday, 4 - Thursday, 5 - Friday, 6 - Saturday.
;
; Parameters:
;       Y - year,
;       M - month,
;       D - day,
;       Gregorian - chosen calendar (0 - Julian, 1 - Gregorian).
;
; Returned values:
;       * 0, 1, ..., 6 If the date is valid,
;       * -1 For the invalid parameters.
;
Procedure DayOfWeekAsm( Y, M, D, Gregorian)
! 
!         pushfd
!         push    ebx edx
! 
; stdcall DateToAbsDayNum, [Y], [M], [D], [Gregorian]                     ; eax := N
          DateToAbsDayNum( Y, M, D, Gregorian)
;?? eax = DateToAbsDayNum( Y, M, D, Gregorian)
!         test    eax, eax
!         jz      .Error
! 
!         mov     ebx, 7                                                  ;
!         XOr     edx, edx                                                ;
!         add     eax, 5                                                  ; edx := (eax + 5) mod 7 = (N + 5) mod 7
!         adc     edx, edx                                                ;
!         div     ebx                                                     ;
! 
!         xchg    eax, edx                                                ; eax := edx
!         jmp     .End
! 
!         .Error:
!                 mov     eax, -1
!         .End:
! 
!         pop     edx ebx
!         popfd
! 
   ProcedureReturn #True
 EndProcedure

; DWORD IsLeapYear(DWORD Y, DWORD Gregorian)
;
; This function determines If the given year is leap in the chosen calendar.
;
; Parameters:
;       Y - year,
;       Gregorian - chosen calendar (0 - Julian, 1 - Gregorian).
;
; Returned values:
;       * 1 If the year Y is leap, 0 - in opposite Case,
;       * -1 For the invalid parameters.
;
Procedure   IsLeapYear( Y, Gregorian)
! 
!         pushfd
!         push    ebx edx
! 
!         .CheckParameters:
!                 test    [Gregorian], -2                                 ; 0 <= Gregorian <= 1
!                 jnz     .Error                                          ;
! 
!         .IsYNegative:
!                 mov     eax, [Y]                                        ; eax := Y
!                 test    eax, eax
!                 jz      .Error
!                 jns     .CheckCalendar
!                                                                         ; eax < 0 (Y < 0)
!                                                                         ;
!                 inc     eax                                             ; eax := eax + 1
!                 neg     eax                                             ; eax := -eax = -(Y + 1) = -Y - 1 =
!                                                                         ;      = |Y| - [Y < 0] = Y'
! 
!         .CheckCalendar:
!                 cmp     [Gregorian], 0
!                 je      .mod4
! 
!         .Gregorian:
!                 XOr     edx, edx                                        ; eax := E(eax / 100) = E(Y' / 100)
!                 mov     ebx, 100                                        ; edx := eax mod 100 = Y' mod 100
!                 div     ebx                                             ; 
! 
!                 test    edx, edx
!                 jz      .mod4
! 
!                 mov     eax, edx                                        ; eax := edx = Y' mod 100
!                                                                         ; 
!                                                                         ; {(Y' mod 100) mod 4 = Y' mod 4} 
! 
!         .mod4:
!                 shr     eax, 1                                          ; eax := E(eax / 2); CF := eax mod 2
!                 jc      .Result                                         ; 
! 
!                 shr     eax, 1                                          ; eax := E(eax / 2); CF := eax mod 2
!                 jmp     .Result                                         ;
! 
!         .Error:
!                 mov     eax, -1
!                 jmp     .End
! 
!         .Result:
!                 setnc   al                                              ; eax := Not CF
!                 movzx   eax, al                                         ;
! 
!         .End:
! 
!         pop     edx ebx
!         popfd
! 
 ProcedureReturn #True
EndProcedure

; DWORD MDToDayNum(DWORD M, DWORD D, DWORD LeapYearFlag)
;
; This function calculates the ordinal number of the day in the year.
;
; Parameters:
;       M - month,
;       D - day,
;       LeapYearFlag - flag determining If the year is leap (0 - normal year, 1 - leap year).
;
; Returned values:
;       * 1, 2, ..., 365 For the normal year, 1, 2, ..., 366 For the leap year,
;       * -1 For the invalid parameters.
;
Procedure   MDToDayNum( M, D, LeapYearFlag)
! 
!         pushfd
!         push    ebx edx
! 
!         .LeapYearFlag:
!                 test    [LeapYearFlag], -2                              ; 0 <= LeapYearFlag <= 1
!                 jnz     .Error                                          ;
! 
!         .Month:
!                 cmp     [M], 1                                          ;
!                 jb      .Error                                          ; 1 <= M <= 12
!                 cmp     [M], 12                                         ;
!                 ja      .Error                                          ;
! 
!         .Day:
!                 cmp     [D], 1                                          ; D >= 1
!                 jb      .Error                                          ;
! 
!                 mov     ebx, [LeapYearFlag]                             ; ebx := LeapYearFlag
!                 lea     ebx, [ebx + 2*ebx]                              ; ebx := 3*ebx = 3*LeapYearFlag
!                 shl     ebx, 2                                          ; ebx := 4*ebx = 12*LeapYearFlag
! 
!                 mov     edx, [M]                                        ; eax := MonthLen[M - 1 + 12*LeapYearFlag]
!                 movzx   eax, [MonthLen - 1 + ebx + edx]                 ;
! 
!                 cmp     [D], eax                                        ; D <= MonthLen[M - 1 + 12*LeapYearFlag]
!                 ja      .Error                                          ;
! 
!         .CalculateDayNum:
!                 shl     ebx, 1                                          ; ebx := 2*ebx = 24*LeapYearFlag
!                 movzx   eax, [DaySum - 2 + ebx + 2*edx]                 ; eax := DaySum(M, LeapYearFlag)
!                 add     eax, [D]                                        ; eax := eax + D = DaySum(M, LeapYearFlag) + D 
!                 jmp     .End
! 
!         .Error:
!                 mov     eax, -1
! 
!         .End:
! 
!         pop     edx ebx
!         popfd
! 
    ProcedureReturn #True
EndProcedure
 
; DWORD DayNumToMD(DWORD n, DWORD LeapYearFlag, DWORD* M, DWORD* D)
;
; This function converts the ordinal number of the day in the year To the adequate month And day numbers. 
; The result strongly depends on the flag determining If the year is leap.
;
; Parameters:
;       n - number of the day in the year,
;       LeapYearFlag - flag determining If the year is leap (0 - normal year, 1 - leap year),
;       M - pointer To variable where the calculated month number will be stored,
;       D - pointer To variable where the calculated day number will be stored. 
;
; Returned values:
;       * 0 For the valid parameters (n, LeapYearFlag),
;       * -1 in opposite Case.
;
Procedure   DayNumToMD( n, LeapYearFlag, M, D)
! 
!         pushfd
!         push    ebx ecx edx
! 
!         .CheckParameters:
!                 test    [LeapYearFlag], -2                              ; 0 <= LeapYearFlag <= 1
!                 jnz     .Error
! 
!                 cmp     [n], 1                                          ; n >= 1
!                 jb      .Error                                          ;
! 
!                 mov     eax, 365                                        ;
!                 add     eax, [LeapYearFlag]                             ; eax := 365 + LeapYearFlag
!                 cmp     [n], eax                                        ; n <= eax
!                 ja      .Error                                          ;
! 
!         .CalculateMD:
!                 mov     ebx, [LeapYearFlag]                             ; ebx := LeapYearFlag
!                 lea     ebx, [ebx + 2*ebx]                              ; ebx := 3*ebx = 3*LeapYearFlag
!                 shl     ebx, 3                                          ; ebx := 8*ebx = 24*LeapYearFlag
! 
!                 mov     ecx, 12                                         ;
!                                                                         ;
!                 .Loop:                                                  ; ecx := max{i; 1 <= i <= 12, DaySum(i, LeapYearFlag) < n} = m
!                         movzx   edx, [DaySum - 2 + ebx + 2*ecx]         ;
!                         cmp     [n], edx                                ; edx := DaySum(m, LeapYearFlag)
!                         ja      .LoopEnd                                ;
!                         loop    .Loop                                   ;
! 
!                 .LoopEnd:
!                         mov     eax, [M]                                ; M := ecx = m
!                         mov     [eax], ecx                              ;
! 
!                         mov     ecx, [n]                                ; ecx := n
!                         sub     ecx, edx                                ; ecx := ecx - edx = n - DaySum(m, LeapYearFlag)
! 
!                         mov     eax, [D]                                ; D := ecx
!                         mov     [eax], ecx                              ;
! 
!                         XOr     eax, eax
! 
!                         jmp     .End
! 
!         .Error:
!                 mov     eax, -1
! 
!         .End:
! 
!         pop     edx ecx ebx
!         popfd
! 
    ProcedureReturn #True
EndProcedure
 
; DWORD DateToAbsDayNum(DWORD Y, DWORD M, DWORD D, DWORD Gregorian)
;
; This function calculates the absolute day number For the given date.
;
; Parameters:
;       Y - year,
;       M - month,
;       D - day,
;       Gregorian - chosen calendar (0 - Julian, 1 - Gregorian).
;
; Returned values:
;       * 1, 2, ..., 2^32-1 For the valid date in the chosen calendar,
;       * 0 For the invalid parameters.
;
Procedure DateToAbsDayNum( Y, M, D, Gregorian)
! 
!         pushfd
!         push    ebx ecx edx
! 
!         test    [Gregorian], -2                                         ; 0 <= Gregorian <= 1
!         jnz     .Error                                                  ;
! 
;! stdcall IsLeapYear, [Y], [Gregorian]                                   ;
           IsLeapYear( Y, Gregorian)
; ?? eax = IsLeapYear( Y, Gregorian)

!         cmp     eax, -1                                                 ; eax := IsLeapYear(Y, Gregorian)
!         je      .Error                                                  ;
! 
!                                                                         ; Y <> 0
! 
!         mov     ebx, eax                                                ; ebx := eax
! 
;! stdcall MDToDayNum, [M], [D], ebx                                      ;
           MDToDayNum(M,D,ebx)
; ?? eax = MDToDayNum(M,D,ebx)     
!         cmp     eax, -1                                                 ; eax := MDToDayNum(M, D, ebx) = n
!         je      .Error                                                  ;
! 
!         mov     ecx, [Y]                                                ;
!         cmp     ecx, 0                                                  ; ecx := Y
!         jg      .CalculateDayNum                                        ;
! 
!         inc     ecx                                                     ; Y < 0
!                                                                         ; ecx := ecx + 1 = Y + 1 = Y + [Y < 0]
! 
!         .CalculateDayNum:
!                 add     ecx, k*J                                        ; 
!                 cmp     [Gregorian], 0                                  ; ecx := ecx + kJ + k(G-J)[Gregorian = 1] =
!                 je      .Yprim0                                         ;      = Y + [Y < 0] + kJ + k(G-J)[Gregorian = 1] = Y'
!                 add     ecx, k*(G-J)                                    ; 
! 
!         .Yprim0:
!                 cmp     ecx, 0                                          ;
!                 jne     .YprimPositive                                  ; Y' = 0
!                 sub     eax, 364                                        ; eax := eax - 364 = n - 364
!                 jmp     .End                                            ;
! 
!         .YprimPositive:                                                 ; Y' > 0
!                                                                         ;
!                 dec     ecx                                             ; ecx := ecx - 1 = Y' - 1
!                 mov     ebx, eax                                        ; ebx := eax = n
! 
!                 mov     eax, 365                                        ; eax := 365
!                 mul     ecx                                             ; eax := 365 * ecx = 365(Y' - 1)
!                 
!                 shr     ecx, 2                                          ; ecx := E(ecx / 4) = E((Y' - 1) / 4)
!                 add     eax, ecx                                        ; eax := eax + ecx = 365(Y' - 1) + E((Y' - 1) / 4)
!                 add     eax, ebx                                        ; eax := eax + ebx = eax + n =
!                                                                         ;      = 365(Y' - 1) + E((Y' - 1) / 4) + n
! 
!                 cmp     [Gregorian], 0
!                 jz      .End
! 
!         .Gregorian:
!                 push    eax                                             ; X := eax
! 
!                 XOr     edx, edx                                        ;
!                 mov     eax, ecx                                        ; eax := ecx = E((Y' - 1) / 4)
!                 mov     ebx, 25                                         ;
!                 div     ebx                                             ; eax := E(eax / 25) = E(E((Y' - 1) / 4) / 25) =
!                                                                         ;      = E((Y' - 1) / 100)
! 
!                 mov     ecx, eax                                        ; ecx := eax = E((Y' - 1) / 100)
!                 pop     eax                                             ; eax := X = 365(Y' - 1) + E((Y' - 1) / 4) + n
! 
!                 sub     eax, ecx                                        ; eax := eax - ecx = 365(Y' - 1) + E((Y' - 1) / 4) + n -
!                                                                         ;                    - E((Y' - 1) / 100)
! 
!                 shr     ecx, 2                                          ; ecx : = E(ecx / 4) = E(E((Y' - 1) / 100) / 4) =
!                                                                         ;       = E((Y' - 1) / 400)
! 
! 
!                 add     eax, ecx                                        ; eax := eax + ecx = 365(Y' - 1) + E((Y' - 1) / 4) + n -
!                                                                         ;                    - E((Y' - 1) / 100) + E((Y' - 1) / 400)
! 
!                 add     eax, 2                                          ; eax := eax + 2 = 365(Y' - 1) + E((Y' - 1) / 4) + n -
!                                                                         ;                  - E((Y' - 1) / 100) + E((Y' - 1) / 400) + 2 =
!                                                                         ;                = N
! 
!                 jmp     .End
! 
!         .Error:
!                 XOr     eax, eax
! 
!         .End:
! 
!         pop     edx ecx ebx
!         popfd
! 
     ProcedureReturn #True
 EndProcedure

; DWORD AbsDayNumToDate(DWORD N, DWORD Gregorian, DWORD* Y, DWORD* M, DWORD* D)
;
; This function converts the absolute day number N = 1, 2, ..., 2^32-1 To the adequate Date (For the chosen calendar).
;
; Parameters:
;       N - absolute day number,
;       Gregorian - chosen calendar (0 - Julian, 1 - Gregorian),
;       Y - pointer To variable where the calculated year number will be stored,
;       M - pointer To variable where the calculated month number will be stored,
;       D - pointer To variable where the calculated day number will be stored.
;
; Returned values:
;       * 0 For the valid parameters (N, Gregorian),
;       * -1 in opposite Case.
;
Procedure AbsDayNumToDate( N, Gregorian, Y, M, D)
! 
!         pushfd
!         push    ebx ecx edx
! 
!         cmp     [N], 0                                                  ; N <> 0
!         je      .Error                                                  ;
! 
!         test    [Gregorian], -2                                         ; 0 <= Gregorian <= 1
!         jnz     .Error                                                  ;
! 
!         XOr     ecx, ecx                                                ; ecx := 0
!         
!         mov     eax, [N]                                                ; eax := N - 1
!         dec     eax                                                     ;
! 
!         cmp     [Gregorian], 0
!         je      .Julian
! 
!         .Gregorian:
!                 cmp     eax, 1
!                 ja      .NextDays
! 
!                                                                         ; 0 <= eax <= 1 (1 <= N <= 2)
! 
!                 mov     ebx, [M]                                        ; M := 12
!                 mov     dword [ebx], 12                                 ;
! 
!                 add     eax, 30                                         ; eax := eax + 30 = N - 1 + 30 = N + 29 
! 
!                 mov     ebx, [D]                                        ; D := eax = N + 29
!                 mov     [ebx], eax                                      ;
! 
!                 mov     ecx, -k*G - 1                                   ; ecx := -kG - 1
! 
!                 jmp     .ReturnY
! 
!         .NextDays:                                                      ; eax > 1 (N > 2)
! 
!                 sub     eax, 2                                          ; eax := eax - 2 = N - 1 - 2 = N - 3
! 
!                 XOr     edx, edx                                        ;
!                 mov     ebx, C400                                       ; eax := E(eax / C400) = E((N - 3) / C400)
!                 div     ebx                                             ; edx := eax mod C400 = (N - 3) mod C400
! 
!                 lea     eax, [eax + 4*eax]                              ; eax := 5*eax = 5*E((N - 3) / C400)
!                 lea     eax, [eax + 4*eax]                              ; eax := 5*eax = 5*(5*E((N - 3) / C400)) =
!                                                                         ;              = 25*E((N - 3) / C400)
! 
!                 shl     eax, 4                                          ; eax := 16*eax = 16*(25*E((N - 3) / C400)) =
!                                                                         ;               = 400*E((N - 3) / C400)
! 
!                 xchg    ecx, eax                                        ; ecx := eax = 400*E((N - 3) / C400)
!                                                                         ; 
! 
!                 xchg    eax, edx                                        ; eax := edx = (N - 3) mod C400
!                                                                         ; 
! 
!                 .Centuries:                                             ;
!                         cmp     eax, C100                               ;
!                         jb      .Julian                                 ;
!                                                                         ;
!                         add     ecx, 100                                ;
!                         sub     eax, C100                               ;
!                                                                         ;
!                         cmp     eax, C100                               ; (eax, ecx) := P(eax, ecx) = 
!                         jb      .Julian                                 ;             = P((N - 3) mod C400, 400*E((N - 3) / C400)) =
!                                                                         ;             = (N100, Y100)
!                         add     ecx, 100                                ;
!                         sub     eax, C100                               ;
!                                                                         ;
!                         cmp     eax, C100                               ;
!                         jb      .Julian                                 ;
!                                                                         ;
!                         add     ecx, 100                                ;
!                         sub     eax, C100                               ;
! 
!         .Julian:
!                                                                         ;                             /
!                                                                         ;                             |  (N - 1, 0)                                 ; Gregorian = 0
!                                                                         ; (N100, Y100) = (eax, ecx) = <
!                                                                         ;                             |  P((N - 3) mod C400, 400*E((N - 3) / C400)) ; Gregorian = 1
!                                                                         ;                             \
! 
!                 XOr     edx, edx                                        ;
!                 mov     ebx, C4                                         ; eax := E(eax / C4) = E(N100 / C4)
!                 div     ebx                                             ; edx := eax mod C4 = N100 mod C4
! 
!                 shl     eax, 2                                          ; eax := 4*eax = 4*E(N100 / C4)
! 
!                 add     ecx, eax                                        ; ecx := ecx + eax = Y100 + 4*E(N100 / C4)
! 
!                 .Years:                                                 ;
!                         inc     ecx                                     ;
!                         cmp     edx, C1                                 ;
!                         jb      .MD                                     ;
!                                                                         ;
!                         sub     edx, C1                                 ;
!                                                                         ;
!                         inc     ecx                                     ; (edx, ecx) := Q(edx, ecx) =
!                         cmp     edx, C1                                 ;             = Q(N100 mod C4, Y100 + 4*E(N100 / C4)) =
!                         jb      .MD                                     ;             = (N', Y*)
!                                                                         ;
!                         sub     edx, C1                                 ;
!                                                                         ;
!                         inc     ecx                                     ;
!                         cmp     edx, C1                                 ;
!                         jb      .MD                                     ;
!                                                                         ;
!                         sub     edx, C1                                 ;
!                                                                         ;
!                         inc     ecx                                     ;
! 
!         .MD:
!                 inc     edx                                             ; edx := edx + 1 = N' + 1
! 
;!      stdcall IsLeapYear, ecx, [Gregorian]                              ; eax := IsLeapYear(ecx, Gregorian) =
;!      ??  mov [Y],ecx
                 IsLeapYear( Y, Gregorian)
;       ?? eax = IsLeapYear( Y, Gregorian)                                                              ;      = IsLeapYear(Y*, Gregorian)
! 
;!       stdcall DayNumToMD, edx, eax, [M], [D]                           ; eax := DayNumToMD(edx, eax, M, D) =
;!      ??  mov [n],edx 
;!      ??  mov [LeapYearFlag], eax
                 DayNumToMD( n, LeapYearFlag, M, D)
;!      ?? eax = DayNumToMD( n, LeapYearFlag, M, D)                       ;      = DayNumToMD(N' + 1, IsLeapYear(Y*, Gregorian), M, D)
! 
!                 cmp     [Gregorian], 0
!                 je      .JulianYears
! 
!                 .GregorianYears:                                        ;
!                         sub     ecx, k*(G - J)                          ;
!                                                                         ; ecx := ecx - kJ - k(G - J)[Gregorian = 1] =
!                 .JulianYears:                                           ;      = Y* - kJ - k(G - J)[Gregorian = 1] = 
!                         sub     ecx, k*J                                ;      = Y'
! 
!                         cmp     ecx, 0
!                         jg      .ReturnY
!                                                                         ; ecx <= 0 (Y' <= 0)
! 
!                         dec     ecx                                     ; ecx := ecx - 1 = Y' - 1 = Y' - [Y' <= 0]
! 
!                 .ReturnY:
!                         mov     eax, [Y]                                ; Y := ecx
!                         mov     [eax], ecx                              ;
! 
!                 XOr     eax, eax
!                 jmp     .End
! 
!         .Error:
!                 mov     eax, -1
! 
!         .End:
! 
!         pop     edx ecx ebx
!         popfd
! 
   ProcedureReturn #True
EndProcedure

; DWORD GregorianToJulian(DWORD Yg, DWORD Mg, DWORD Dg, DWORD* Yj, DWORD* Mj, DWORD* Dj)
;
; This function converts the Gregorian date To the adequate Julian date.
;
; Parameters:
;       Yg - year of the Gregorian date,
;       Mg - month of the Gregorian date,
;       Dg - day of the Gregorian date,
;       Yj - pointer To variable where the calculated year number of the Julian date will be stored,
;       Mj - pointer To variable where the calculated month number of the Julian date will be stored,
;       Dj - pointer To variable where the calculated day number of the Julian date will be stored.
;
; Returned values:
;       * 0 For the valid Gregorian date,
;       * -1 in opposite Case.
;
Procedure GregorianToJulian( Yg, Mg, Dg, Yj, Mj, Dj)
! 
!         .GregorianToNum:
;!        stdcall DateToAbsDayNum, [Yg], [Mg], [Dg], 1
                  DateToAbsDayNum( Yg, Mg, Dg, 1)
;        ?? eax = DateToAbsDayNum( Yg, Mg, Dg, 1)
!                 test    eax, eax
!                 jz      .Error
! 
!         .NumToJulian:
;!        stdcall AbsDayNumToDate, eax, 0, [Yj], [Mj], [Dj]
;!       ?? mov [N],eax
                  AbsDayNumToDate( N, 0, Yj, Mj, Dj)
;        ?? eax = AbsDayNumToDate( N, 0, Yj, Mj, Dj)
!                 jmp     .End
! 
!         .Error:
!                 mov     eax, -1
! 
!         .End:
! 
    ProcedureReturn #True
EndProcedure
 
; DWORD JulianToGregorian(DWORD Yj, DWORD Mj, DWORD Dj, DWORD* Yg, DWORD* Mg, DWORD* Dg)
;
; This function converts the Julian date To the adequate Gregorian date.
;
; Parameters:
;       Yj - year of the Julian date,
;       Mj - month of the Julian date,
;       Dj - day of the Julian date,
;       Yg - pointer To variable where the calculated year number of the Gregorian date will be stored,
;       Mg - pointer To variable where the calculated month number of the Gregorian date will be stored,
;       Dg - pointer To variable where the calculated day number of the Gregorian date will be stored.
;
; Returned values:
;       * 0 For the valid Julian date,
;       * -1 in opposite Case.
;
Procedure JulianToGregorian( Yj, Mj, Dj, Yg, Mg, Dg)
! 
!         .JulianToNum:
;!        stdcall DateToAbsDayNum, [Yj], [Mj], [Dj], 0
                  DateToAbsDayNum( Yj, Mj, Dj, 0)
;       ?? eax =  DateToAbsDayNum( Yj, Mj, Dj, 0)
!                 test    eax, eax
!                 jz      .Error
!         .NumToGregorian:
;!        stdcall AbsDayNumToDate, eax, 1, [Yg], [Mg], [Dg]
;       ?? mov [N],eax
                  AbsDayNumToDate( N, 1, Yg, Mg, Dg)
;       ?? eax =  AbsDayNumToDate( N, 1, Yg, Mg, Dg)
!                 jmp     .End
! 
!         .Error:
!                 mov     eax, -1
! 
!         .End:
! 
    ProcedureReturn #True
EndProcedure


;! section '.edata' export Data readable
;! 
;!         export  'Calendar.dll',\
;!                 AbsDayNumToDate,        'AbsDayNumToDate',\
;!                 DateToAbsDayNum,        'DateToAbsDayNum',\
;!                 DayNumToMD,             'DayNumToMD',\
;!                 DayOfWeekAsm,           'DayOfWeekAsm',\
;!                 GregorianToJulian,      'GregorianToJulian',\
;!                 IsLeapYear,             'IsLeapYear',\
;!                 JulianToGregorian,      'JulianToGregorian',\
;!                 MDToDayNum,             'MDToDayNum'
;! 
;! 
;! section '.reloc' fixups Data discardable

[Backup]

C'est qu'étant donné que Purebasic gère en natif les lignes de codes assembleur
avec l'utilisation en début de ligne du symbole " ! ".
[/code]

il me semble que le "!" n'est pas obligatoire si dans les options de compilation tu choisis "Activer l'assembleur en ligne" ...

[falsam]

il me semble que le "!" n'est pas obligatoire si dans les options de compilation tu choisis "Activer l'assembleur en ligne" ...

Cette option n'existe plus ....... a moins que je sois aveugle

[kernadec]

bonjour

Code : Tout sélectionner

Et pour cause d'un test insuffisant pour le calcul du numéro de la semaine 
à partir du nombre ordinal de l'année.   :oops: 


Cordialement

[PAPIPP]

Bonjour à tous et plus particulièrement à Kernadec Falsam et Dobro
Je ne sais si ce topo doit figurer ici ou pas, déplacer le dans le cas contraire.
Voici quelques infos sur l’utilisation de l’ASM sous PB et plus particulièrement sous PB520
Avant de poursuivre Il est nécessaire de faire remarquer que pour utiliser ASM sous PB
Il faut d’une part connaître FASM mais aussi les conventions d’interfaçage entre PB et ASM.

Si vous venez de MASM ou TASM(1) ce qui est le plus fréquent car la plupart des documentations ASM sont basées sur ces 2 assembleurs
il y a une différence de syntaxe avec FASM qui risque de vous poser des problèmes de compréhension. L'adressage de la mémoire se fait d'une façon qui peut paraitre tordue au premier abord.
La définition d'une variable s'écrit comme avant:

var DD 5 ; un DWORD initialisé à 5

Cependant lorsque vous utiliserez l'identifiant var, FASM le remplacera par l'adresse de var, pas par son contenu.
Ce qui est Intéressant à partir de là c'est que les crochets [] deviennent un opérateur simple à comprendre : Ils servent à accéder à une donnée en mémoire. L’adresse de cette donnée est fournie entre LES crochets
.Avec MASM LES crochets ne sont pas nécessaires pour faire un accès mémoire.
Concrètement: pour FASM

MOV eax,var ; copie l'adresse de var dans EAX
MOV eax, [var] ; crochets => accès mémoire
; ; l'adresse du DWORD lu est celui de var, donc on
; ; copie dans EAX le contenu de var (5)

MOV eax, [ebx+ecx*4] ; crochets => accès mémoire
; ; l'adresse du DWORD lu est obtenue en
; ; calculant ebx + ecx*4
; ; (c'est la même syntaxe qu'avec MASM ou TASM)

En comparaison la syntaxe MASM aurait donné:

MOV eax,offset var
MOV eax,var ; mov eax, [var] est équivalent, mais c'est peu utilisé
MOV eax, [ebx+ecx*4]
Il y a bien sûr d'autres différences mais la plupart ne sont pas vraiment importantes.
LES instructions elles-mêmes s'écrivent le plus souvent de la même façon, il ne vous reste donc plus qu'à apprendre

Maintenant voyons les ‘conventions’ d’interfaçage entre PB et FASM
Le Prg proposé ci-dessous ne peut servir que d'exemple il n'est pas fonctionnel.
S'il vous manque les macros _N() ou _H() aller les chercher http://www.purebasic.fr/french/viewtopi ... =6&t=13296 à la date du 23/10:2013
Attention à la case en ASM.Respecter la même pour des procédures ou des variables PB.

Code : Tout sélectionner

; Pour utiliser les infos Pb dans ASM suivant les différents cas observez les consignes suivantes et
;                        observez la Case en ASM même pour des références PB
;   ! fstp tword [v_infglob]                ; Attention avec global     v_nominfo
;   ! fstp tword [so_TF_DECOMPOSENN.v_vten] ; Attention avec static     so_nomprocedure.v_nominfo  : ==> avec PB520
;   ! fstp tword [s_TF_DECOMPOSENN.v_vten]  ; Attention avec static     s_nomprocedure.v_nominfo  : ==> avec < à PB520
;   ! fstp tword [p.v_infprot]              ; Attention avec protected  p.v_nominfo
;   ! fstp tword [v_infshare]               ; Attention avec share      v_nominfo
;   ! fstp tword [p.v_infsimple]            ; Attention avec rien       p.v_nominfo
;                  ATTENTION pour les pointeurs remplacer v_ par p_
;         Pour les jump si l'étiquette est en ASM alors on la cite normalement en tenant compte de la case
;                       si l'étiquette est en PB alors on cite l'étiquette précédé de l_  suivi de létiquette attention à la case
;                                                  et si l'on est dans une procedure l_nomprocedure_etiquette attention à la case
; ***************************************************************************************************************
;;************  Exemple :
;   Deux_procx.q=2   ; Variable PB
;   JMP l_saut_procx                              ; Attention le label PB doit être précédé de l_
;   !deux_procx dq 2 ; Variable ASM               ; Attention la variable  nommée ici deux_procx garde son nom
;   saut_procx:      ;--------> ici étiquette PB
;   ;  !saut_asmx   ;--------> ici étiquette ASM
;   ;   ! fild qword [deux_procx]      ; Attention si vous utilisez la définition ASM la définition reste inchange
;   ! fild qword [p.v_Deux_procx]      ; Attention l'info Pb doit être précédé de p.v_
;   ; Remarques : pour fonctionner correctement une seule des instructions ci-dessus peut être active placez l'autre en commentaire
;************************************   étiquette anonyme ********************************************
;   	; Le nom de @@: signifie étiquette anonyme,vous pouvez avoir défini un grand nombre d'entre eux dans la source.
;Symbole @b(ou l'équivalent @r)le plus proche des références du label précédent anonyme
;,symbole @f références plus proche de l'étiquette suivante anonyme.
;Ces symboles spéciaux sont insensibles à la casse.

;*******************************  TESTS EN ASM ********************************************************************
; 					CMP al,10
; ************ test sur nombre non sign
;            tous les jxx sont limtés  -127 +128 octets
;             combiner les avec LES JMP long de 32767 octets
; 					aprs cmp A,B
;            A>B JNBE ou JA           CF=0 et ZF=0
;            A>= JNB ou JAE ou JNC    CF=0
;            A<=B JBE ou JNA
;            A<B JB ou JNAE ou JC
;            A=B JE ou JZ
;            A<>B JNE ou JNZ
; ************ test sur nombre sign
; 					aprs cmp A,B
;            A>B JG ou JNLE
;            A>= JGE ou JNL
;            A<=B JNG ou JLE
;            A<B  JNGE ou JL
;            A=B JE ou JZ
;            A<>B JNE ou JNZ
; ************ test des indicateurs
; 					aprs cmp A,B
;            JE ou JZ saut si ZF=1 jump si egal ou zro
;            JNE ou JNZ saut si ZF=0 jump si pas egal ou pas zro
;            JC      saut si CP =1   Jump si Carry
;            JNC     saut si CP=0    jump si non Carry
;            JS     saut si SP=1   jump si Signe
;           JNS     saut si SP=0  jump si non Signe
;            JO     saut si OF=1   jump si Owerflow
;           JNS    saut si OF=0   jump si pas Owerflow
;********************************************************************************************************************
;   Debug _n(#PB_Byte)   ;  #PB_Byte=0    La valeur est un octet (8-bit) allant de 0 à 255
;   Debug _n(#PB_Ascii)  ;  #PB_Ascii=8   La valeur est un octet (8-bit) allant de 0 à 255
;   Debug _n(#PB_Word )  ;  #PB_Word=1    La valeur est un word (16-bit) allant de 0 à 65536
;   Debug _n(#PB_Unicode);  #PB_Unicode=9 La valeur est un word (16-bit) allant de 0 à 65536
;   Debug _n(#PB_Long )  ;  #PB_Long=2    La valeur est un long (32-bit) allant de 0 à 4294967296
;   Debug _n(#PB_Quad)   ;  #PB_Quad=4    La valeur est un quad (64-bit) allant de 0 à 18446744073709551615
; ; #PB_Byte=0
;
;
;
;
;
Global GVPL.l,GVS.s,GV${8},GVSF.s{8},GRVPL.l,GVS.s,GRV${8},GRVSF.s{8}
GVPL=$12345678
GVS="Pierre D"
GV$="Durand_Dur"
GVSF="ARGENTEUIL"

Procedure.L  essai1(*Point.string,Long.l)
  Static STVPL.l,STVS.S,STV${8},STVSF.s{8},*STPL
  Define NVPL.l,NVS.s,NV${8},NVSF.s{8},*NPL
  Shared SVPL.l,SVS.S,SV${8},SVSF.s{8},*SPL
  Protected PVPL.l,PVS.S,PV${8},PVSF.s{8},*PPL
  NVS="Pierre D"
  NVSF="ARGENTEUIL"
  NVPL=$12345678
  aa=long
  Macro db_SR()
    ;     !PUSH esp
    !PUSHA ;   -> pour 32 bits PUSH A pour tout type
    ;     !push EAX
    Define.l REAX,REBX,RECX,REDX,RESI,REDI,RESP,REBP,RCS,RDS,RES,RSS,RFS,RGS,REIP
    !MOV [p.v_REAX],EAX
    !MOV [p.v_REBX],EBX
    !MOV [p.v_RECX],ECX
    !MOV [p.v_REDX],EDX
    !MOV [p.v_RESI],ESI
    !MOV [p.v_REDI],EDI
    !MOV [p.v_RESP],ESP
    !MOV [p.v_REBP],EBP
    !MOV word [p.v_RCS],CS
    !MOV word [p.v_RDS],DS
    !MOV word [p.v_RES],ES
    !MOV word [p.v_RSS],SS
    !MOV word [p.v_RFS],FS
    !MOV word [p.v_RGS],GS
    ;   !MOV word [p.v_REIP],EIP
    PrintN(_NL+_Hl(REAX)+_hl(REBX)+_Hl(RECX)+_Hl(REDX)+_HL(RESI)+#CRLF$+_NL+_HL(REDI)+_HL(RESP)+_HL(REBP)+_HL(RCS)+_HL(RDS))
    
    ;     !pop EAX
    !POPA
    ;     !pop esp
  EndMacro
  ;   db_Sr()
  ;********************* INFOS GLOBALES ****************
  
  PrintN("***************** Mode INFO global vers REG  avec !  ***"+_n(GVPL)+_H(GVPL))
  !lea EAX,[v_GVPL]
  ;   !lea EBX, v_GVPL ;erreur sur cette info normal
  !mov EBX,v_GVPL
  !MOV ECX,[v_GVPL]
  db_sr()
  PrintN(" ")
  
  PrintN("***************** Mode INFO global vers REG avec enableasm   ***"+_n(GVPL)+_H(GVPL))
  EnableASM
  LEA EAX,[v_GVS]
  MOV EBX,v_GVS
  MOV ECX,[v_GVS]
  DisableASM
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO paramétre *point de la procedure  avec !  ***"+_n(GVPL)+_H(GVPL))
  ;   *Point.string,Long.l
  !LEA EAX, [p.p_Point]
  ;   !LEA EBX, p.p_Point
  ;   !MOV ECX, p.p_Point
  !MOV EDX,[p.p_Point]
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO paramétre *point de la procedure  avec enableasm   ***"+_n(GVPL)+_H(GVPL))
  ;   *Point.string,Long.l
  EnableASM
  LEA EAX, [p.p_Point]
  ;   LEA EBX, p.p_Point
  ;   MOV ECX, p.p_Point
  MOV EDX,[p.p_Point]
  DisableASM
  db_sr()
  
  PrintN(" ")
  PrintN("**************** Mode INFO paramétre Long de la procedure  avec !  ***"+_n(GVPL)+_H(GVPL))
  ;   *Point.string,Long.l
  !LEA EAX, [p.v_Long]
  ;   !LEA EBX, p.p_Point
  ;   !MOV ECX, p.v_Long
  !MOV EDX, [p.v_Long]
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO paramétre Long de la procedure  avec enableasm   ***"+_n(GVPL)+_H(GVPL))
  ;   *Point.string,Long.l
  EnableASM
  LEA EAX, [p.v_Long]
  ;   !LEA EBX, p.p_Point
  ;   !MOV ECX, p.v_Long
  MOV EDX, [p.v_Long]
  DisableASM
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO variable shared  de la procedure  avec !  ***"+_n(GVPL)+_H(GVPL))
;   SVPL.l,SVS.S,SV${8},SVSF.s{8}
  !lea EAX,[v_SVPL]
  !mov EBX,v_SVSF
  !mov ECX,dword [v_SVSF]
  !MOV EDX,[p_SPL]
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO variable shared de la procedure  avec enableasm   ***"+_n(GVPL)+_H(GVPL))
  ;   SVPL.l,SVS.S,SV${8},SVSF.s{8}
  EnableASM
  LEA EAX,[v_SVPL]
  MOV EBX,v_SVSF
  MOV ECX,dword [v_SVSF]
  MOV EDX,[p_SPL]
  DisableASM
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO variable  static de la procedure  avec !  ***"+_n(GVPL)+_H(GVPL))
  ;  STVPL.l,STVS.S,STV${8},STVSF.s{8},*STPL 
  ; avec static so_nomprocedure.v_nominfo 
  !lea EAX,[so_essai1.v_STVPL]
  !mov EBX,so_essai1.v_STVSF
  !mov ECX,dword [so_essai1.v_STVSF]
  !MOV EDX,[so_essai1.p_STPL]
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO variable static de la procedure  avec enableasm   ***"+_n(GVPL)+_H(GVPL))
;  STVPL.l,STVS.S,STV${8},STVSF.s{8},*STPL 
  EnableASM
  LEA EAX,[so_essai1.v_STVPL]
  MOV EBX,so_essai1.v_STVSF
  MOV ECX,dword [so_essai1.v_STVSF]
  MOV EDX,[so_essai1.p_STPL]
  DisableASM
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO variable  normale de la procedure  avec !  ***"+_n(GVPL)+_H(GVPL))
  ;  NVPL.l,NVS.s,NV${8},NVSF.s{8},*NPL
  ;    Attention avec rien       p.v_nominfo  
  !LEA EAX,[p.v_NVPL]
;   !mov EBX,p.v_NVSF erreur
  !mov ECX,dword [p.v_NVSF]
  !MOV EDX,[p.p_NPL]
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO variable normal de la procedure  avec enableasm   ***"+_n(GVPL)+_H(GVPL))
  ;  NVPL.l,NVS.s,NV${8},NVSF.s{8},*NPL
  ;    Attention avec rien       p.v_nominfo  !LEA EAX,[p.v_NVPL]
  EnableASM
  LEA EAX,[p.v_NVPL]
;   mov EBX,p.v_NVSF erreur
  MOV ECX,dword [p.v_NVSF]
  MOV EDX,[p.p_NPL]
;   DisableASM
  db_sr()
;   
  PrintN(" ")
  PrintN("**************** Mode INFO variable  Protected de la procedure  avec !  ***"+_n(GVPL)+_H(GVPL))
  ;  PVPL.l,PVS.S,PV${8},PVSF.s{8},*PPL
  ;  Attention avec protected  p.v_nominfo 
  !LEA EAX,[p.v_PVPL]
;   !mov EBX,p.v_PVSF erreur
  !mov ECX,dword [p.v_PVSF]
  !MOV EDX,[p.p_PPL]
  db_sr()
  PrintN(" ")
  
  PrintN("**************** Mode INFO variable Protected de la procedure  avec enableasm   ***"+_n(GVPL)+_H(GVPL))
  ;  PVPL.l,PVS.S,PV${8},PVSF.s{8},*PPL
  ;   Attention avec protected  p.v_nominfo
  EnableASM
  LEA EAX,[p.v_PVPL]
  LEA EBX,[p.v_PVSF] ;erreur
  MOV ECX,dword [p.v_PVSF]
  MOV EDX,[p.p_PPL]
  DisableASM
  db_sr()
  
  
;      ; ******** Définition et saut en PB et en ASM avec ! ********
  !JMP l_essai1_saut_proc3                              ; Attention le label PB doit être précédé de l_
  Deux_proc3.q=2   ; Variable PB
  saut_proc3:      ;--------> ici étiquette PB
  !JMP saut_asm3                             ; Attention le label PB doit être précédé de l_
  !deux_asm3 dq 2 ; Variable ASM               ; Attention la variable  nommée ici deux_asmx garde son nom
  !saut_asm3:   ;--------> ici étiquette ASM
  !fild qword [deux_asm3]       ; Attention si vous utilisez la définition ASM la définition reste inchange
  !fild qword [p.v_Deux_proc3]      ; Attention l'info Pb doit être précédé de p.v_

; 
  ;      ; ******** Définition et saut en PB et en ASM avec enableasm ********

   EnableASM
  JMP l_essai1_saut_proc4                             ; Attention le label PB doit être précédé de l_essai1_
  Deux_proc4.q=2   ; Variable PB
  saut_proc4:      ;--------> ici étiquette PB
  JMP saut_asm4                              ; Attention le label PB doit être précédé de l_
  !deux_asm4 dq 2 ; Variable ASM               ; Attention la variable  nommée ici deux_asmx garde son nom
  !saut_asm4:   ;--------> ici étiquette ASM
  FILD qword [deux_asm4]       ; Attention si vous utilisez la définition ASM la définition reste inchange
  FILD qword [p.v_Deux_proc4]      ; Attention l'info Pb doit être précédé de p.v_
 DisableASM

; fin:
ProcedureReturn @SVS
EndProcedure
Define MNVPL.l,MNVS.s,MNV${8},MNVSF.s{8}

OpenConsole()
EnableGraphicalConsole(0)
ConsoleLocate(0,0)
ConsoleTitle(GVS)

   ; ******** Définition et saut en PB et en ASM avec ! ********
  !JMP l_saut_procx                              ; Attention le label PB doit être précédé de l_
  Deux_procx.q=2   ; Variable PB
  saut_procx:      ;--------> ici étiquette PB
  !JMP saut_asmx                              ; Attention le label PB doit être précédé de l_
  !deux_asmx dq 2 ; Variable ASM               ; Attention la variable  nommée ici deux_asmx garde son nom
  !saut_asmx:   ;--------> ici étiquette ASM
  !fild qword [deux_asmx]       ; Attention si vous utilisez la définition ASM la définition reste inchange
  !fild qword [v_Deux_procx]      ; Attention l'info Pb doit être précédé de v_  (Prg principal)

     ; ******** Définition et saut en PB et en ASM avec enableasm pour les instruction ou c'est possible********
 EnableASM
  JMP l_saut_proc2                              ; Attention le label PB doit être précédé de l_
  Deux_proc2.q=2   ; Variable PB
  saut_proc2:      ;--------> ici étiquette PB
  JMP saut_asm2                              ; Attention le label PB doit être précédé de l_
  !deux_asm2 dq 2 ; Variable ASM               ; Attention la variable  nommée ici deux_asmx garde son nom
  !saut_asm2:   ;--------> ici étiquette ASM
  FILD qword [deux_asm2]       ; Attention si vous utilisez la définition ASM la définition reste inchange
  FILD qword [v_Deux_proc2]      ; Attention l'info Pb doit être précédé de v_   (Prg principal)
 DisableASM




MNVPL=$1234567
MNVS="Pierre D_"
MNV$="Durand_"
MNVSF="ARGENTEUIL_"
PrintN(_NL+_H(@MNV$)+_n(Len(MNV$)))
AA.l=essai1(@MNV$,Len(MNV$))
PrintN(_NL+_s(AA$))
PrintN (_NL+_H(@MNV$)+_n(Len(MNV$)))
;PrintN(m_h(@MNV$,16,1))
Input()
CloseConsole()

Une des grandes différences entre asm avec ! et celui défini entre enableasm /disableasm
celui qui est défini entre enableasm/disableasm peut être déboguer (arrêt sur instruction et voir les registres dans Débogueur/désassembleur).
A+

[kernadec]

bonjour PAPIPP

merci beaucoup de ton aide.
cela ma permis entre autre de comprendre l'importance de l'instruction "Lea",
Et de lire la doc avec attention à son sujet en comparaison avec 'mov' & 'movzx'

je vais étudier tes exemples, mais heureusement que les longues soirées d'hiver arrivent.

Cordialement

[Kwai chang caine]

Qu'est ce que c'est beau l'ASM
J'y boirais comme du petit lait si seulement je comprenais ne serais-ce qu'une ligne...avec certe quelques aigreurs d'estomac, car c'est quelque chose

Mais j'en suis pas la, j'arrive même pas a le lancer le code
Je sais pas ce que j'ai encore oublié, mais il me dit qu'il ne connais pas _n()

[PAPIPP]

Bonjour KCC
S'il te manque les macros _NL ,_N() ou _H() aller les chercher http://www.purebasic.fr/french/viewtopi ... =6&t=13296 à la date du 23/10:2013
J'ai supprimé l'utilisation de la macro m_h()
A+

[Kwai chang caine]

Merci PAPIPP

J'ai rajouté les macros que tu m'a dit et cette fois j'ai l'erreur :

Ligne 129: Les comparaisons (=, <, >, <>, =< et >=) sont uniquement supportees apres les mot clefs tel que If, While, Until ou dans la fonction Bool().

à la ligne

PrintN("***************** Mode INFO global vers REG avec ! ***"+_n(GVPL)+_H(GVPL))

Laisse tomber...j'suis vraiment trop une nouille

[PAPIPP]

Bonjour KCC.

Je ne lâche qu’assez rarement car :
D’une part cela peut provenir de mon PRG
Et que d’autre part je peux toujours apprendre.

Dans la ligne 129 je ne vois pas d’erreur sauf si une macro n’a pas été copiée.
Le décalage entre le N° de ligne 129 de ton programme avec l’ajout des macros et la copie que j’ai faite du PRG proposé (ligne 117), et qui fonctionne chez moi sans macro (macros en RESIDENTS) est de 12 lignes.
Je pense que certaines macros n’ont pas été copiées

Pour être certain de ne pas rater une macro il est préférable de copier toutes les macros.
A+

[kernadec]

bonjour PAPIPP

ton code fonctionne, mais il faut mettre en commentaire la ligne suivante:

Code : Tout sélectionner

PrintN(_NL+_Hl(REAX)+_hl(REBX)+_Hl(RECX)+_Hl(REDX)+_HL(RESI)+#CRLF$+_NL+_HL(REDI)+_HL(RESP)+_HL(REBP)+_HL(RCS)+_HL(RDS))

car il manque certainement une macro
voici le rapport:
_Hl() n'est pas une fonction, un tableau, une macro ou une liste.

Cordialement

[PAPIPP]

Bonjour kernadec

oups c'est la macro _HL() qui manque l

Code : Tout sélectionner

Macro _HL (__HL,_pr="$")
_q_t_#__HL#=_q_t_+_PR+RSet(Hex(PeekL(@__HL),#PB_Long),8,"0")+" "
EndMacro

Les RESIDENTS c'est très bien mais j'oublie toujours une ou deux macros

Excusez moi
A+

[Kwai chang caine]

Youppi !!! ça marche !!! Bien vu KERNADEC

Je ne lâche qu’assez rarement car :
D’une part cela peut provenir de mon PRG
Et que d’autre part je peux toujours apprendre.

Voila pourquoi tu sais parler à l'oreille des processeurs

Excusez moi

De quoi ????
De nous donner noir de codes pleins de hieroglyphes à faire palir un egyptien ??
De repondre à des inhibés du bulbe comme moi, alors qu'ils essaient de lire un livre qu'il comprennent même pas le titre ??

Moi je te remercie encore de ta patience et de tes idées qui nous permettent d'explorer les fondations de nos machines.
Mon empire pour 20% de ta connaissance

Et merci à mon copain KERNADEC qui a aussi un cerveau que rien que 10% suffirait à combler le miens
Parce que il en a aussi sous le capot le KERNADEC et principalement pas en informatique

Ca fait du bien de fréquenter des personnes comme vous et certains autres des forums.
Des personnes que rien que quand ils te disent bonjour tu te couche déjà moins con que la veille

Et excusez moi d'essayer de jouer dans la cour des grands
C'est plus fort que moi la curiosité, mais sur les forums vous faites tellement de choses super intéressantes, même si bien souvent j'y comprend rien
Comme vous le savez je collectionne les codes, comme certains autres du forum d'ailleurs, et des fois je sais même pas ce que je vais pouvoir mettre comme titre au fichier PB

Passez une bonne journée, je vais réviser le If/Then...Repeat/until....heureusement que FRED il a pensé à moi en creant des jouets à ma taille