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