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