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