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