Discussion :

[Lyaskator]

Bonjour,
je me suis mis à l'ocaml en autodidacte après avoir fait un petit peu de C.
j'ai passé au bas mot tout l'après-midi à essayer de trouver ce qui clochait dans mon code ocaml suivant. Un peu d'aide ne serait pas de refus.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let rec main_def_argv ite_argv val_argv =
	print_endline ("Test de " ^ Sys.argv.(ite_argv) ^ " .");
	if ite_argv > 0 then
		if (Sys.argv.(ite_argv).[0] == '"') && (Sys.argv.(ite_argv).[(String.length Sys.argv.(ite_argv)) -1]) == '"' then
			if val_argv == true then val_argv = false else (main_def_argv (ite_argv-1) true)
		else
			(main_def_argv (ite_argv-1) false)
	else
		if val_argv == true then val_argv = true
		else val_argv = false;;
 
match (main_def_argv ((Array.length Sys.argv)-1) false) with
	| true -> print_endline "Arguments valides."
	| false -> print_endline "Arguments invalides. Arrêt du programme."; exit 42;;

Le but de ce morceau de code :
l'utilisateur doit lancer le programme en console en envoyant au moins un argument entre "\" et \"" . Il peut envoyer n'importe quel autre argument du moment qu'il se plie à cette règle.

Ce code ne fonctionne pas. Par exemple, si je tape :
./main blabla
le programme considère les arguments envoyés comme valides, alors que l'argument n'a pas été entouré de "\" et \"".
Pourquoi ?

Ensuite, j'aimerais savoir s'il n'y a pas un moyen d'envoyer un argument en pouvant y mettre n'importe quoi : si je fais, par exemple, ./main "\"truc"machinchose\""
ça ne va pas, à cause du " entre truc et machinchose, j'aimerais faire en sorte qu'aucun argument ne risque de poser problème.
J'ai cherché pendant tout l'après-midi, là j'en ai ras-le-bol et je ne comprends pas ce qui cloche. La personne qui m'aidera aura droit à mes remerciements les plus sincères.
Merci d'avance.

[Cacophrene]

Bonjour,

À mon humble avis, le problème est dans la première phrase de ton message : OCaml n'est pas le C, ni dans sa syntaxe ni dans son esprit. Par exemple, == est une égalité physique en OCaml, pour tester une égalité simple on utilise simplement =. Un autre exemple :

Code :

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

if val_argv == true then val_argv = true

En OCaml ce code veut dire : si val_argv est vrai, alors tester l'égalité de val_argv et true... tu vois où je veux en venir. Il ne s'agit pas d'une affectation !

Pour la gestion fine des arguments en ligne de commande, la bibliothèque standard offre le module Arg. Mais avant tout ça, je te propose de reprendre le code point par point. Est-ce que tu peux me dire précisément ce que tu attends de ta fonction ?

Cordialement,
Cacophrène

[Lyaskator]

Merci d'avoir répondu.
J'attends de ma fonction qu'elle regarde chaque argument envoyé par l'utilisateur lors du lancement du programme en console. Un de ces arguments doit être entouré de "\" et \"" (pour stocker une phrase), l'utilisateur peut aussi envoyer d'autres arguments sans contrainte de mise en forme.
Si un argument (et un seul) est bien entre "\" et \"", alors c'est bon, la fonction doit retourner vrai, sinon c'est pas bon et la fonction doit retourner faux.
Merci d'avance.

[Cacophrene]

Re,

Quelque chose comme ceci peut-être :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
let check_args () =
  try
    Array.iteri (fun i arg ->
      let n = String.length arg in
      if arg.[0] = '"' && arg.[n - 1] = '"' then raise Exit
    ) Sys.argv;
    false
  with Exit -> true

let _ = print_endline (if check_args () then "OUI" else "NON")

Ce code passe en revue tous les arguments à la recherche d'une valeur délimitée par "\" et \"". Par exemple, l'appel ./foo "\"bar foo\"" donne OUI. Si tu as des questions sur ce code n'hésite pas. Et bien entendu ce n'est pas la seule façon d'écrire une telle fonction.

Cordialement,
Cacophrène

[gasche]

Si tu veux apprendre le Caml, je suggère que tu commences par écrire des programmes intéressants. Bidouiller des arguments en ligne de commande, c'est compliqué et pas très inspiré, et OCaml ne rendra pas la tâche moins pénible qu'elle le serait dans un langage quelconque. Par ailleurs il existe déjà une bibliothèque un peu plus haut niveau pour la gestion des arguments en ligne de commande, Arg.

Caml excelle dans le domaine des manipulations symboliques (AST de langages informatiques, expressions mathématiques, un peu de linguistique, etc.). Pourquoi ne pas essayer par exemple une fonction simple de dérivation de polynômes ?

[Lyaskator]

Merci beaucoup Cacophrene,
mais ton code ne fonctionne pas exactement.
Si j'entre plusieurs arguments, chacun entre "\" et \"", il retourne vrai, or je veux qu'il n'accepte les arguments que si un seul d'entre eux est entre "\" et \"".

Code :

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

1
2
3
4
Array.iteri (fun i arg ->
      let n = String.length arg in
      if arg.[0] = '"' && arg.[n - 1] = '"' then raise Exit
    ) Sys.argv;

Je n'ai pas très bien compris comment fonctionnait ce bout de code.

Si tu veux apprendre le Caml, je suggère que tu commences par écrire des programmes intéressants. Bidouiller des arguments en ligne de commande, c'est compliqué et pas très inspiré, et OCaml ne rendra pas la tâche moins pénible qu'elle le serait dans un langage quelconque. Par ailleurs il existe déjà une bibliothèque un peu plus haut niveau pour la gestion des arguments en ligne de commande, Arg.

Caml excelle dans le domaine des manipulations symboliques (AST de langages informatiques, expressions mathématiques, un peu de linguistique, etc.). Pourquoi ne pas essayer par exemple une fonction simple de dérivation de polynômes ?

Oh, ça ne me paraissait pas inintéressant le bidouillage des arguments.
D'un autre côté j'ai commencé avec un tutoriel qui n'était plus à jour et où il y avait des trous, je vais jeter un coup d'œil à ceux que developpez.net propose, ils ont l'air bien.
En tout cas merci pour ta réponse.

[gasche]

Personnellement j'ai appris dans le http://www.pps.jussieu.fr/Livres/ora/DA-OCAML/ DA-OCaml, un tutoriel très complet (mais en réalité il suffit de lire les 3 premiers chapitres et on a déjà compris l'essentiel), mais parfois un peu trop lapidaire pour être tout à fait pédagogique.

Ceci dit le tutoriel de SpiceGuid sur DVP est certainement intéressant aussi.