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