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