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