probleme de compilation ; dependance entre fichiers [Résolu]

[gorgonite]

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

Code :

fsc.exe -c main.fs

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

[gorgonite]

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

[gorgonite]

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.

[gorgonite]

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 ?

[LLB]

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

[gorgonite]

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]

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