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