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