Rechercher dans le site :

Traduction/Translation/Traduko/Traducción/Übersetzung/Traduzione

Identifiez-vous pour accéder à la partie privée du site ou le modifier.

Déconnexion.

Ĉu vi parolas esperanton ?

 

Dernière mise à jour le 22/10/2023

Autres langages généralistes et système Mensura

Go(Golang), Logo (Berkeley Logo, Lhogo, MSW-Logo), Rebol, Ruby

Go (Golang)

C'est un langage compilé inspiré de C et Pascal, développé par Google, de type « Open Source », disponible pour Linux, Mac, Windows, et quelques autres systèmes.
Il peut utiliser les bibliothèques dynamiques, mais la documentation à ce sujet est peu claire, et les exemples donnés ne concernent que des paramètres entiers. C'est pourquoi les explications ci-dessous ne sont que pour des paramètres entiers.
On peut utiliser facilement les fonctions cea, ceb, csb, mais les fonctions renvoyant des réels ou des chaînes de caractères ne semblent pas aussi facilement utilisables. La solution est donc d'utiliser les fonctions de nommage renvoyant les codes ASCII des caractères : cdetailnum, ctitrenum, cneanum, cnebnum, cnsanum, cnsbnum.
Pour les fonctions numériques renvoyant un nombre réel, on peut imaginer faire une fonction ceadnumstrnum, recevant le numéro de la voie à lire,  et le numéro du caractère de la chaîne correspondant à la valeur numérique, et renvoyant la valeur ASCII de ce caractère. C'est compliqué, et normalement la fonction cea doit pouvoir donner des résultats aussi satisfaisants.
package main
import ( "syscall" ; "fmt" ;  "runtime")

var resint int32;
var resfloat float64;
var resstring string;

var mabib=syscall.NewLazyDLL("bibdynsyst_pb2018.dll")
var monea=mabib.NewProc("cea")
var monnea=mabib.NewProc("cnea")
var mondetailnum=mabib.NewProc("cdetailnum")
var montitrenum=mabib.NewProc("ctitrenum")
var monneanum=mabib.NewProc("cneanum")

func eago (a int) int  {resint,_,_:=monea.Call(uintptr(a))
      return int(resint)  }

func neabase(a int)string    {resstring,_,_:=monnea.Call(uintptr(a))
     return string(resstring) }

func detailnumgo(a int) int {
    resstring,_,_:=mondetailnum.Call(uintptr(a))
    return int(resstring)
    }
   
func detail() string{
    var chloc=""
    for i:=0;i<100;i++{
        if detailnumgo(i)==0{return chloc}
        chloc=chloc+string(detailnumgo(i))
    }
    return chloc
}

func titrenumgo(a int) int{
    resstring,_,_:=montitrenum.Call(uintptr(a))
    return int(resstring)
}
func titre() string{
    var chloc=""
    for i:=0;i<100;i++{
        if titrenumgo(i)==0{return chloc}
        chloc=chloc+string(titrenumgo(i))
    }
    return chloc
}

func neanumgo(numvoie int32 , numlettre int32) int32 {
    resint,_,_:=monneanum.Call(uintptr(numvoie),uintptr(numlettre))
    return int32(resint)
}   

func nea(numvoie int32)string{
var chloc=""
    for i:=0;i<100;i++{
        if neanumgo(numvoie,int32(i))==0{return chloc}
        chloc=chloc+string(neanumgo(numvoie,int32(i)))
    }
    return chloc
}    
   
func main() {
   fmt.Println("Début ",runtime.Version())
   for i:=0;i<4;i++{
   fmt.Println(nea(int32(i)),"--> eago(",i,")=",eago(i)) // correct
    } 
  fmt.Println("nea base=",string(neabase(0)))//mauvais
  fmt.Println("detail:",detail())
  fmt.Println("titre:",titre())
  fmt.Printf("Fini !")
}

Langage Logo

Berkeley Logo (UCBLogo et variantes, logiciels libres pour Windows et Linux)

Ce logiciel provient de l'Université de Californie à Berkeley (http://www.cs.berkeley.edu/~bh/logo.html). Une variante en est aUCBLogo, de Andreas Micheler (http://aucblogo.org/en/Logo.html).
L'instruction DynamicLibrary permet de charger la bibliothèque dynamique.
mabibdyn=DynamicLibrary "bibdyn_syst_pb_ANSI
Les différentes fonctions peuvent être appelées par les instructions DLCall ou DynamicLibraryCall.
Dans la liste des paramètres entre parenthèses, le premier paramètre indique le type de résultat ("word" pour une chaîne de caractères, "int" pour un entier, "float" pour un réel ; bien que les détails des types de variables ne soient pas précisés dans le fichier d'aide, ces types de caractères sont compatibles avec Mensurasoft).
Ensuite, dans la liste des paramètres, on met le ou les paramètres. Chaque paramètre de la fonction de Mensurasoft doit être sous la forme de 3 paramètres dans la liste. D'abord est le nom du paramètre (sans guère d'importance), puis le type du paramètre, et enfin l'identificateur du paramètre correspondant à ce qui est donné dans la première ligne de déclaration.
to detail
chloc=dlcall mabibdyn [stddetail] (list "word)
output chloc
end

to titre
chloc=dlcall mabibdyn [stdtitre] (list "word)
output chloc
end

to eadouble n
  nloc=dlcall mabibdyn [stdeadouble] (list "float "n "float n)
output nloc
end
 
to ead n
  nloc=dlcall mabibdyn [stdead] (list "float "n "int n)
output nloc
end

to ea n
  nloc=dlcall mabibdyn [stdea] (list "int "n "int n)
  output nloc
end
 

to nea n
output dlcall mabibdyn [stdnea] (list "word "n "int n)
end

to nead n
chloc=dlcall mabibdyn [stdnead] (list "word "n "int n)
output chloc
end

to sb n valeur
nloc=dlcall mabibdyn [stdsb] (list "int "n "int n "valeur "int valeur)
output nloc
end

to nsb n
chloc=dlcall mabibdyn [stdnsb] (list "word "n "int n)
output chloc
end

Ensuite, on peut appeler les différentes nouvelles instructions, par exemple par
print detail
print nead 2
print ead 0
print sb 0 1

Lhogho (logiciel libre pour Windows et Linux)

(http://lhogho.sourceforge.net/)
Comme pour d'autres langages, on commence par charger la bibliothèque dynamique par l'instruction libload :
make "handle libload "bibdyn.dll
Ensuite, on déclare l'utilisation des fonctions en indiquant le type de résultat, puis le nom de la fonction dans la bibliothèque dynamique, puis le type de paramètre.
to ead :n
end
external "ead [F8 stdead i4] :handle
F8 signifie un nombre réel (F = Float) codé sur 8 octets, c'est à dire de type double précision. I4 signifie un nombre entier codé sur 4 octets. On peut déclarer une chaîne par S1 (chaque caractère correspond à 1 octet) ou par S2 (chaque caractère correspond à deux octets, pour le codage unicode). S'il n'y a pas de paramètre d'entrée, comme pour les fonctions stddetail, stdtitre, cdetail et ctitre, on ne met pas de type de paramètre :
to detail
end
external "detail [S1 stddetail  ] :handle

Lorsqu'il y a plusieurs paramètres (sorties analogiques et binaires), on met les deux types de paramètres après le nom de la fonction, dans l'ordre normal :
to sb :n :valeur
end
external "sb [i4 stdsb i4 i4] :handle

On peut donc ensuite utiliser ces nouvelles fonctions :
print detail
print ead 0
print nead 0
print sb 0 1

MSW-Logo et FMSLogo (Windows)

(http://mswlogo.softonic.fr/telecharger ou http://sourceforge.net/projects/fmslogo/)
C’est assez simple :
- On charge la DLL par l’instruction dllload :
dllload "xadestar.dll
- puis on utilise les fonctions par l’instruction dllcall, à laquelle on passe en paramètre le nom de la fonction (et éventuellement des paramètres) :
print dllcall[s stddetail]
print dllcall[f stdead l 0]
où  f indique le type du résultat renvoyé par la fonction («float», c’est à dire un nombre réel de type double), l le type du paramètre («long», c’est à dire un entier long), et 0 est la valeur de ce paramètre
- enfin, on libère la mémoire de la DLL par
dllfree

Symboles des types de paramètres et de résultats :
v = void (rien)
w = word (entier sur 16 bits)
l = longword (entier long sur 32 bits)
f = float (réel de type double, sur 64 bits)
s = string (spstr = chaîne de caractères à zéro terminal)

Quelques remarques  :
- l’état majuscule/minuscule est important
- les fonctions à paramètres sont de type stdcall
- apparemment aussi, l’ordre des paramètres est inversé par rapport à d'habitude. Pour les fonctions avec deux paramètres, il faut appeler d’abord le deuxième, puis le premier.
- enfin, il semble qu’une seule DLL est chargeable à la fois. Pour en utiliser une deuxième, il faut d’abord décharger la première.

;fonctions pour charger des bibliothèques dynamiques
;du système Mensurasoft en MSWLogo
;de façon à faire ce langage sensible au monde extérieur.

to chargebibdyn
dllload "./bibdyn_syst.dll
end

to dechargebibdyn
dllfree
end

 
to detail
  output dllcall[s stddetail]
  end

to titre
  output dllcall(list "s "stdtitre)
  ;output dllcall[s stdtitre] ; possible aussi car il n'y a pas de paramètres
  end
 
to nead :n
 output dllcall (list "s "stdnead "l :n )
  end
  
to neadouble :n
   output dllcall (list "s "stdneadouble "f :n)
   end
  
to neadstr :n
   output dllcall(list "s "stdneadstr "s :n)
   end
  
to ead :n
  output dllcall(list "f "stdead "l :n)
  end

to nsad :n
  output dllcall(list "s "stdnsad  "l :n)
  end

to sad  :valeur   :n  ; l'ordre des paramètres est inverse d'habituellement !
  output dllcall(list "f "stdsad  "f :valeur "l :n)
  end
 
to eb :n
  output dllcall(list "l "stdeb "l :n)
  end
 
to neb :n
  output dllcall(list "s "stdneb "l :n)
  end
 
to sb :valeur :n   ; l'ordre des paramètres est inverse d'habituellement !
  output dllcall(list  "l "stdsb  "l :valeur "l :n)
  end

Voir sur Internet : http://www.educa.fmf.uni-lj.si/logo/eurologo.01/paper1.doc

Rebol

Des versions de base sont disponibles sur http://www.rebol.com. Les versions stables Rebol 2 peuvent appeler les bibliothèques dynamiques, mais les Rebol 3 (« alpha, unofficial ») ne semblent pas (encore) pouvoir le faire. Rebol2 existe pour divers systèmes (entre autres Windows, Linux et MacOS).
Sous Windows, si on suppose la bibliothèque dynamique bibdyn.dll dans le même répertoire que rebol.exe (ou dans un autre répertoire accessible automatiquement), on peut réaliser le fichier suivant hello.r :
REBOL []
  mabib: load/library %bibdyn.dll
  stdtitre: make routine! [return:[string!]] mabib "stdtitre"
  stdnead: make routine! [return:[string!] n [integer!]] mabib "stdnead"
  stdead: make routine!  [return:[decimal!] n [integer!]] mabib "stdead"
 
print "hello worlds !!!"
print stdtitre()
print stdnead(0)
print stdead(0)
Ce programme est lançable dans l'interpréteur Rebol par do %hello.r

Ruby

(http://www.ruby-lang.org/fr)
L'appel des bibliothèques dynamiques est facile et rapide :

require 'dl/import'

module Mabibdyn
  extend DL::Importable
  dlload 'bibdyn_syst_pb_mouse.dll'
  extern 'int stdea(int)'
  extern '  VALUE  * stdnea(int)'
  extern 'float stdead(int)'
  extern 'int stdsb(int,int)'
  extern ' VALUE * stddetail()'
end

puts 'Hello !'

puts Mabibdyn.stdea(0)
puts  Mabibdyn.stdnea(0)
puts Mabibdyn.stdead(0)
puts Mabibdyn.stddetail()
puts Mabibdyn.stdsb(0,1)

puts 'finto nsb :n
  output dllcall(list "s "stdnsb "l :n)
  end