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