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