+ Répondre à la discussion
Affichage des résultats 1 à 7 sur 7
  1. #1
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 223
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 223
    Points : 17 607
    Points
    17 607

    Par défaut probleme de compilation ; dependance entre fichiers

    Salut,



    Je recommence avec mes questions betes...

    voici mon main.fs

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    #light
    
    open Types
    
    let usage_msg = "usage : "
    let show_ast = ref false
    let interprete = ref false
    let analyze = ref false
    let explicit = ref false
    let debug = ref false
    let input_name = ref ""
    
    let speclist = [
      ("--show-ast",Arg.Set(show_ast),"affichage de l'ast")
      ("--explicit",Arg.Set(explicit),"déclaration obligatoire des variables")
      ("--debug",Arg.Set(debug),"debug")
      ("--analyze",Arg.Set(analyze),"analyse")
      ("--int",Arg.Set(interprete),"interprétation")]
    
    let main () =
      Arg.parse speclist (fun s -> input_name := s) usage_msg
      if (String.length (!input_name)) > 0 then
        let fichier = open_in !input_name
        let buffer = Lexing.from_channel fichier
        let ast = Parser.main Lexer.nextToken buffer
        print_any ast
      else
        Arg.usage speclist usage_msg 
    
    main ()

    J'essaie de le compiler avec la même commande que mes autres fichiers
    mon "graphe de dépendance" est le suivant :
    Code :
    1
    2
    3
    4
    5
    6
    7
    main.fs
     |-- types.fs
        |-- interval.fs
     |-- parser.fs
     |-- lexer.fs
        |-- parser.fs
    cela aurait fonctionné avec un Makefile pour OCaml, mais F# gère sans doute cela différemment à cause des assembly .Net, et je me prends cette erreur :

    Code :
    1
    2
    3
    4
    5
    main.fs(4,5): error: Compilation unit interval is required by an imported module but was not referenced. 
    Available assemblies are: mscorlib;System;System.Xml;System.Runtime.Remoting;System.Runtime.Serialization.Formatters.Soap;
    System.Data;System.Drawing;System.Web;System.Web.Services;System.Windows.Forms;FSharp.Core;FSharp.Compatibility;types.
    
    main.fs(26,14): error: FS0039: The namespace or module 'Parser' is not defined.

    je me doute qu'avec Visual Studio tout serait gérer sans problème, mais j'aimerais aussi pouvoir fournir des Makefile pour que les utilisateurs de F# avec Mono (comme moi ) puissent aussi compiler
    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

  2. #2
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 223
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 223
    Points : 17 607
    Points
    17 607

    Par défaut

    j'ai fini par trouver...

    en gros, il faut ajouter en tete de chaque fichier *.fs

    Code :
    1
    2
    3
    4
    5
    #r @"module_utilise.dll";;
    ...
    #light
    ...
    et compiler vers des dll (fsc.exe -a ) et non des modules (fsc.exe -c )
    sauf le "main.fs"


    voici un exemple de Makefile assez simple :

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    OBJS = interval.dll types.dll parser.dll lexer.dll 
    EXE = compilo.exe
    
    FSC = /usr/bin/mono ~/FSharp-1.9.3.7/bin/fsc.exe
    FSLEX = /usr/bin/mono ~/FSharp-1.9.3.7/bin/fslex.exe
    FSYACC = /usr/bin/mono ~/FSharp-1.9.3.7/bin/fsyacc.exe
    
    
    all: main
    
    delete_tmp:
    	if [ -f lexer.fs ] ; then rm lexer.fs ; fi
    	if [ -f parser.fs ] ; then rm parser.fs ; fi
    	if [ -f parser.fsi ] ; then rm parser.fsi ; fi
    clean: delete_tmp
    	rm -f \#*\# *~ *.netmodule *.exe *.dll
    
    reset: clean all
    
    main: $(OBJS) delete_tmp
    	$(FSC) -o $(EXE) main.fs
    
    .SUFFIXES: .dll .netmodule .fs .fsi .fsy .fsl .exe
    
    .fsy.fs:
    	$(FSYACC) -o $@ $<
    
    .fsl.fs:
    	$(FSLEX) -o $@ $<
    
    .fs.netmodule:
    	$(FSC) -c $<
    
    .fs.dll:
    	$(FSC) -a $<
    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

  3. #3
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 223
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 223
    Points : 17 607
    Points
    17 607

    Par défaut

    bon disons que cette solution me fut utile dans un premier temps, mais j'ai vraiment envie de ne pas multiplier inutilement les dll

    en remplaçant #r @"*.dll" par ceci :
    Code :
    #load @"module_utilise.netmodule";;
    je pensais que cela reglerait le probleme... j'arrive à compiler tous les modules à l'exception de ceux utilisant un autre module explicitement : ie sans faire open Module, mais en appelant ainsi les fonctions

    Code :
    1
    2
    3
    #load @"module.netmodule";;
    
    Module.fonction arg1 arg2 ... argN
    je me prends l'erreur suivante :
    main.fs(39,14): error: FS0039: The namespace or module 'Parser' is not defined.
    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

  4. #4
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 223
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 223
    Points : 17 607
    Points
    17 607

    Par défaut

    eureka... c'était simple en plus

    suffit de donner tous les fichiers sources à fsc.

    Code :
    "$(FSC)" $(FLASGS) -o $(EXE) $(SRC)
    et ça marche

    evidemment, avec un Makefile, fsyacc et fslex seront appelés automatiquement avant

    j'ai importé mon projet sous Visual Studio 2008, et malheureusement ce dernier ne pense pas à appeler fsyacc et fslex... quelqu'un sait-il comment l'y contraindre ?


    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

  5. #5
    LLB
    LLB est déconnecté
    Membre Expert
    Inscrit en
    mars 2002
    Messages
    962
    Détails du profil
    Informations forums :
    Inscription : mars 2002
    Messages : 962
    Points : 1 308
    Points
    1 308

    Par défaut

    Il me semble que ce n'est pas encore géré.
    Perso, j'appelais fslex et fsyacc à la main.

  6. #6
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 223
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 223
    Points : 17 607
    Points
    17 607

    Par défaut

    Citation Envoyé par LLB Voir le message
    Il me semble que ce n'est pas encore géré.
    Perso, j'appelais fslex et fsyacc à la main.
    ok, ben je vais devoir gérer mon Makefile... ou regardez de plus prêt un meta-makefile pouvant créer des fichiers de conf VS
    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

  7. #7
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 223
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 223
    Points : 17 607
    Points
    17 607

    Par défaut

    au passage, pour les intéressés voici le Makefile que je me suis fait

    il marche sous Linux et sous Windows avec cygwin

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    WINDOWS=false
    DLL=false
    EXE = compilo
    
    SRCLEX  = $(shell dir *.fsl)
    SRCYACC = $(shell dir *.fsy)
    SRC = interval.fs types.fs  $(SRCYACC:.fsy=.fs) $(SRCLEX:.fsl=.fs) interpret.fs analyzer.fs main.fs
    
    ifeq ($(DLL),true)
      OBJS = $(SRC:.fs=.dll)
    else
      OBJS = $(SRC:.fs=.netmodule)
    endif
    
    ifeq ($(WINDOWS),true)
      FSVERSION = 1.9.4.15
      FSROOT = /cygdrive/c/Program Files (x86)/FSharp-$(FSVERSION)
    else
      FSVERSION = 1.9.3.7
      FSROOT = /usr/local/FSharp-$(FSVERSION)
    endif
    
    ifeq ($(WINDOWS),true)
      FSC = "$(FSROOT)/bin/fsc.exe"
      FSLEX = "$(FSROOT)/bin/fslex.exe"
      FSYACC = "$(FSROOT)/bin/fsyacc.exe"
    else
      FSC = /usr/bin/mono $(FSROOT)/bin/fsc.exe
      FSLEX = /usr/bin/mono $(FSROOT)/bin/fslex.exe
      FSYACC = /usr/bin/mono $(FSROOT)/bin/fsyacc.exe
    endif
    
    FLAGS = -O3 --progress --fullpaths --all-warnings
    
    DOC_DIR = ./doc
    
    all: main
    
    delete_tmp:
    	if [ -f lexer.fs ] ; then rm lexer.fs ; fi
    	if [ -f parser.fs ] ; then rm parser.fs ; fi
    	if [ -f parser.fsi ] ; then rm parser.fsi ; fi
    clean: delete_tmp
    	rm -f \#*\# *~ *.netmodule *.exe *.dll
    
    reset: clean all
    
    main: $(SRC)
    	$(FSC) $(FLAGS) -o $(EXE).exe $(SRC)
    	@make delete_tmp
    
    doc: $(SRC)
    	mkdir -p $(DOC_DIR)/$(EXE)
    	$(FSC) $(FLAGS) -o $(EXE).exe $(SRC) --generate-html --html-output-directory $(DOC_DIR)
    	@make delete_tmp
    	cp "$(FSROOT)/manual/msdn.css" $(DOC_DIR)/
    
    purge_doc:
    	rm -rf $(DOC_DIR)/*
    
    reset_doc: purge_doc doc
    
    .SUFFIXES: .dll .netmodule .fs .fsi .fsy .fsl .exe
    
    .fsy.fs:
    	$(FSYACC) -o $@ $<
    
    .fsl.fs:
    	$(FSLEX) -o $@ $<
    
    .fs.netmodule:
    	$(FSC) $(FLAGS) -c $<
    
    .fs.dll:
    	$(FSC) $(FLAGS) -a $<
    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •