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