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