← Back to branch summary

~ubuntu-branches/ubuntu/hoary/scilab/hoary

« back to all changes in this revision

Viewing changes to routines/libcomm/list_chainees.c

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2005-01-09 22:58:21 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050109225821-473xr8vhgugxxx5j
Tags: 3.0-12
http://bugs.debian.org/255869
changed configure.in to build scilab's own malloc.o, closes: #255869

Show diffs side-by-side

added added

removed removed

Lines of Context:
routines/libcomm/list_chainees.c
1
 
/**********************************************/
2
 
/* Gestion de listes doublement chainees v1.0 */
3
 
/**********************************************/
4
 
 
5
 
#include <stdio.h>
6
 
#include "listes_chainees.h"
7
 
 
8
 
static ldc_element_liste ldc_rechercher_element();
9
 
 
10
 
static ldc_liste_chainee temp1;
11
 
ldc_liste_chainee ldc_creer(correspondre,desallouer,liberer,allouer)
12
 
int (*correspondre)();
13
 
void (*desallouer)();
14
 
void (*liberer)();
15
 
void *(*allouer)();
16
 
{
17
 
 
18
 
    temp1 = (ldc_liste_chainee)(*allouer)(sizeof(struct ldc_Liste_chainee));
19
 
    temp1 -> correspondre = correspondre;
20
 
    temp1 -> desallouer = desallouer;
21
 
    temp1 -> liberer = liberer;
22
 
    temp1 -> allouer = allouer;
23
 
    temp1 -> premier_element = NULL;
24
 
 
25
 
    return temp1;
26
 
}
27
 
 
28
 
void ldc_detruire(liste)
29
 
ldc_liste_chainee liste;
30
 
{
31
 
    ldc_element_liste pointeur,temp;
32
 
 
33
 
    pointeur = liste -> premier_element;
34
 
    while(pointeur != NULL)
35
 
    {
36
 
        temp = pointeur -> suivant;
37
 
        (*(liste -> desallouer))(pointeur -> objet);
38
 
        (*(liste -> liberer))(pointeur);
39
 
        pointeur = temp;
40
 
    }
41
 
    (*(liste -> liberer))(liste);
42
 
}
43
 
 
44
 
void ldc_ajouter_objet(liste,objet)
45
 
ldc_liste_chainee liste;
46
 
ldc_objet_liste objet;
47
 
{
48
 
    ldc_element_liste nouvel_element;
49
 
 
50
 
    nouvel_element = (*(liste -> allouer))(sizeof(struct ldc_Element_liste));
51
 
 
52
 
    if (liste -> premier_element != NULL)
53
 
        (liste -> premier_element) -> precedent = nouvel_element;
54
 
    nouvel_element -> suivant = liste -> premier_element;
55
 
    nouvel_element -> precedent = NULL;
56
 
    liste -> premier_element = nouvel_element;
57
 
    nouvel_element -> objet = objet;
58
 
}
59
 
 
60
 
int ldc_supprimer_objet(liste,objet)
61
 
ldc_liste_chainee liste;
62
 
ldc_objet_liste objet;
63
 
{
64
 
    ldc_element_liste element_a_supprimer;
65
 
 
66
 
    element_a_supprimer = ldc_rechercher_element(liste,objet);
67
 
 
68
 
    if (element_a_supprimer == NULL)
69
 
        return 0;
70
 
 
71
 
    if (liste -> desallouer != NULL)
72
 
        (liste -> desallouer)(element_a_supprimer -> objet);
73
 
 
74
 
    if (element_a_supprimer == liste -> premier_element)
75
 
        liste -> premier_element = element_a_supprimer -> suivant;
76
 
    else
77
 
        (element_a_supprimer -> precedent) -> suivant = element_a_supprimer -> suivant;
78
 
 
79
 
    if ((element_a_supprimer -> suivant) != NULL)
80
 
        (element_a_supprimer -> suivant) -> precedent = element_a_supprimer -> precedent;
81
 
 
82
 
    (liste -> liberer)(element_a_supprimer);
83
 
 
84
 
    return 1;
85
 
}
86
 
 
87
 
static ldc_element_liste element1;
88
 
ldc_objet_liste ldc_objet_suivant(liste,correspondance)
89
 
ldc_liste_chainee liste;
90
 
ldc_element_correspondance correspondance;
91
 
{
92
 
  element1 = ldc_rechercher_element(liste,correspondance);
93
 
 
94
 
    if ((element1 == NULL) || (element1 -> suivant == NULL))
95
 
        return NULL;
96
 
 
97
 
    return (element1 -> suivant) -> objet;
98
 
}
99
 
 
100
 
static ldc_element_liste element2;
101
 
ldc_objet_liste ldc_objet_precedent(liste,correspondance)
102
 
ldc_liste_chainee liste;
103
 
ldc_element_correspondance correspondance;
104
 
{
105
 
    element2 = ldc_rechercher_element(liste,correspondance);
106
 
 
107
 
    if ((element2 == NULL) || (element2 -> precedent == NULL))
108
 
        return NULL;
109
 
 
110
 
    return (element2 -> precedent) -> objet;
111
 
}
112
 
 
113
 
static ldc_element_liste element_a_chercher;
114
 
static ldc_element_liste ldc_rechercher_element(liste,correspondance)
115
 
ldc_liste_chainee liste;
116
 
ldc_element_correspondance correspondance;
117
 
{
118
 
 
119
 
    element_a_chercher = liste -> premier_element;
120
 
    while(element_a_chercher != NULL)
121
 
    {
122
 
        if ((*(liste -> correspondre))(element_a_chercher -> objet,correspondance))
123
 
            break;
124
 
        element_a_chercher = element_a_chercher -> suivant;
125
 
    }
126
 
 
127
 
    return element_a_chercher;
128
 
}
129
 
 
130
 
static ldc_element_liste element3;
131
 
ldc_objet_liste ldc_rechercher_objet(liste,correspondance)
132
 
ldc_liste_chainee liste;
133
 
ldc_element_correspondance correspondance;
134
 
{
135
 
 
136
 
    element3 = ldc_rechercher_element(liste,correspondance);
137
 
 
138
 
    if (element3 == NULL)
139
 
        return NULL;
140
 
    return element3 -> objet;
141
 
}
142
 
 
143
 
void ldc_appliquer_liste(liste,fonction_sur_objet)
144
 
ldc_liste_chainee liste;
145
 
void (*fonction_sur_objet)();
146
 
{
147
 
    ldc_element_liste element;
148
 
 
149
 
    element = liste -> premier_element;
150
 
    while(element != NULL)
151
 
    {
152
 
        (*fonction_sur_objet)(element -> objet);
153
 
        element = element -> suivant;
154
 
    }
155
 
}