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