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