Discussion :

[kamouminator]

salut tout le monde,
je cherche un moyen de génerer du code C sous linux, mon idée est d'implementer une interface qui va demander a l'utilisateur un certain nombre d'options:
nom de l'auteur, description du driver,license utilisée, nom du driver (suffixe),type de driver (charactere, block...) etc...


ce qui genererai un XML de ce type par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
<Driver>
	<Author>kamou</Author>
	<Desc>Dummy Driver</Desc>
	<License>GPL</License>
	<Suffix>Dummy</Suffix>
	<Type>char</Type>
	<SubDrv>
		<Type>i2c</Type>
		<Suffix>i2c</Suffix>
	</SubDrv>
</Driver>

je cherche donc un bon moyen de generer de l'xml ET de parser l'XML pour generer du code C a partir de certains "motifs" de code...
le resultat de ce petit bout de code xml serai:

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/major.h>
 
 
 
/* Global variables */
struct cdev *dumy_cdev  = NULL;
unsigned int dumy_major;
unsigned int nb_devices = 1;
 
/* Definition for file operation */
static struct file_operations dummy_fops =
{
	.owner = THIS_MODULE,
};
 
 
 
static int dummy_i2c_probe(struct i2c_client*client){
 
	return 0;	
}
 
 
static int   __devexit  dummy_i2c_remove(struct i2c_client *client){
 
	return 0;
}
 
 
 
static struct i2c_driver dummy_i2c_driver ={
 
	.driver ={
		.name = "dummy",
		.owner = THIS_MODULE,
	},
	.probe  = dummy_i2c_probe,
	.remove = __devexit_p(dummy_i2c_remove),
};
 
 
static void dummy_cleanup_module(void){
 
  cdev_del(dummy_cdev);
  unregister_chrdev_region(MKDEV(device_major, 0), nb_devices);
  i2c_del_driver(&dummy_i2c_driver);
 
}
 
static int dummy_init_module(void){
 
	dev_t dev_no;
 
 
	if (alloc_chrdev_region(&dev_no,0 ,nb_devices ,"dummy" ) ){
 
		printk(KERN_ALERT  "dummy: can't allocate char device region\n");
		return(-EBUSY);
	}
	dummy_major=MAJOR(dev_no);
	if ((dummy_cdev=cdev_alloc())==NULL){
		printk(KERN_ALERT "dummy: can't allocate device\n");
		unregister_chrdev_region(MKDEV(device_major,0),nb_devices);
		return(-EBUSY);
	}
	dummy_cdev->owner = THIS_MODULE;
	dummy_cdev->ops   = dummy_fops;
 
	if(i2c_add_driver(&dumy_i2c_driver)){
		printk(KERN_ALERT "dummy: can't add i2c driver\n");
		return (-EBUSY);
	}
 
	if (cdev_add(dummy_cdev,dev_no,nbdevices)){
		printk(KERN_ALERT "dummy: can't add device\n");
		unregister_chrdev_region(MKDEV(device_major,0),nb_devices);
		return(-EBUSY);
	}
	return 0;
 
}
 
module_init(dummy_init_module);
module_exit(dummy_cleanup_module);
 
MODULE_AUTHOR("kamou");
MODULE_DESCRIPTION("dummy driver");
MODULE_LICENSE("GPL");

[Davidbrcz]

Je connais des outils pour faire IMH <-> code, UML <-> code mais ce que tu demandes me semble ne pas exister (ou alors).

je pense que le plus simple est de le créer, surtout si le fichier de code à générer ne change pas trop.

Pour parcer du XML en C, tu as le choix, il suffit de demander à Google.
Mais il ressort libxml2, Expat, écrire le tient , ...

[kamouminator]

oui j'ai commencé à regarder libxml2, c'est pas mal, mais existe il (bon j'en demande peut etre beacoup...) une lib qui permette de matcher un "motif" dans un fichier et le remplacer par une chaine de charactère (en gérant le décalage qui en suit) ?

sinon j'imagine que je vais devoir le faire à la main...je demande histoire de ne pas reinventer la roue comme on dit...

[kamouminator]

je me suis peut être mal exprimé
je ne recherche pas vraiment un motif à la sed ou autre, mais une chaine de caractères...

[Davidbrcz]

Bah pour des chaines de caratères, tu peux regarder du coté des regex.

[kamouminator]

justement, les expressions régulières sont à mon avis trop générales dans le cas de mon programme.
dans le sens ou, je n'aurais pas à chercher par exemple un mot contenant trois lettre deux chiffre et une virgule ^^

mais un mot connu à l'avance, par exemple dans un fichier template contenant des prototypes de fonctions du style:

Code :

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

1
2
3
4
5
6
7
static int NOM_probe(...){
  /*...*/
  return 0;
}
static int NOM_init(...){
  /*...*/
}

ou NOM devra être remplacé par une chaine trouvée dans mon xml
je sais que les expression régulières sont tout a fais capables de gérer ce cas, mais peut etre existe il une lib de "gestion" de fichier plus adaptée ?