File:
[local] /
rpl /
src /
instructions_s10.c
Revision
1.58:
download - view:
text,
annotated -
select for diffs -
revision graph
Sun May 20 17:28:26 2012 UTC (12 years, 11 months ago) by
bertrand
Branches:
MAIN
CVS tags:
HEAD
Correction de POLL pour traiter une liste de descripteurs et obtenir
des informations sur les types d'actions "pollables". Ajout d'un
timeout dans SMPHRTRYDECR. Si ce timeout vaut 0, la fonction est
équivalente à l'ancienne fonction SMPHRTRYDECR.
1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.8
4: Copyright (C) 1989-2012 Dr. BERTRAND Joël
5:
6: This file is part of RPL/2.
7:
8: RPL/2 is free software; you can redistribute it and/or modify it
9: under the terms of the CeCILL V2 License as published by the french
10: CEA, CNRS and INRIA.
11:
12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
15: for more details.
16:
17: You should have received a copy of the CeCILL License
18: along with RPL/2. If not, write to info@cecill.info.
19: ================================================================================
20: */
21:
22:
23: #include "rpl-conv.h"
24:
25:
26: /*
27: ================================================================================
28: Fonction 'spawn'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_spawn(struct_processus *s_etat_processus)
40: {
41: logical1 drapeau;
42: logical1 variable_partagee;
43:
44: pthread_attr_t attributs;
45:
46: pthread_mutexattr_t attributs_mutex;
47:
48: pthread_t thread_surveillance;
49:
50: struct_descripteur_thread *s_argument_thread;
51:
52: struct_liste_chainee *l_element_courant;
53:
54: struct_objet *s_copie;
55: struct_objet *s_objet;
56: struct_objet *s_objet_resultat;
57: struct_objet *s_objet_systeme;
58:
59: struct_processus *s_nouvel_etat_processus;
60:
61: struct timespec attente;
62:
63: (*s_etat_processus).erreur_execution = d_ex;
64:
65: if ((*s_etat_processus).affichage_arguments == 'Y')
66: {
67: printf("\n SPAWN ");
68:
69: if ((*s_etat_processus).langue == 'F')
70: {
71: printf("(lancement d'un thread)\n\n");
72: }
73: else
74: {
75: printf("(create thread)\n\n");
76: }
77:
78: printf(" 1: %s, %s\n", d_NOM, d_RPN);
79: printf("-> 1: %s\n", d_PRC);
80:
81: return;
82: }
83: else if ((*s_etat_processus).test_instruction == 'Y')
84: {
85: (*s_etat_processus).nombre_arguments = -1;
86: return;
87: }
88:
89: if (test_cfsf(s_etat_processus, 31) == d_vrai)
90: {
91: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
92: {
93: return;
94: }
95: }
96:
97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
98: &s_objet) == d_erreur)
99: {
100: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
101: return;
102: }
103:
104: /*
105: * Une routine fille doit pouvoir renvoyer des objets au processus
106: * père au travers de la fonction SEND. Il ne peut donc s'agir que
107: * d'une fonction ou d'une expression RPN.
108: */
109:
110: if (((*s_objet).type != NOM) && ((*s_objet).type != RPN))
111: {
112: liberation(s_etat_processus, s_objet);
113:
114: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
115: return;
116: }
117:
118: /*
119: * Si l'argument est de type NOM, il faut que la variable correspondante
120: * soit une variable de type RPN.
121: */
122:
123: variable_partagee = d_faux;
124: s_copie = NULL;
125:
126: if ((*s_objet).type == NOM)
127: {
128: if (recherche_variable(s_etat_processus, (*((struct_nom *)
129: (*s_objet).objet)).nom) == d_vrai)
130: {
131: if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
132: {
133: if (pthread_mutex_lock(&((*(*s_etat_processus)
134: .s_liste_variables_partagees).mutex)) != 0)
135: {
136: (*s_etat_processus).erreur_systeme = d_es_processus;
137: return;
138: }
139:
140: if (recherche_variable_partagee(s_etat_processus,
141: (*(*s_etat_processus).pointeur_variable_courante).nom,
142: (*(*s_etat_processus).pointeur_variable_courante)
143: .variable_partagee, (*(*s_etat_processus)
144: .pointeur_variable_courante).origine) == d_faux)
145: {
146: if (pthread_mutex_unlock(&((*(*s_etat_processus)
147: .s_liste_variables_partagees).mutex)) != 0)
148: {
149: (*s_etat_processus).erreur_systeme = d_es_processus;
150: return;
151: }
152:
153: liberation(s_etat_processus, s_objet);
154:
155: (*s_etat_processus).erreur_systeme = d_es;
156: (*s_etat_processus).erreur_execution =
157: d_ex_argument_invalide;
158: return;
159: }
160:
161: if (((*(*(*s_etat_processus).s_liste_variables_partagees)
162: .table[(*(*s_etat_processus)
163: .s_liste_variables_partagees).position_variable].objet)
164: .type != RPN) && ((*(*(*s_etat_processus)
165: .s_liste_variables_partagees).table
166: [(*(*s_etat_processus).s_liste_variables_partagees)
167: .position_variable].objet).type != ADR))
168: {
169: if (pthread_mutex_unlock(&((*(*s_etat_processus)
170: .s_liste_variables_partagees).mutex)) != 0)
171: {
172: (*s_etat_processus).erreur_systeme = d_es_processus;
173: return;
174: }
175:
176: liberation(s_etat_processus, s_objet);
177:
178: (*s_etat_processus).erreur_execution =
179: d_ex_argument_invalide;
180: return;
181: }
182:
183: if ((s_copie = copie_objet(s_etat_processus,
184: (*(*s_etat_processus)
185: .s_liste_variables_partagees).table
186: [(*(*s_etat_processus).s_liste_variables_partagees)
187: .position_variable].objet, 'P')) == NULL)
188: {
189: if (pthread_mutex_unlock(&((*(*s_etat_processus)
190: .s_liste_variables_partagees).mutex)) != 0)
191: {
192: (*s_etat_processus).erreur_systeme = d_es_processus;
193: return;
194: }
195:
196: (*s_etat_processus).erreur_systeme =
197: d_es_allocation_memoire;
198:
199: return;
200: }
201:
202: variable_partagee = d_vrai;
203:
204: if (pthread_mutex_unlock(&((*(*s_etat_processus)
205: .s_liste_variables_partagees).mutex)) != 0)
206: {
207: (*s_etat_processus).erreur_systeme = d_es_processus;
208: return;
209: }
210: }
211: else
212: {
213: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
214: .type != RPN) && ((*(*(*s_etat_processus)
215: .pointeur_variable_courante).objet).type != ADR))
216: {
217: liberation(s_etat_processus, s_objet);
218:
219: (*s_etat_processus).erreur_execution =
220: d_ex_argument_invalide;
221: return;
222: }
223: }
224: }
225: else // Variable inexistante
226: {
227: liberation(s_etat_processus, s_objet);
228:
229: (*s_etat_processus).erreur_systeme = d_es;
230: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
231: return;
232: }
233: }
234:
235: if ((s_argument_thread = malloc(sizeof(struct_descripteur_thread))) == NULL)
236: {
237: (*s_etat_processus).erreur_systeme = d_es_processus;
238: return;
239: }
240:
241: if (pipe((*s_argument_thread).pipe_erreurs) != 0)
242: {
243: (*s_etat_processus).erreur_systeme = d_es_processus;
244: return;
245: }
246:
247: if (pipe((*s_argument_thread).pipe_interruptions) != 0)
248: {
249: (*s_etat_processus).erreur_systeme = d_es_processus;
250: return;
251: }
252:
253: if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0)
254: {
255: (*s_etat_processus).erreur_systeme = d_es_processus;
256: return;
257: }
258:
259: if (pipe((*s_argument_thread).pipe_objets) != 0)
260: {
261: (*s_etat_processus).erreur_systeme = d_es_processus;
262: return;
263: }
264:
265: if (pipe((*s_argument_thread).pipe_acquittement) != 0)
266: {
267: (*s_etat_processus).erreur_systeme = d_es_processus;
268: return;
269: }
270:
271: if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0)
272: {
273: (*s_etat_processus).erreur_systeme = d_es_processus;
274: return;
275: }
276:
277: if (pipe((*s_argument_thread).pipe_injections) != 0)
278: {
279: (*s_etat_processus).erreur_systeme = d_es_processus;
280: return;
281: }
282:
283: if (pipe((*s_argument_thread).pipe_nombre_injections) != 0)
284: {
285: (*s_etat_processus).erreur_systeme = d_es_processus;
286: return;
287: }
288:
289: if ((s_nouvel_etat_processus = copie_etat_processus(s_etat_processus))
290: == NULL)
291: {
292: return;
293: }
294:
295: pthread_mutexattr_init(&attributs_mutex);
296: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
297: pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);
298: pthread_mutexattr_destroy(&attributs_mutex);
299:
300: pthread_mutexattr_init(&attributs_mutex);
301: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
302: pthread_mutex_init(&((*s_argument_thread).mutex_nombre_references),
303: &attributs_mutex);
304: pthread_mutexattr_destroy(&attributs_mutex);
305:
306: (*s_argument_thread).processus_detache = d_faux;
307: (*s_argument_thread).thread_actif = d_faux;
308: (*s_argument_thread).thread_pere = pthread_self();
309: (*s_argument_thread).pid = getpid();
310:
311: (*s_nouvel_etat_processus).pipe_donnees =
312: (*s_argument_thread).pipe_objets[1];
313: (*s_nouvel_etat_processus).pipe_nombre_objets_attente =
314: (*s_argument_thread).pipe_nombre_objets_attente[1];
315: (*s_nouvel_etat_processus).pipe_interruptions =
316: (*s_argument_thread).pipe_interruptions[1];
317: (*s_nouvel_etat_processus).pipe_nombre_interruptions_attente =
318: (*s_argument_thread).pipe_nombre_interruptions_attente[1];
319: (*s_nouvel_etat_processus).pipe_injections =
320: (*s_argument_thread).pipe_injections[0];
321: (*s_nouvel_etat_processus).pipe_nombre_injections =
322: (*s_argument_thread).pipe_nombre_injections[0];
323: (*s_nouvel_etat_processus).pipe_acquittement =
324: (*s_argument_thread).pipe_acquittement[0];
325: (*s_nouvel_etat_processus).presence_pipes = d_vrai;
326:
327: (*s_nouvel_etat_processus).niveau_initial =
328: (*s_etat_processus).niveau_courant;
329: (*s_nouvel_etat_processus).debug_programme = d_faux;
330: (*s_nouvel_etat_processus).nombre_objets_injectes = 0;
331: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
332: (*s_nouvel_etat_processus).temps_maximal_cpu = 0;
333: (*s_nouvel_etat_processus).presence_fusible = d_faux;
334: (*s_nouvel_etat_processus).thread_fusible = 0;
335:
336: (*s_nouvel_etat_processus).pile_profilage = NULL;
337: (*s_nouvel_etat_processus).pile_profilage_fonctions = NULL;
338:
339: /*
340: * Lancement du thread fils et du thread de surveillance
341: */
342:
343: if (pthread_attr_init(&attributs) != 0)
344: {
345: (*s_etat_processus).erreur_systeme = d_es_processus;
346: return;
347: }
348:
349: if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0)
350: {
351: (*s_etat_processus).erreur_systeme = d_es_processus;
352: return;
353: }
354:
355: # ifdef SCHED_OTHER
356: if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
357: {
358: (*s_etat_processus).erreur_systeme = d_es_processus;
359: return;
360: }
361: # endif
362:
363: # ifdef PTHREAD_EXPLICIT_SCHED
364: if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0)
365: {
366: (*s_etat_processus).erreur_systeme = d_es_processus;
367: return;
368: }
369: # endif
370:
371: # ifdef PTHREAD_SCOPE_SYSTEM
372: if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
373: {
374: (*s_etat_processus).erreur_systeme = d_es_processus;
375: return;
376: }
377: # endif
378:
379: /*
380: * Création de l'objet à retourner
381: */
382:
383: if ((s_objet_resultat = allocation(s_etat_processus, PRC)) == NULL)
384: {
385: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
386: return;
387: }
388:
389: (*((struct_processus_fils *) (*s_objet_resultat).objet)).thread
390: = s_argument_thread;
391:
392: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread)
393: .nombre_objets_dans_pipe = 0;
394: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread)
395: .nombre_interruptions_dans_pipe = 0;
396: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread)
397: .nombre_references = 1;
398:
399: // Lancement du thread fils
400:
401: (*s_argument_thread).s_nouvel_etat_processus = s_nouvel_etat_processus;
402: (*s_argument_thread).s_etat_processus = s_etat_processus;
403:
404: if (variable_partagee == d_vrai)
405: {
406: (*s_argument_thread).argument = s_copie;
407: (*s_argument_thread).destruction_objet = d_vrai;
408: }
409: else
410: {
411: (*s_argument_thread).argument = s_objet;
412: (*s_argument_thread).destruction_objet = d_faux;
413: }
414:
415: (*s_argument_thread).thread_actif = d_faux;
416:
417: if (pthread_create(&(*s_nouvel_etat_processus).tid,
418: &attributs, lancement_thread, s_argument_thread) != 0)
419: {
420: (*s_etat_processus).erreur_systeme = d_es_processus;
421: return;
422: }
423:
424: attente.tv_sec = 0;
425: attente.tv_nsec = GRANULARITE_us * 1000;
426:
427: while((*s_argument_thread).thread_actif == d_faux)
428: {
429: scrutation_interruptions(s_etat_processus);
430: nanosleep(&attente, NULL);
431: INCR_GRANULARITE(attente.tv_nsec);
432: }
433:
434: if (pthread_attr_destroy(&attributs) != 0)
435: {
436: (*s_etat_processus).erreur_systeme = d_es_processus;
437: return;
438: }
439:
440: if (pthread_attr_init(&attributs) != 0)
441: {
442: (*s_etat_processus).erreur_systeme = d_es_processus;
443: return;
444: }
445:
446: if (pthread_attr_setdetachstate(&attributs,
447: PTHREAD_CREATE_DETACHED) != 0)
448: {
449: (*s_etat_processus).erreur_systeme = d_es_processus;
450: return;
451: }
452:
453: # ifdef SCHED_OTHER
454: if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
455: {
456: (*s_etat_processus).erreur_systeme = d_es_processus;
457: return;
458: }
459: # endif
460:
461: # ifdef PTHREAD_EXPLICIT_SCHED
462: if (pthread_attr_setinheritsched(&attributs,
463: PTHREAD_EXPLICIT_SCHED) != 0)
464: {
465: (*s_etat_processus).erreur_systeme = d_es_processus;
466: return;
467: }
468: # endif
469:
470: # ifdef PTHREAD_SCOPE_SYSTEM
471: if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
472: {
473: (*s_etat_processus).erreur_systeme = d_es_processus;
474: return;
475: }
476: # endif
477:
478: /*
479: * On copie l'objet plutôt que le pointeur car cet objet peut être
480: * accédé depuis deux threads distincts et aboutir à un blocage lors d'une
481: * copie.
482: */
483:
484: if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet_resultat, 'O'))
485: == NULL)
486: {
487: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
488: return;
489: }
490:
491: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
492: {
493: pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex));
494: (*s_etat_processus).erreur_systeme = d_es_processus;
495: return;
496: }
497:
498: // Si le tid existe déjà dans la pile des processus, il s'agit forcement
499: // d'un processus moribond. On attend donc qu'il soit effectivement
500: // libéré.
501:
502: do
503: {
504: l_element_courant = (struct_liste_chainee *)
505: (*s_etat_processus).l_base_pile_processus;
506: drapeau = d_faux;
507:
508: attente.tv_sec = 0;
509: attente.tv_nsec = GRANULARITE_us * 1000;
510:
511: while(l_element_courant != NULL)
512: {
513: if (((*(*((struct_processus_fils *)
514: (*(*l_element_courant).donnee).objet)).thread)
515: .processus_detache == d_faux) &&
516: ((*s_argument_thread).processus_detache == d_faux))
517: {
518: if (pthread_equal((*(*((struct_processus_fils *)
519: (*(*l_element_courant).donnee).objet)).thread)
520: .tid, (*s_argument_thread).tid) != 0)
521: {
522: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
523: {
524: (*s_etat_processus).erreur_systeme = d_es_processus;
525: return;
526: }
527:
528: scrutation_injection(s_etat_processus);
529:
530: if ((*s_etat_processus).nombre_interruptions_non_affectees
531: != 0)
532: {
533: affectation_interruptions_logicielles(s_etat_processus);
534: }
535:
536: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
537: {
538: traitement_interruptions_logicielles(s_etat_processus);
539: }
540:
541: nanosleep(&attente, NULL);
542: INCR_GRANULARITE(attente.tv_nsec);
543:
544: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
545: {
546: (*s_etat_processus).erreur_systeme = d_es_processus;
547: return;
548: }
549:
550: drapeau = d_vrai;
551: break;
552: }
553: }
554:
555: scrutation_interruptions(s_etat_processus);
556: l_element_courant = (*l_element_courant).suivant;
557: }
558: } while(drapeau == d_vrai);
559:
560: if (empilement(s_etat_processus,
561: (struct_liste_chainee **) &((*s_etat_processus)
562: .l_base_pile_processus), s_objet_systeme) == d_erreur)
563: {
564: pthread_mutex_unlock(&((*s_etat_processus).mutex));
565: return;
566: }
567:
568: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
569: {
570: (*s_etat_processus).erreur_systeme = d_es_processus;
571: return;
572: }
573:
574: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
575: s_objet_resultat) == d_erreur)
576: {
577: return;
578: }
579:
580: if (pthread_mutex_lock(&(*s_argument_thread).mutex) != 0)
581: {
582: (*s_etat_processus).erreur_systeme = d_es_processus;
583: return;
584: }
585:
586: if ((*s_argument_thread).thread_actif == d_faux)
587: {
588: // Le thread n'existe plus.
589:
590: pthread_join((*s_argument_thread).tid, NULL);
591: pthread_mutex_unlock(&(*s_argument_thread).mutex);
592: (*s_etat_processus).erreur_systeme = d_es_processus;
593: return;
594: }
595:
596: if (pthread_mutex_unlock(&(*s_argument_thread).mutex) != 0)
597: {
598: (*s_etat_processus).erreur_systeme = d_es_processus;
599: return;
600: }
601:
602: // Lancement du thread de surveillance
603:
604: if (pthread_create(&thread_surveillance, &attributs,
605: surveillance_processus, s_argument_thread) != 0)
606: {
607: (*s_etat_processus).erreur_systeme = d_es_processus;
608: return;
609: }
610:
611: if (pthread_attr_destroy(&attributs) != 0)
612: {
613: (*s_etat_processus).erreur_systeme = d_es_processus;
614: return;
615: }
616:
617: // Le fils peut être présent sans être en attente du signal de départ.
618:
619: if (envoi_signal_thread((*s_argument_thread).tid, rpl_sigstart) != 0)
620: {
621: (*s_etat_processus).erreur_systeme = d_es_processus;
622: return;
623: }
624:
625: return;
626: }
627:
628:
629: /*
630: ================================================================================
631: Fonction 'sqlconnect'
632: ================================================================================
633: Entrées :
634: --------------------------------------------------------------------------------
635: Sorties :
636: --------------------------------------------------------------------------------
637: Effets de bord : néant
638: ================================================================================
639: */
640:
641: void
642: instruction_sqlconnect(struct_processus *s_etat_processus)
643: {
644: struct_objet *s_objet_argument;
645: struct_objet *s_objet_resultat;
646: struct_objet *s_objet_systeme;
647:
648: (*s_etat_processus).erreur_execution = d_ex;
649:
650: if ((*s_etat_processus).affichage_arguments == 'Y')
651: {
652: printf("\n SQLCONNECT ");
653:
654: if ((*s_etat_processus).langue == 'F')
655: {
656: printf("(connexion à une base de données SQL)\n\n");
657: }
658: else
659: {
660: printf("(connect to SQL database)\n\n");
661: }
662:
663: printf(" 1: %s\n", d_LST);
664: printf("-> 1: %s\n\n", d_SQL);
665:
666: if ((*s_etat_processus).langue == 'F')
667: {
668: printf(" Utilisation :\n\n");
669: }
670: else
671: {
672: printf(" Usage:\n\n");
673: }
674:
675: printf(" { \"mysql\" \"server\" \"database\" "
676: "\"user\" \"password\" } SQLCONNECT\n");
677: printf(" { \"postgresql:iso-8859-1\" \"server\" "
678: "\"database\" \"user\" \"password\" port }\n");
679: printf(" SQLCONNECT\n");
680:
681: return;
682: }
683: else if ((*s_etat_processus).test_instruction == 'Y')
684: {
685: (*s_etat_processus).nombre_arguments = -1;
686: return;
687: }
688:
689: if (test_cfsf(s_etat_processus, 31) == d_vrai)
690: {
691: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
692: {
693: return;
694: }
695: }
696:
697: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
698: &s_objet_argument) == d_erreur)
699: {
700: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
701: return;
702: }
703:
704: if ((*s_objet_argument).type == LST)
705: {
706: if ((s_objet_resultat = parametres_sql(s_etat_processus,
707: s_objet_argument)) == NULL)
708: {
709: liberation(s_etat_processus, s_objet_resultat);
710: liberation(s_etat_processus, s_objet_argument);
711: return;
712: }
713:
714: if ((*s_etat_processus).erreur_execution ==
715: d_ex_instruction_indisponible)
716: {
717: liberation(s_etat_processus, s_objet_resultat);
718: return;
719: }
720:
721: if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet_resultat,
722: 'O')) == NULL)
723: {
724: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
725: return;
726: }
727:
728: if (empilement(s_etat_processus,
729: (struct_liste_chainee **) &((*s_etat_processus)
730: .s_connecteurs_sql), s_objet_systeme) == d_erreur)
731: {
732: return;
733: }
734:
735: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
736: s_objet_resultat) == d_erreur)
737: {
738: return;
739: }
740: }
741: else
742: {
743: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
744:
745: liberation(s_etat_processus, s_objet_argument);
746: return;
747: }
748:
749: liberation(s_etat_processus, s_objet_argument);
750: return;
751: }
752:
753:
754: /*
755: ================================================================================
756: Fonction 'sqldisconnect'
757: ================================================================================
758: Entrées :
759: --------------------------------------------------------------------------------
760: Sorties :
761: --------------------------------------------------------------------------------
762: Effets de bord : néant
763: ================================================================================
764: */
765:
766: void
767: instruction_sqldisconnect(struct_processus *s_etat_processus)
768: {
769: logical1 drapeau;
770:
771: struct_liste_chainee *l_element_courant;
772: struct_liste_chainee *l_element_precedent;
773:
774: struct_objet *s_objet;
775:
776: (*s_etat_processus).erreur_execution = d_ex;
777:
778: if ((*s_etat_processus).affichage_arguments == 'Y')
779: {
780: printf("\n SQLDISCONNECT ");
781:
782: if ((*s_etat_processus).langue == 'F')
783: {
784: printf("(déconnexion d'une base de donnée SQL)\n\n");
785: }
786: else
787: {
788: printf("(disconnection from SQL database)\n\n");
789: }
790:
791: printf(" 1: %s\n", d_SQL);
792: return;
793: }
794: else if ((*s_etat_processus).test_instruction == 'Y')
795: {
796: (*s_etat_processus).nombre_arguments = -1;
797: return;
798: }
799:
800: if (test_cfsf(s_etat_processus, 31) == d_vrai)
801: {
802: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
803: {
804: return;
805: }
806: }
807:
808: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
809: &s_objet) == d_erreur)
810: {
811: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
812: return;
813: }
814:
815: if ((*s_objet).type == SQL)
816: {
817: if (((*((struct_connecteur_sql *) (*s_objet).objet)).pid !=
818: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
819: (*s_objet).objet)).tid, pthread_self()) == 0))
820: {
821: (*s_etat_processus).erreur_execution = d_ex_fichier_hors_contexte;
822:
823: liberation(s_etat_processus, s_objet);
824: return;
825: }
826:
827: l_element_courant = (*s_etat_processus).s_connecteurs_sql;
828: l_element_precedent = NULL;
829:
830: while(l_element_courant != NULL)
831: {
832: if (((*((struct_connecteur_sql *) (*(*l_element_courant).donnee)
833: .objet)).pid == getpid()) && (pthread_equal(
834: (*((struct_connecteur_sql *) (*(*l_element_courant).donnee)
835: .objet)).tid, pthread_self()) != 0) &&
836: (strcmp((*((struct_connecteur_sql *) (*(*l_element_courant)
837: .donnee).objet)).type, (*((struct_connecteur_sql *)
838: (*s_objet).objet)).type) == 0))
839: {
840: if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type,
841: "MYSQL") == 0)
842: {
843: # ifdef MYSQL_SUPPORT
844:
845: if ((*((struct_connecteur_sql *) (*(*l_element_courant)
846: .donnee).objet)).descripteur.mysql ==
847: (*((struct_connecteur_sql *) (*s_objet).objet))
848: .descripteur.mysql)
849: {
850: drapeau = d_vrai;
851: }
852: else
853: {
854: drapeau = d_faux;
855: }
856:
857: # else
858:
859: if ((*s_etat_processus).langue == 'F')
860: {
861: printf("+++Attention : Support de MySQL "
862: "non compilé !\n");
863: }
864: else
865: {
866: printf("+++Warning : MySQL support not available !\n");
867: }
868:
869: fflush(stdout);
870:
871: drapeau = d_faux;
872: # endif
873: }
874: else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet))
875: .type, "POSTGRESQL") == 0)
876: {
877: # ifdef POSTGRESQL_SUPPORT
878:
879: if ((*((struct_connecteur_sql *) (*(*l_element_courant)
880: .donnee).objet)).descripteur.postgresql ==
881: (*((struct_connecteur_sql *) (*s_objet).objet))
882: .descripteur.postgresql)
883: {
884: drapeau = d_vrai;
885: }
886: else
887: {
888: drapeau = d_faux;
889: }
890:
891: # else
892:
893: if ((*s_etat_processus).langue == 'F')
894: {
895: printf("+++Attention : Support de PostgreSQL "
896: "non compilé !\n");
897: }
898: else
899: {
900: printf("+++Warning : PostgreSQL support "
901: "not available !\n");
902: }
903:
904: fflush(stdout);
905:
906: drapeau = d_faux;
907: # endif
908: }
909: else
910: {
911: BUG(1, printf("SQL type '%s' not allowed!",
912: (*((struct_connecteur_sql *) (*s_objet).objet))
913: .type));
914: return;
915: }
916:
917: if (drapeau == d_vrai)
918: {
919: if (l_element_precedent == NULL)
920: {
921: (*s_etat_processus).s_connecteurs_sql =
922: (*l_element_courant).suivant;
923: }
924: else if ((*l_element_courant).suivant == NULL)
925: {
926: (*l_element_precedent).suivant = NULL;
927: }
928: else
929: {
930: (*l_element_precedent).suivant =
931: (*l_element_courant).suivant;
932: }
933:
934: liberation(s_etat_processus, (*l_element_courant).donnee);
935: free(l_element_courant);
936:
937: break;
938: }
939: }
940:
941: l_element_precedent = l_element_courant;
942: l_element_courant = (*l_element_courant).suivant;
943: }
944:
945: sqlclose(s_objet);
946: }
947: else
948: {
949: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
950:
951: liberation(s_etat_processus, s_objet);
952: return;
953: }
954:
955: liberation(s_etat_processus, s_objet);
956: return;
957: }
958:
959:
960: /*
961: ================================================================================
962: Fonction 'smphrincr'
963: ================================================================================
964: Entrées :
965: --------------------------------------------------------------------------------
966: Sorties :
967: --------------------------------------------------------------------------------
968: Effets de bord : néant
969: ================================================================================
970: */
971:
972: void
973: instruction_smphrincr(struct_processus *s_etat_processus)
974: {
975: struct_objet *s_objet_argument;
976:
977: (*s_etat_processus).erreur_execution = d_ex;
978:
979: if ((*s_etat_processus).affichage_arguments == 'Y')
980: {
981: printf("\n SMPHRINCR ");
982:
983: if ((*s_etat_processus).langue == 'F')
984: {
985: printf("(incrémentation du sémaphore)\n\n");
986: }
987: else
988: {
989: printf("(semaphore incrementation)\n\n");
990: }
991:
992: printf(" 1: %s\n", d_SPH);
993: return;
994: }
995: else if ((*s_etat_processus).test_instruction == 'Y')
996: {
997: (*s_etat_processus).nombre_arguments = -1;
998: return;
999: }
1000:
1001: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1002: {
1003: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1004: {
1005: return;
1006: }
1007: }
1008:
1009: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1010: &s_objet_argument) == d_erreur)
1011: {
1012: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1013: return;
1014: }
1015:
1016: if ((*s_objet_argument).type == SPH)
1017: {
1018: if (sem_post((*((struct_semaphore *) (*s_objet_argument).objet))
1019: .semaphore) != 0)
1020: {
1021: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1022:
1023: liberation(s_etat_processus, s_objet_argument);
1024: return;
1025: }
1026:
1027: liberation(s_etat_processus, s_objet_argument);
1028: }
1029: else
1030: {
1031: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1032:
1033: liberation(s_etat_processus, s_objet_argument);
1034: return;
1035: }
1036:
1037: return;
1038: }
1039:
1040:
1041: /*
1042: ================================================================================
1043: Fonction 'smphrdecr'
1044: ================================================================================
1045: Entrées :
1046: --------------------------------------------------------------------------------
1047: Sorties :
1048: --------------------------------------------------------------------------------
1049: Effets de bord : néant
1050: ================================================================================
1051: */
1052:
1053: void
1054: instruction_smphrdecr(struct_processus *s_etat_processus)
1055: {
1056: struct_objet *s_objet_argument;
1057:
1058: unsigned char *tampon;
1059:
1060: (*s_etat_processus).erreur_execution = d_ex;
1061:
1062: if ((*s_etat_processus).affichage_arguments == 'Y')
1063: {
1064: printf("\n SMPHRDECR ");
1065:
1066: if ((*s_etat_processus).langue == 'F')
1067: {
1068: printf("(decrémentation du sémaphore)\n\n");
1069: }
1070: else
1071: {
1072: printf("(semaphore decrementation)\n\n");
1073: }
1074:
1075: printf(" 1: %s\n", d_SPH);
1076: return;
1077: }
1078: else if ((*s_etat_processus).test_instruction == 'Y')
1079: {
1080: (*s_etat_processus).nombre_arguments = -1;
1081: return;
1082: }
1083:
1084: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1085: {
1086: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1087: {
1088: return;
1089: }
1090: }
1091:
1092: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1093: &s_objet_argument) == d_erreur)
1094: {
1095: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1096: return;
1097: }
1098:
1099: if ((*s_objet_argument).type == SPH)
1100: {
1101: if ((*s_etat_processus).profilage == d_vrai)
1102: {
1103: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
1104: == NULL)
1105: {
1106: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1107: return;
1108: }
1109:
1110: profilage(s_etat_processus, tampon);
1111: free(tampon);
1112:
1113: if ((*s_etat_processus).erreur_systeme != d_es)
1114: {
1115: return;
1116: }
1117: }
1118:
1119: # ifndef SEMAPHORES_NOMMES
1120: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1121: # else
1122: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1123: # endif
1124: {
1125: (*s_etat_processus).erreur_systeme = d_es_processus;
1126: return;
1127: }
1128:
1129: while(sem_wait((*((struct_semaphore *) (*s_objet_argument).objet))
1130: .semaphore) == -1)
1131: {
1132: if (errno != EINTR)
1133: {
1134: # ifndef SEMAPHORES_NOMMES
1135: sem_post(&((*s_etat_processus).semaphore_fork));
1136: # else
1137: sem_post((*s_etat_processus).semaphore_fork);
1138: # endif
1139:
1140: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1141:
1142: if ((*s_etat_processus).profilage == d_vrai)
1143: {
1144: profilage(s_etat_processus, NULL);
1145: }
1146:
1147: liberation(s_etat_processus, s_objet_argument);
1148: return;
1149: }
1150: }
1151:
1152: # ifndef SEMAPHORES_NOMMES
1153: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1154: # else
1155: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1156: # endif
1157: {
1158: if (errno != EINTR)
1159: {
1160: if ((*s_etat_processus).profilage == d_vrai)
1161: {
1162: profilage(s_etat_processus, NULL);
1163: }
1164:
1165: (*s_etat_processus).erreur_systeme = d_es_processus;
1166: return;
1167: }
1168: }
1169:
1170: if ((*s_etat_processus).profilage == d_vrai)
1171: {
1172: profilage(s_etat_processus, NULL);
1173: }
1174:
1175: liberation(s_etat_processus, s_objet_argument);
1176: }
1177: else
1178: {
1179: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1180:
1181: liberation(s_etat_processus, s_objet_argument);
1182: return;
1183: }
1184:
1185: return;
1186: }
1187:
1188:
1189: /*
1190: ================================================================================
1191: Fonction 'smphrtrydecr'
1192: ================================================================================
1193: Entrées :
1194: --------------------------------------------------------------------------------
1195: Sorties :
1196: --------------------------------------------------------------------------------
1197: Effets de bord : néant
1198: ================================================================================
1199: */
1200:
1201: void
1202: instruction_smphrtrydecr(struct_processus *s_etat_processus)
1203: {
1204: real8 partie_entiere;
1205:
1206: struct_objet *s_objet_argument_1;
1207: struct_objet *s_objet_argument_2;
1208: struct_objet *s_objet_resultat;
1209:
1210: struct timeval horodatage;
1211:
1212: struct timespec horodatage_absolu;
1213:
1214: unsigned char *tampon;
1215:
1216: (*s_etat_processus).erreur_execution = d_ex;
1217:
1218: if ((*s_etat_processus).affichage_arguments == 'Y')
1219: {
1220: printf("\n SMPHRTRYDECR ");
1221:
1222: if ((*s_etat_processus).langue == 'F')
1223: {
1224: printf("(essai de decrémentation du sémaphore)\n\n");
1225: }
1226: else
1227: {
1228: printf("(try to decremente semaphore)\n\n");
1229: }
1230:
1231: printf(" 2: %s\n", d_SPH);
1232: printf(" 1: %s, %s\n", d_INT, d_REL);
1233: printf("-> 1: %s\n", d_INT);
1234: return;
1235: }
1236: else if ((*s_etat_processus).test_instruction == 'Y')
1237: {
1238: (*s_etat_processus).nombre_arguments = -1;
1239: return;
1240: }
1241:
1242: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1243: {
1244: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1245: {
1246: return;
1247: }
1248: }
1249:
1250: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1251: &s_objet_argument_1) == d_erreur)
1252: {
1253: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1254: return;
1255: }
1256:
1257: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1258: &s_objet_argument_2) == d_erreur)
1259: {
1260: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1261: return;
1262: }
1263:
1264: if (((*s_objet_argument_2).type == SPH) && (((*s_objet_argument_1).type
1265: == INT) || ((*s_objet_argument_1).type == REL)))
1266: {
1267: gettimeofday(&horodatage, NULL);
1268:
1269: if ((*s_objet_argument_1).type == INT)
1270: {
1271: if ((*((integer8 *) (*s_objet_argument_1).objet)) < 0)
1272: {
1273: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1274:
1275: liberation(s_etat_processus, s_objet_argument_1);
1276: liberation(s_etat_processus, s_objet_argument_2);
1277: return;
1278: }
1279:
1280: horodatage.tv_sec += (*((integer8 *) (*s_objet_argument_1).objet));
1281: }
1282: else
1283: {
1284: if ((*((real8 *) (*s_objet_argument_1).objet)) < 0)
1285: {
1286: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1287:
1288: liberation(s_etat_processus, s_objet_argument_1);
1289: liberation(s_etat_processus, s_objet_argument_2);
1290: return;
1291: }
1292:
1293: partie_entiere = floor((*((real8 *) (*s_objet_argument_1).objet)));
1294: horodatage.tv_sec += partie_entiere;
1295: horodatage.tv_usec += (*((real8 *) (*s_objet_argument_1).objet))
1296: - partie_entiere;
1297:
1298: if (horodatage.tv_usec > 1000000)
1299: {
1300: horodatage.tv_usec -= 1000000;
1301: horodatage.tv_sec += 1;
1302: }
1303: }
1304:
1305: horodatage_absolu.tv_sec = horodatage.tv_sec;
1306: horodatage_absolu.tv_nsec = horodatage.tv_usec * 1000;
1307:
1308: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1309: {
1310: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1311: return;
1312: }
1313:
1314: if ((*s_etat_processus).profilage == d_vrai)
1315: {
1316: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument_2))
1317: == NULL)
1318: {
1319: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1320: return;
1321: }
1322:
1323: profilage(s_etat_processus, tampon);
1324: free(tampon);
1325:
1326: if ((*s_etat_processus).erreur_systeme != d_es)
1327: {
1328: return;
1329: }
1330: }
1331:
1332: # ifndef SEMAPHORES_NOMMES
1333: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1334: # else
1335: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1336: # endif
1337: {
1338: if ((*s_etat_processus).profilage == d_vrai)
1339: {
1340: profilage(s_etat_processus, NULL);
1341: }
1342:
1343: (*s_etat_processus).erreur_systeme = d_es_processus;
1344: return;
1345: }
1346:
1347: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
1348:
1349: while(sem_timedwait((*((struct_semaphore *) (*s_objet_argument_2)
1350: .objet)).semaphore, &horodatage_absolu) == -1)
1351: {
1352: switch(errno)
1353: {
1354: case EINTR :
1355: {
1356: break;
1357: }
1358:
1359: case EINVAL :
1360: {
1361: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1362:
1363: if ((*s_etat_processus).profilage == d_vrai)
1364: {
1365: profilage(s_etat_processus, NULL);
1366: }
1367:
1368: liberation(s_etat_processus, s_objet_argument_1);
1369: liberation(s_etat_processus, s_objet_argument_2);
1370: return;
1371: }
1372:
1373: case ETIMEDOUT :
1374: {
1375: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
1376: break;
1377: }
1378: }
1379:
1380: if ((*((integer8 *) (*s_objet_resultat).objet)) == 0)
1381: {
1382: break;
1383: }
1384: }
1385:
1386: # ifndef SEMAPHORES_NOMMES
1387: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1388: # else
1389: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1390: # endif
1391: {
1392: if (errno != EINTR)
1393: {
1394: if ((*s_etat_processus).profilage == d_vrai)
1395: {
1396: profilage(s_etat_processus, NULL);
1397: }
1398:
1399: (*s_etat_processus).erreur_systeme = d_es_processus;
1400: return;
1401: }
1402: }
1403:
1404: if ((*s_etat_processus).profilage == d_vrai)
1405: {
1406: profilage(s_etat_processus, NULL);
1407: }
1408:
1409: liberation(s_etat_processus, s_objet_argument_1);
1410: liberation(s_etat_processus, s_objet_argument_2);
1411: }
1412: else
1413: {
1414: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1415:
1416: liberation(s_etat_processus, s_objet_argument_1);
1417: liberation(s_etat_processus, s_objet_argument_2);
1418: return;
1419: }
1420:
1421: return;
1422: }
1423:
1424:
1425: /*
1426: ================================================================================
1427: Fonction 'smphrgetv'
1428: ================================================================================
1429: Entrées :
1430: --------------------------------------------------------------------------------
1431: Sorties :
1432: --------------------------------------------------------------------------------
1433: Effets de bord : néant
1434: ================================================================================
1435: */
1436:
1437: void
1438: instruction_smphrgetv(struct_processus *s_etat_processus)
1439: {
1440: int valeur;
1441:
1442: struct_objet *s_objet_argument;
1443: struct_objet *s_objet_resultat;
1444:
1445: (*s_etat_processus).erreur_execution = d_ex;
1446:
1447: if ((*s_etat_processus).affichage_arguments == 'Y')
1448: {
1449: printf("\n SMPHRGETV ");
1450:
1451: if ((*s_etat_processus).langue == 'F')
1452: {
1453: printf("(valeur du sémaphore)\n\n");
1454: }
1455: else
1456: {
1457: printf("(semaphore value)\n\n");
1458: }
1459:
1460: printf(" 1: %s\n", d_SPH);
1461: return;
1462: }
1463: else if ((*s_etat_processus).test_instruction == 'Y')
1464: {
1465: (*s_etat_processus).nombre_arguments = -1;
1466: return;
1467: }
1468:
1469: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1470: {
1471: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1472: {
1473: return;
1474: }
1475: }
1476:
1477: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1478: &s_objet_argument) == d_erreur)
1479: {
1480: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1481: return;
1482: }
1483:
1484: if ((*s_objet_argument).type == SPH)
1485: {
1486: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1487: {
1488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1489:
1490: liberation(s_etat_processus, s_objet_argument);
1491: return;
1492: }
1493:
1494: if (sem_getvalue((*((struct_semaphore *) (*s_objet_argument).objet))
1495: .semaphore, &valeur) != 0)
1496: {
1497: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1498:
1499: liberation(s_etat_processus, s_objet_argument);
1500: return;
1501: }
1502:
1503: (*((integer8 *) (*s_objet_resultat).objet)) = valeur;
1504:
1505: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1506: s_objet_resultat) == d_erreur)
1507: {
1508: return;
1509: }
1510:
1511: liberation(s_etat_processus, s_objet_argument);
1512: }
1513: else
1514: {
1515: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1516:
1517: liberation(s_etat_processus, s_objet_argument);
1518: return;
1519: }
1520:
1521: return;
1522: }
1523:
1524:
1525: /*
1526: ================================================================================
1527: Fonction 'svl'
1528: ================================================================================
1529: Entrées :
1530: --------------------------------------------------------------------------------
1531: Sorties :
1532: --------------------------------------------------------------------------------
1533: Effets de bord : néant
1534: ================================================================================
1535: */
1536:
1537: void
1538: instruction_svl(struct_processus *s_etat_processus)
1539: {
1540: struct_objet *s_objet_argument;
1541: struct_objet *s_objet_resultat;
1542:
1543: (*s_etat_processus).erreur_execution = d_ex;
1544:
1545: if ((*s_etat_processus).affichage_arguments == 'Y')
1546: {
1547: printf("\n SVL ");
1548:
1549: if ((*s_etat_processus).langue == 'F')
1550: {
1551: printf("(valeurs singulières)\n\n");
1552: }
1553: else
1554: {
1555: printf("(singular values)\n\n");
1556: }
1557:
1558: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1559: printf("-> 1: %s\n", d_VRL);
1560: return;
1561: }
1562: else if ((*s_etat_processus).test_instruction == 'Y')
1563: {
1564: (*s_etat_processus).nombre_arguments = -1;
1565: return;
1566: }
1567:
1568: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1569: {
1570: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1571: {
1572: return;
1573: }
1574: }
1575:
1576: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1577: &s_objet_argument) == d_erreur)
1578: {
1579: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1580: return;
1581: }
1582:
1583: if (((*s_objet_argument).type == MIN) ||
1584: ((*s_objet_argument).type == MRL) ||
1585: ((*s_objet_argument).type == MCX))
1586: {
1587: if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
1588: {
1589: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1590: return;
1591: }
1592:
1593: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1594: NULL, (*s_objet_resultat).objet, NULL);
1595:
1596: if ((*s_etat_processus).erreur_systeme != d_es)
1597: {
1598: return;
1599: }
1600:
1601: if (((*s_etat_processus).erreur_execution != d_ex) ||
1602: ((*s_etat_processus).exception != d_ep))
1603: {
1604: liberation(s_etat_processus, s_objet_resultat);
1605: liberation(s_etat_processus, s_objet_argument);
1606: return;
1607: }
1608:
1609: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1610: s_objet_resultat) == d_erreur)
1611: {
1612: return;
1613: }
1614: }
1615: else
1616: {
1617: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1618:
1619: liberation(s_etat_processus, s_objet_argument);
1620: return;
1621: }
1622:
1623: liberation(s_etat_processus, s_objet_argument);
1624:
1625: return;
1626: }
1627:
1628:
1629: /*
1630: ================================================================================
1631: Fonction 'svd'
1632: ================================================================================
1633: Entrées :
1634: --------------------------------------------------------------------------------
1635: Sorties :
1636: --------------------------------------------------------------------------------
1637: Effets de bord : néant
1638: ================================================================================
1639: */
1640:
1641: void
1642: instruction_svd(struct_processus *s_etat_processus)
1643: {
1644: struct_objet *s_objet_argument;
1645: struct_objet *s_objet_resultat_1;
1646: struct_objet *s_objet_resultat_2;
1647: struct_objet *s_objet_resultat_3;
1648:
1649: struct_vecteur s_vecteur;
1650:
1651: unsigned long i;
1652: unsigned long j;
1653:
1654: (*s_etat_processus).erreur_execution = d_ex;
1655:
1656: if ((*s_etat_processus).affichage_arguments == 'Y')
1657: {
1658: printf("\n SVD ");
1659:
1660: if ((*s_etat_processus).langue == 'F')
1661: {
1662: printf("(décomposition en valeurs singulières)\n\n");
1663: }
1664: else
1665: {
1666: printf("(singular value decomposition)\n\n");
1667: }
1668:
1669: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1670: printf("-> 3: %s, %s\n", d_MRL, d_MCX);
1671: printf(" 2: %s, %s\n", d_MRL, d_MCX);
1672: printf(" 1: %s\n", d_VRL);
1673: return;
1674: }
1675: else if ((*s_etat_processus).test_instruction == 'Y')
1676: {
1677: (*s_etat_processus).nombre_arguments = -1;
1678: return;
1679: }
1680:
1681: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1682: {
1683: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1684: {
1685: return;
1686: }
1687: }
1688:
1689: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1690: &s_objet_argument) == d_erreur)
1691: {
1692: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1693: return;
1694: }
1695:
1696: if (((*s_objet_argument).type == MIN) ||
1697: ((*s_objet_argument).type == MRL))
1698: {
1699: if ((s_objet_resultat_1 = allocation(s_etat_processus, MRL)) == NULL)
1700: {
1701: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1702: return;
1703: }
1704:
1705: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL)
1706: {
1707: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1708: return;
1709: }
1710:
1711: if ((s_objet_resultat_3 = allocation(s_etat_processus, MRL)) == NULL)
1712: {
1713: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1714: return;
1715: }
1716:
1717: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1718: (*s_objet_resultat_3).objet, &s_vecteur,
1719: (*s_objet_resultat_1).objet);
1720:
1721: if ((*s_etat_processus).erreur_systeme != d_es)
1722: {
1723: return;
1724: }
1725:
1726: if (((*s_etat_processus).erreur_execution != d_ex) ||
1727: ((*s_etat_processus).exception != d_ep))
1728: {
1729: liberation(s_etat_processus, s_objet_resultat_1);
1730: liberation(s_etat_processus, s_objet_resultat_2);
1731: liberation(s_etat_processus, s_objet_resultat_3);
1732: liberation(s_etat_processus, s_objet_argument);
1733: return;
1734: }
1735:
1736: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
1737: (*((struct_matrice *) (*s_objet_argument).objet))
1738: .nombre_colonnes;
1739: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
1740: (*((struct_matrice *) (*s_objet_argument).objet))
1741: .nombre_lignes;
1742:
1743: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
1744: malloc((*((struct_matrice *) (*s_objet_resultat_2).objet))
1745: .nombre_lignes * sizeof(real8 *))) == NULL)
1746: {
1747: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1748: return;
1749: }
1750:
1751: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1752: .nombre_lignes; i++)
1753: {
1754: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1755: .objet)).tableau)[i] = malloc((*((struct_matrice *)
1756: (*s_objet_resultat_2).objet)).nombre_colonnes *
1757: sizeof(real8 *))) == NULL)
1758: {
1759: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1760: return;
1761: }
1762:
1763: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1764: .nombre_colonnes; j++)
1765: {
1766: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1767: .objet)).tableau)[i][j] = 0;
1768: }
1769: }
1770:
1771: for(i = 0; i < s_vecteur.taille; i++)
1772: {
1773: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
1774: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i];
1775: }
1776:
1777: free(s_vecteur.tableau);
1778:
1779: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1780: s_objet_resultat_3) == d_erreur)
1781: {
1782: return;
1783: }
1784:
1785: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1786: s_objet_resultat_2) == d_erreur)
1787: {
1788: return;
1789: }
1790:
1791: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1792: s_objet_resultat_1) == d_erreur)
1793: {
1794: return;
1795: }
1796: }
1797: else if ((*s_objet_argument).type == MCX)
1798: {
1799: if ((s_objet_resultat_1 = allocation(s_etat_processus, MCX)) == NULL)
1800: {
1801: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1802: return;
1803: }
1804:
1805: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL)
1806: {
1807: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1808: return;
1809: }
1810:
1811: if ((s_objet_resultat_3 = allocation(s_etat_processus, MCX)) == NULL)
1812: {
1813: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1814: return;
1815: }
1816:
1817: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1818: (*s_objet_resultat_3).objet, &s_vecteur,
1819: (*s_objet_resultat_1).objet);
1820:
1821: if ((*s_etat_processus).erreur_systeme != d_es)
1822: {
1823: return;
1824: }
1825:
1826: if (((*s_etat_processus).erreur_execution != d_ex) ||
1827: ((*s_etat_processus).exception != d_ep))
1828: {
1829: liberation(s_etat_processus, s_objet_resultat_1);
1830: liberation(s_etat_processus, s_objet_resultat_2);
1831: liberation(s_etat_processus, s_objet_resultat_3);
1832: liberation(s_etat_processus, s_objet_argument);
1833: return;
1834: }
1835:
1836: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
1837: (*((struct_matrice *) (*s_objet_argument).objet))
1838: .nombre_colonnes;
1839: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
1840: (*((struct_matrice *) (*s_objet_argument).objet))
1841: .nombre_lignes;
1842:
1843: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
1844: malloc((*((struct_matrice *) (*s_objet_resultat_2).objet))
1845: .nombre_lignes * sizeof(real8 *))) == NULL)
1846: {
1847: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1848: return;
1849: }
1850:
1851: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1852: .nombre_lignes; i++)
1853: {
1854: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1855: .objet)).tableau)[i] = malloc((*((struct_matrice *)
1856: (*s_objet_resultat_2).objet)).nombre_colonnes *
1857: sizeof(real8 *))) == NULL)
1858: {
1859: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1860: return;
1861: }
1862:
1863: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1864: .nombre_colonnes; j++)
1865: {
1866: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1867: .objet)).tableau)[i][j] = 0;
1868: }
1869: }
1870:
1871: for(i = 0; i < s_vecteur.taille; i++)
1872: {
1873: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
1874: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i];
1875: }
1876:
1877: free(s_vecteur.tableau);
1878:
1879: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1880: s_objet_resultat_3) == d_erreur)
1881: {
1882: return;
1883: }
1884:
1885: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1886: s_objet_resultat_2) == d_erreur)
1887: {
1888: return;
1889: }
1890:
1891: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1892: s_objet_resultat_1) == d_erreur)
1893: {
1894: return;
1895: }
1896: }
1897: else
1898: {
1899: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1900:
1901: liberation(s_etat_processus, s_objet_argument);
1902: return;
1903: }
1904:
1905: liberation(s_etat_processus, s_objet_argument);
1906: return;
1907: }
1908:
1909:
1910: /*
1911: ================================================================================
1912: Fonction 'swapcntxt'
1913: ================================================================================
1914: Entrées :
1915: --------------------------------------------------------------------------------
1916: Sorties :
1917: --------------------------------------------------------------------------------
1918: Effets de bord : néant
1919: ================================================================================
1920: */
1921:
1922: void
1923: instruction_swapcntxt(struct_processus *s_etat_processus)
1924: {
1925: integer8 i;
1926: integer8 registre_taille;
1927:
1928: struct_liste_chainee *l_element_courant;
1929: struct_liste_chainee *l_element_courant_taille;
1930: struct_liste_chainee *registre;
1931:
1932: struct_objet *s_objet_argument;
1933:
1934: (*s_etat_processus).erreur_execution = d_ex;
1935:
1936: if ((*s_etat_processus).affichage_arguments == 'Y')
1937: {
1938: printf("\n SWAPCNTXT ");
1939:
1940: if ((*s_etat_processus).langue == 'F')
1941: {
1942: printf("(échange de contextes)\n\n");
1943: }
1944: else
1945: {
1946: printf("(swap contexts)\n\n");
1947: }
1948:
1949: printf(" 1: %s\n", d_INT);
1950: return;
1951: }
1952: else if ((*s_etat_processus).test_instruction == 'Y')
1953: {
1954: (*s_etat_processus).nombre_arguments = -1;
1955: return;
1956: }
1957:
1958: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1959: {
1960: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1961: {
1962: return;
1963: }
1964: }
1965:
1966: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1967: &s_objet_argument) == d_erreur)
1968: {
1969: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1970: return;
1971: }
1972:
1973: if ((*s_objet_argument).type == INT)
1974: {
1975: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
1976: l_element_courant_taille = (*s_etat_processus)
1977: .l_base_pile_taille_contextes;
1978:
1979: i = (*((integer8 *) (*s_objet_argument).objet));
1980:
1981: while((l_element_courant != NULL) && (l_element_courant_taille != NULL))
1982: {
1983: i--;
1984:
1985: if (i == 0)
1986: {
1987: break;
1988: }
1989:
1990: l_element_courant = (*l_element_courant).suivant;
1991: l_element_courant_taille = (*l_element_courant_taille).suivant;
1992: }
1993:
1994: if ((l_element_courant == NULL) || (l_element_courant_taille == NULL))
1995: {
1996: liberation(s_etat_processus, s_objet_argument);
1997:
1998: (*s_etat_processus).erreur_execution = d_ex_contexte;
1999: return;
2000: }
2001:
2002: if ((*(*l_element_courant).donnee).type != LST)
2003: {
2004: (*s_etat_processus).erreur_systeme = d_es_contexte;
2005: return;
2006: }
2007:
2008: if ((*(*l_element_courant_taille).donnee).type != INT)
2009: {
2010: (*s_etat_processus).erreur_systeme = d_es_contexte;
2011: return;
2012: }
2013:
2014: registre = (*s_etat_processus).l_base_pile;
2015: registre_taille = (*s_etat_processus).hauteur_pile_operationnelle;
2016:
2017: (*s_etat_processus).l_base_pile = (*(*l_element_courant).donnee).objet;
2018: (*s_etat_processus).hauteur_pile_operationnelle =
2019: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet));
2020:
2021: (*(*l_element_courant).donnee).objet = registre;
2022: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet)) =
2023: registre_taille;
2024: }
2025: else
2026: {
2027: liberation(s_etat_processus, s_objet_argument);
2028:
2029: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2030: return;
2031: }
2032:
2033: liberation(s_etat_processus, s_objet_argument);
2034: }
2035:
2036: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s10.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src