Ou est mon erreur!

nico · Message par **nico** » mer. 18/juil./2007 21:38

On ne peut le faire qu'avec les variables optionnelles:

Interface Calcul
    Addition(a.l,b.l,c.l=0,d.l=0)
EndInterface

Structure Class
    *Vtable.Addition
EndStructure
   
Procedure.l Addition(*this,a ,b ,c=0, d=0)

    ProcedureReturn a+b+c+d
EndProcedure


Global NewList Poo.Class()

AddElement(Poo())
Poo()\Vtable=?Vtable

*Pointeur.Calcul=Poo()
Debug *Pointeur\Addition(5,3)
Debug *Pointeur\Addition(5,3,1)
Debug *Pointeur\Addition(5,3,1,2)

DataSection
Vtable:
Data.l @Addition()
EndDataSection

Ollivier · Message par **Ollivier** » mer. 18/juil./2007 22:11

Mais non, ce que je te demande, c'est de m'intégrer une 2nde procédure quelconque. Je disais 'addition à trois paramètres' mais ça peut très bien être une soustraction ou autre, comme tu veux!

Le but est que je saisisse les différentes logiques que tu mets en jeu:
Interface >> je connais pas
Structure >> je découvre (c'est cool)
Procédure >> je connais bien
Syntaxe et application des pointeurs >> je découvre (c'est cocasse)

Et ton exemple est super, il donne un exemple simple qui fonctionne. Normalement, si je ne suis pas trop une bille

, je devrais tout comprendre avec un second exemple de code comprenant:
une addition
& une soustraction.

Woilà!

Ollivier · Message par **Ollivier** » mer. 18/juil./2007 22:12

Ptain connery, j'ai réussi!

Code : Tout sélectionner

Interface Calcul 
    Addition(a.l, b.l) 
    Soustraction(a.l, b.l) ;(+)
EndInterface 

Structure Class 
    *Vtable.Addition 
    *Vtable2.Soustraction ;(+)
EndStructure 
    
Procedure.l Addition(*this,a ,b) 
    ProcedureReturn a+b
EndProcedure 

Procedure.l Soustraction(*this,a ,b) ;(+)
    ProcedureReturn a-b             ;(+)
EndProcedure                         ;(+)


Global NewList Poo.Class() 

AddElement(Poo()) 
Poo()\Vtable=?Vtable 
AddElement(Poo())                   ;(+)
Poo()\Vtable=?Vtable                ;(+)

*Pointeur.Calcul=Poo() 
Debug *Pointeur\Addition(5,3) 
Debug *Pointeur\Soustraction(5,2)   ;(+)

DataSection 
Vtable: 
Data.l @Addition()
Vtable2:                ;(+)
Data.l @Soustraction()  ;(+)
EndDataSection

Ollivier · Message par **Ollivier** » mer. 18/juil./2007 22:32

Alors, si je saisis un chouia, on procède comme suit:

1) On fourgue ses noms et types dans un fichier 'SOURCE.TXT' :

Code : Tout sélectionner

Addition.l(a.l, b.l) 
Soustraction.l(a.l, b.l)

Anonyme · Message par **Anonyme** » mer. 18/juil./2007 23:24

Code : Tout sélectionner

AddElement(Poo())
Poo()\Vtable=?Vtable
AddElement(Poo())                   ;(+)
Poo()\Vtable=?Vtable                ;(+)

le faire 2x est inutile,
Nico, tu ma donner envie de faire un parser de classes , j'ai commencer,
cela ressemble a ceci :

Pseudo c++

Code : Tout sélectionner

class MaClass
{
          Test(A)
          Value.l
         
}

Maclass::Test.l(A)
{
;Insert PureBasic Code here...
ProcedureReturn A*A
}

Conversion en code pb (non fini) :

Code : Tout sélectionner

Interface MaClass
          Test(A)
EndInterface

Structure MaClass_
          Value.l
         
EndStructure

Procedure.l Test(A)
;{
;Insert PureBasic Code here...
ProcedureReturn A*A
EndProcedure

DataSection
Addr:
Data.l @Test(),
EndDataSection

Demain , je fignole cela

Ollivier · Message par **Ollivier** » jeu. 19/juil./2007 0:09

2) On exécute ce code pour transformer SOURCE.TXT en SOURCE.PB

Code : Tout sélectionner

Source.s = "SOURCE.TXT"
Target.s = "TARGET.PB"
Global InterfaceName.s = "Calcul"
Global StructureName.s = "Class"
Global LabelName.s = "Vtable"
Global ListName.s = "Poo"


#Source = 1
#Target = 2

#I = Chr(40)
#O = Chr(41)
#IO = Chr(40) + Chr(41)

Global suff.s = ""
Global tmp.s = ""
Global pref.s = ""
Global NameAndType.s = ""
Global Name.s = ""
Global TypeOf.s = ""
Global args.s = ""

Declare W(x.s)
Declare ChildA(a.s, b.s, c.s)
Declare ChildB(a.s, b.s, c.s)
Declare ChildC(a.s, b.s, c.s)

Procedure ChildA(a.s, b.s, c.s)
  W("  " + a + #I + c + #O)
EndProcedure

Procedure ChildB(a.s, b.s, c.s)
  W("  *" + LabelName + Suff + "." + a)
EndProcedure

Procedure ChildC(a.s, b.s, c.s)
  W(LabelName + Suff + ":")
  W("Data." + TypeOf + " @" + Name + #IO)
EndProcedure

Macro Main(x)
  FileSeek(#Source, 0) ; Pour balayer SOURCE.TXT, faut commencer par le début
  Count.l = 1
  Repeat
    Tmp = ReadString(#Source) ; On choppe le bordelo
    Tmp = Trim(Tmp)             ; On vire le superflu d'espace à gauche à droite
    If Tmp <> ""                ; S'il y a quelque qui reste dans cte ligne...
      Pref = Left(Tmp, 1)       ; ...On s'intéresse au 1er caractère de la ligne ('préfixe')
      If Pref <> ";"              ; Si c'est pas un commentaire...      
        NameAndType = StringField(Tmp, 1, #I) ; On prend le nom et le type
          Name = StringField(NameAndType, 1, ".") ; On sépare le nom...
          TypeOf = StringField(NameAndType, 2, ".") ; ...du type
        Args = StringField(Tmp, 2, #I) ; On prend les arguments
          Args = StringField(Args, 1, #O) ; On enlève cette parenthèse finale et inutile
          Suff = Str(Count): If Suff = "1": Suff = "": EndIf ; (ça c'est pour numéroter les labels)
        Child#x(Name, TypeOf, Args) ; On habille Monsieur, Madame et Mademoiselle
        Count + 1
      EndIf
    EndIf
  Until Eof(#Source)           ; On arrête si c'est fini
EndMacro


Procedure W(x.s) ; Une procédure parce writemachin c'est trop long...
  WriteStringN(#Target, x)
  Debug x
EndProcedure


  ReadFile(#Source, "SOURCE.TXT")
  If CreateFile(#Target, "SOURCE.PB") = 0
    Debug "Création de fichier : pas cool !"
    End
  EndIf

  ; On grave dans la roche...
  W("")
  W("Interface " + InterfaceName)
  Main(A)
  W("EndInterface")
  W("")
  W("Structure " + StructureName)
  Main(B)
  W("EndStructure")
  W("")
  W("Global NewList " + ListName + "." + StructureName + #IO)
  W("")
  W("AddElement(" + ListName + #IO + #O)
  W(ListName + #IO + "\" + LabelName + " = ?" + LabelName)
  W("")
  W("DataSection")
  Main(C)
  W("EndDataSection")
  W("")

; On ferme
CloseFile(#Target)

Ollivier · Message par **Ollivier** » jeu. 19/juil./2007 0:11

cpl! Tu t'es glissé entre l'étape 1 et l'étape 2 ! Oui j'ai fait la rectif merci. C'est quoi un parser?

3) Dernière étape : on charge SOURCE.PB créé par le code de l'étape 2
ça donne ce qu'on veut (enfin j'espère, en tout cas, on peut stocker plusieurs milliers de noms de procédures, ça mouchera toujours bien) :

Code : Tout sélectionner

Interface Calcul
  Addition(a.l, b.l)
  Soustraction(a.l, b.l)
EndInterface

Structure Class
  *Vtable.Addition
  *Vtable2.Soustraction
EndStructure

Global NewList Poo.Class()

AddElement(Poo())
Poo()\Vtable = ?Vtable

DataSection
Vtable:
Data.l @Addition()
Vtable2:
Data.l @Soustraction()
EndDataSection

PS: Prévenez-moi si je fais erreur et dites-moi au moins à quoi ça sert? !

Anonyme · Message par **Anonyme** » jeu. 19/juil./2007 1:37

Parser , c'est de l'analyse syntaxtique , c'est à dire que le parser doit être capable de lire un fichier de l'analyser et d'en tirer des conclusions , par exemple, le miens
sert à convertir du pseudo c++ en code exploitable purebasic :

Code : Tout sélectionner

class MaClass
{
          Test(A)
          Value.l
         
}

Maclass::Test.l(A)
{
;Insert PureBasic Code here...
ProcedureReturn A*A
}

Comme tu peut voir sur le code plus haut, c'est pas du purebasic , ni du c++ , mais une dérive que j'ai choisi pour faire de la POO en purebasic.
le parser doit donc analyser le code plus haut et le transformer en code PureBasic :

Code : Tout sélectionner

Interface MaClass
          Test(A)
EndInterface

Structure MaClass_
          Value.l
         
EndStructure

Procedure.l Test(A)
;{
;Insert PureBasic Code here...
ProcedureReturn A*A
EndProcedure

DataSection
Addr:
Data.l @Test(),
EndDataSection

bon, il est pas fini, je terminerais cela plus tard

Ollivier · Message par **Ollivier** » jeu. 19/juil./2007 18:40

Génial. Je ne me casserai pas autant les mirettes pour créer et poster de tels codes au milieu de la nuit!