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