probleme de compilation ; dependance entre fichiers

**gorgonite** · 13/05/2008, 11h11

Salut,

Je recommence avec mes questions betes...

voici mon main.fs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fsc.exe -c main.fs

mon "graphe de dépendance" est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**gorgonite** · 13/05/2008, 16h04

j'ai fini par trouver...

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 $<

**gorgonite** · 18/05/2008, 20h52

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

#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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**gorgonite** · 19/05/2008, 16h19

eureka... c'était simple en plus

suffit de donner tous les fichiers sources à fsc.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"$(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 ?

**LLB** · 19/05/2008, 17h17

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

**gorgonite** · 19/05/2008, 17h19

Envoyé par LLB

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

**gorgonite** · 19/05/2008, 21h38

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 $<

probleme de compilation ; dependance entre fichiers

F#

Discussions similaires

Partager

Partager