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