1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.4
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: # ifndef SEMAPHORES_NOMMES
1109: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1110: # else
1111: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1112: # endif
1113: {
1114: (*s_etat_processus).erreur_systeme = d_es_processus;
1115: return;
1116: }
1117:
1118: while(sem_wait((*((struct_semaphore *) (*s_objet_argument).objet))
1119: .semaphore) == -1)
1120: {
1121: if (errno != EINTR)
1122: {
1123: # ifndef SEMAPHORES_NOMMES
1124: sem_post(&((*s_etat_processus).semaphore_fork));
1125: # else
1126: sem_post((*s_etat_processus).semaphore_fork);
1127: # endif
1128:
1129: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1130:
1131: if ((*s_etat_processus).profilage == d_vrai)
1132: {
1133: profilage(s_etat_processus, NULL);
1134: }
1135:
1136: liberation(s_etat_processus, s_objet_argument);
1137: return;
1138: }
1139: }
1140:
1141: # ifndef SEMAPHORES_NOMMES
1142: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1143: # else
1144: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1145: # endif
1146: {
1147: if (errno != EINTR)
1148: {
1149: if ((*s_etat_processus).profilage == d_vrai)
1150: {
1151: profilage(s_etat_processus, NULL);
1152: }
1153:
1154: (*s_etat_processus).erreur_systeme = d_es_processus;
1155: return;
1156: }
1157: }
1158:
1159: if ((*s_etat_processus).profilage == d_vrai)
1160: {
1161: profilage(s_etat_processus, NULL);
1162: }
1163:
1164: liberation(s_etat_processus, s_objet_argument);
1165: }
1166: else
1167: {
1168: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1169:
1170: liberation(s_etat_processus, s_objet_argument);
1171: return;
1172: }
1173:
1174: return;
1175: }
1176:
1177:
1178: /*
1179: ================================================================================
1180: Fonction 'smphrtrydecr'
1181: ================================================================================
1182: Entrées :
1183: --------------------------------------------------------------------------------
1184: Sorties :
1185: --------------------------------------------------------------------------------
1186: Effets de bord : néant
1187: ================================================================================
1188: */
1189:
1190: void
1191: instruction_smphrtrydecr(struct_processus *s_etat_processus)
1192: {
1193: struct_objet *s_objet_argument;
1194: struct_objet *s_objet_resultat;
1195:
1196: unsigned char *tampon;
1197:
1198: (*s_etat_processus).erreur_execution = d_ex;
1199:
1200: if ((*s_etat_processus).affichage_arguments == 'Y')
1201: {
1202: printf("\n SMPHRTRYDECR ");
1203:
1204: if ((*s_etat_processus).langue == 'F')
1205: {
1206: printf("(essai de decrémentation du sémaphore)\n\n");
1207: }
1208: else
1209: {
1210: printf("(try to decremente semaphore)\n\n");
1211: }
1212:
1213: printf(" 1: %s\n", d_SPH);
1214: printf("-> 1: %s\n", d_INT);
1215: return;
1216: }
1217: else if ((*s_etat_processus).test_instruction == 'Y')
1218: {
1219: (*s_etat_processus).nombre_arguments = -1;
1220: return;
1221: }
1222:
1223: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1224: {
1225: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1226: {
1227: return;
1228: }
1229: }
1230:
1231: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1232: &s_objet_argument) == d_erreur)
1233: {
1234: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1235: return;
1236: }
1237:
1238: if ((*s_objet_argument).type == SPH)
1239: {
1240: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1241: {
1242: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1243: return;
1244: }
1245:
1246: if ((*s_etat_processus).profilage == d_vrai)
1247: {
1248: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
1249: == NULL)
1250: {
1251: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1252: return;
1253: }
1254:
1255: profilage(s_etat_processus, tampon);
1256: free(tampon);
1257:
1258: if ((*s_etat_processus).erreur_systeme != d_es)
1259: {
1260: return;
1261: }
1262: }
1263:
1264: # ifndef SEMAPHORES_NOMMES
1265: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1266: # else
1267: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1268: # endif
1269: {
1270: if ((*s_etat_processus).profilage == d_vrai)
1271: {
1272: profilage(s_etat_processus, NULL);
1273: }
1274:
1275: (*s_etat_processus).erreur_systeme = d_es_processus;
1276: return;
1277: }
1278:
1279: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
1280:
1281: while(sem_trywait((*((struct_semaphore *) (*s_objet_argument).objet))
1282: .semaphore) == -1)
1283: {
1284: switch(errno)
1285: {
1286: case EINTR :
1287: {
1288: break;
1289: }
1290:
1291: case EINVAL :
1292: {
1293: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1294:
1295: if ((*s_etat_processus).profilage == d_vrai)
1296: {
1297: profilage(s_etat_processus, NULL);
1298: }
1299:
1300: liberation(s_etat_processus, s_objet_argument);
1301: return;
1302: }
1303:
1304: case EAGAIN :
1305: {
1306: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
1307: break;
1308: }
1309: }
1310:
1311: if ((*((integer8 *) (*s_objet_resultat).objet)) != 0)
1312: {
1313: break;
1314: }
1315: }
1316:
1317: # ifndef SEMAPHORES_NOMMES
1318: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1319: # else
1320: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1321: # endif
1322: {
1323: if (errno != EINTR)
1324: {
1325: if ((*s_etat_processus).profilage == d_vrai)
1326: {
1327: profilage(s_etat_processus, NULL);
1328: }
1329:
1330: (*s_etat_processus).erreur_systeme = d_es_processus;
1331: return;
1332: }
1333: }
1334:
1335: if ((*s_etat_processus).profilage == d_vrai)
1336: {
1337: profilage(s_etat_processus, NULL);
1338: }
1339:
1340: liberation(s_etat_processus, s_objet_argument);
1341: }
1342: else
1343: {
1344: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1345:
1346: liberation(s_etat_processus, s_objet_argument);
1347: return;
1348: }
1349:
1350: return;
1351: }
1352:
1353:
1354: /*
1355: ================================================================================
1356: Fonction 'smphrgetv'
1357: ================================================================================
1358: Entrées :
1359: --------------------------------------------------------------------------------
1360: Sorties :
1361: --------------------------------------------------------------------------------
1362: Effets de bord : néant
1363: ================================================================================
1364: */
1365:
1366: void
1367: instruction_smphrgetv(struct_processus *s_etat_processus)
1368: {
1369: int valeur;
1370:
1371: struct_objet *s_objet_argument;
1372: struct_objet *s_objet_resultat;
1373:
1374: (*s_etat_processus).erreur_execution = d_ex;
1375:
1376: if ((*s_etat_processus).affichage_arguments == 'Y')
1377: {
1378: printf("\n SMPHRGETV ");
1379:
1380: if ((*s_etat_processus).langue == 'F')
1381: {
1382: printf("(valeur du sémaphore)\n\n");
1383: }
1384: else
1385: {
1386: printf("(semaphore value)\n\n");
1387: }
1388:
1389: printf(" 1: %s\n", d_SPH);
1390: return;
1391: }
1392: else if ((*s_etat_processus).test_instruction == 'Y')
1393: {
1394: (*s_etat_processus).nombre_arguments = -1;
1395: return;
1396: }
1397:
1398: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1399: {
1400: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1401: {
1402: return;
1403: }
1404: }
1405:
1406: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1407: &s_objet_argument) == d_erreur)
1408: {
1409: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1410: return;
1411: }
1412:
1413: if ((*s_objet_argument).type == SPH)
1414: {
1415: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1416: {
1417: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1418:
1419: liberation(s_etat_processus, s_objet_argument);
1420: return;
1421: }
1422:
1423: if (sem_getvalue((*((struct_semaphore *) (*s_objet_argument).objet))
1424: .semaphore, &valeur) != 0)
1425: {
1426: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1427:
1428: liberation(s_etat_processus, s_objet_argument);
1429: return;
1430: }
1431:
1432: (*((integer8 *) (*s_objet_resultat).objet)) = valeur;
1433:
1434: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1435: s_objet_resultat) == d_erreur)
1436: {
1437: return;
1438: }
1439:
1440: liberation(s_etat_processus, s_objet_argument);
1441: }
1442: else
1443: {
1444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1445:
1446: liberation(s_etat_processus, s_objet_argument);
1447: return;
1448: }
1449:
1450: return;
1451: }
1452:
1453:
1454: /*
1455: ================================================================================
1456: Fonction 'svl'
1457: ================================================================================
1458: Entrées :
1459: --------------------------------------------------------------------------------
1460: Sorties :
1461: --------------------------------------------------------------------------------
1462: Effets de bord : néant
1463: ================================================================================
1464: */
1465:
1466: void
1467: instruction_svl(struct_processus *s_etat_processus)
1468: {
1469: struct_objet *s_objet_argument;
1470: struct_objet *s_objet_resultat;
1471:
1472: (*s_etat_processus).erreur_execution = d_ex;
1473:
1474: if ((*s_etat_processus).affichage_arguments == 'Y')
1475: {
1476: printf("\n SVL ");
1477:
1478: if ((*s_etat_processus).langue == 'F')
1479: {
1480: printf("(valeurs singulières)\n\n");
1481: }
1482: else
1483: {
1484: printf("(singular values)\n\n");
1485: }
1486:
1487: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1488: printf("-> 1: %s\n", d_VRL);
1489: return;
1490: }
1491: else if ((*s_etat_processus).test_instruction == 'Y')
1492: {
1493: (*s_etat_processus).nombre_arguments = -1;
1494: return;
1495: }
1496:
1497: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1498: {
1499: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1500: {
1501: return;
1502: }
1503: }
1504:
1505: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1506: &s_objet_argument) == d_erreur)
1507: {
1508: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1509: return;
1510: }
1511:
1512: if (((*s_objet_argument).type == MIN) ||
1513: ((*s_objet_argument).type == MRL) ||
1514: ((*s_objet_argument).type == MCX))
1515: {
1516: if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
1517: {
1518: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1519: return;
1520: }
1521:
1522: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1523: NULL, (*s_objet_resultat).objet, NULL);
1524:
1525: if ((*s_etat_processus).erreur_systeme != d_es)
1526: {
1527: return;
1528: }
1529:
1530: if (((*s_etat_processus).erreur_execution != d_ex) ||
1531: ((*s_etat_processus).exception != d_ep))
1532: {
1533: liberation(s_etat_processus, s_objet_resultat);
1534: liberation(s_etat_processus, s_objet_argument);
1535: return;
1536: }
1537:
1538: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1539: s_objet_resultat) == d_erreur)
1540: {
1541: return;
1542: }
1543: }
1544: else
1545: {
1546: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1547:
1548: liberation(s_etat_processus, s_objet_argument);
1549: return;
1550: }
1551:
1552: liberation(s_etat_processus, s_objet_argument);
1553:
1554: return;
1555: }
1556:
1557:
1558: /*
1559: ================================================================================
1560: Fonction 'svd'
1561: ================================================================================
1562: Entrées :
1563: --------------------------------------------------------------------------------
1564: Sorties :
1565: --------------------------------------------------------------------------------
1566: Effets de bord : néant
1567: ================================================================================
1568: */
1569:
1570: void
1571: instruction_svd(struct_processus *s_etat_processus)
1572: {
1573: struct_objet *s_objet_argument;
1574: struct_objet *s_objet_resultat_1;
1575: struct_objet *s_objet_resultat_2;
1576: struct_objet *s_objet_resultat_3;
1577:
1578: struct_vecteur s_vecteur;
1579:
1580: unsigned long i;
1581: unsigned long j;
1582:
1583: (*s_etat_processus).erreur_execution = d_ex;
1584:
1585: if ((*s_etat_processus).affichage_arguments == 'Y')
1586: {
1587: printf("\n SVD ");
1588:
1589: if ((*s_etat_processus).langue == 'F')
1590: {
1591: printf("(décomposition en valeurs singulières)\n\n");
1592: }
1593: else
1594: {
1595: printf("(singular value decomposition)\n\n");
1596: }
1597:
1598: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1599: printf("-> 3: %s, %s\n", d_MRL, d_MCX);
1600: printf(" 2: %s, %s\n", d_MRL, d_MCX);
1601: printf(" 1: %s\n", d_VRL);
1602: return;
1603: }
1604: else if ((*s_etat_processus).test_instruction == 'Y')
1605: {
1606: (*s_etat_processus).nombre_arguments = -1;
1607: return;
1608: }
1609:
1610: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1611: {
1612: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1613: {
1614: return;
1615: }
1616: }
1617:
1618: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1619: &s_objet_argument) == d_erreur)
1620: {
1621: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1622: return;
1623: }
1624:
1625: if (((*s_objet_argument).type == MIN) ||
1626: ((*s_objet_argument).type == MRL))
1627: {
1628: if ((s_objet_resultat_1 = allocation(s_etat_processus, MRL)) == NULL)
1629: {
1630: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1631: return;
1632: }
1633:
1634: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL)
1635: {
1636: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1637: return;
1638: }
1639:
1640: if ((s_objet_resultat_3 = allocation(s_etat_processus, MRL)) == NULL)
1641: {
1642: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1643: return;
1644: }
1645:
1646: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1647: (*s_objet_resultat_3).objet, &s_vecteur,
1648: (*s_objet_resultat_1).objet);
1649:
1650: if ((*s_etat_processus).erreur_systeme != d_es)
1651: {
1652: return;
1653: }
1654:
1655: if (((*s_etat_processus).erreur_execution != d_ex) ||
1656: ((*s_etat_processus).exception != d_ep))
1657: {
1658: liberation(s_etat_processus, s_objet_resultat_1);
1659: liberation(s_etat_processus, s_objet_resultat_2);
1660: liberation(s_etat_processus, s_objet_resultat_3);
1661: liberation(s_etat_processus, s_objet_argument);
1662: return;
1663: }
1664:
1665: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
1666: (*((struct_matrice *) (*s_objet_argument).objet))
1667: .nombre_colonnes;
1668: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
1669: (*((struct_matrice *) (*s_objet_argument).objet))
1670: .nombre_lignes;
1671:
1672: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
1673: malloc((*((struct_matrice *) (*s_objet_resultat_2).objet))
1674: .nombre_lignes * sizeof(real8 *))) == NULL)
1675: {
1676: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1677: return;
1678: }
1679:
1680: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1681: .nombre_lignes; i++)
1682: {
1683: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1684: .objet)).tableau)[i] = malloc((*((struct_matrice *)
1685: (*s_objet_resultat_2).objet)).nombre_colonnes *
1686: sizeof(real8 *))) == NULL)
1687: {
1688: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1689: return;
1690: }
1691:
1692: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1693: .nombre_colonnes; j++)
1694: {
1695: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1696: .objet)).tableau)[i][j] = 0;
1697: }
1698: }
1699:
1700: for(i = 0; i < s_vecteur.taille; i++)
1701: {
1702: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
1703: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i];
1704: }
1705:
1706: free(s_vecteur.tableau);
1707:
1708: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1709: s_objet_resultat_3) == d_erreur)
1710: {
1711: return;
1712: }
1713:
1714: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1715: s_objet_resultat_2) == d_erreur)
1716: {
1717: return;
1718: }
1719:
1720: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1721: s_objet_resultat_1) == d_erreur)
1722: {
1723: return;
1724: }
1725: }
1726: else if ((*s_objet_argument).type == MCX)
1727: {
1728: if ((s_objet_resultat_1 = allocation(s_etat_processus, MCX)) == NULL)
1729: {
1730: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1731: return;
1732: }
1733:
1734: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL)
1735: {
1736: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1737: return;
1738: }
1739:
1740: if ((s_objet_resultat_3 = allocation(s_etat_processus, MCX)) == NULL)
1741: {
1742: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1743: return;
1744: }
1745:
1746: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1747: (*s_objet_resultat_3).objet, &s_vecteur,
1748: (*s_objet_resultat_1).objet);
1749:
1750: if ((*s_etat_processus).erreur_systeme != d_es)
1751: {
1752: return;
1753: }
1754:
1755: if (((*s_etat_processus).erreur_execution != d_ex) ||
1756: ((*s_etat_processus).exception != d_ep))
1757: {
1758: liberation(s_etat_processus, s_objet_resultat_1);
1759: liberation(s_etat_processus, s_objet_resultat_2);
1760: liberation(s_etat_processus, s_objet_resultat_3);
1761: liberation(s_etat_processus, s_objet_argument);
1762: return;
1763: }
1764:
1765: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
1766: (*((struct_matrice *) (*s_objet_argument).objet))
1767: .nombre_colonnes;
1768: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
1769: (*((struct_matrice *) (*s_objet_argument).objet))
1770: .nombre_lignes;
1771:
1772: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
1773: malloc((*((struct_matrice *) (*s_objet_resultat_2).objet))
1774: .nombre_lignes * sizeof(real8 *))) == NULL)
1775: {
1776: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1777: return;
1778: }
1779:
1780: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1781: .nombre_lignes; i++)
1782: {
1783: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1784: .objet)).tableau)[i] = malloc((*((struct_matrice *)
1785: (*s_objet_resultat_2).objet)).nombre_colonnes *
1786: sizeof(real8 *))) == NULL)
1787: {
1788: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1789: return;
1790: }
1791:
1792: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1793: .nombre_colonnes; j++)
1794: {
1795: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1796: .objet)).tableau)[i][j] = 0;
1797: }
1798: }
1799:
1800: for(i = 0; i < s_vecteur.taille; i++)
1801: {
1802: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
1803: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i];
1804: }
1805:
1806: free(s_vecteur.tableau);
1807:
1808: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1809: s_objet_resultat_3) == d_erreur)
1810: {
1811: return;
1812: }
1813:
1814: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1815: s_objet_resultat_2) == d_erreur)
1816: {
1817: return;
1818: }
1819:
1820: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1821: s_objet_resultat_1) == d_erreur)
1822: {
1823: return;
1824: }
1825: }
1826: else
1827: {
1828: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1829:
1830: liberation(s_etat_processus, s_objet_argument);
1831: return;
1832: }
1833:
1834: liberation(s_etat_processus, s_objet_argument);
1835: return;
1836: }
1837:
1838:
1839: /*
1840: ================================================================================
1841: Fonction 'swapcntxt'
1842: ================================================================================
1843: Entrées :
1844: --------------------------------------------------------------------------------
1845: Sorties :
1846: --------------------------------------------------------------------------------
1847: Effets de bord : néant
1848: ================================================================================
1849: */
1850:
1851: void
1852: instruction_swapcntxt(struct_processus *s_etat_processus)
1853: {
1854: integer8 i;
1855: integer8 registre_taille;
1856:
1857: struct_liste_chainee *l_element_courant;
1858: struct_liste_chainee *l_element_courant_taille;
1859: struct_liste_chainee *registre;
1860:
1861: struct_objet *s_objet_argument;
1862:
1863: (*s_etat_processus).erreur_execution = d_ex;
1864:
1865: if ((*s_etat_processus).affichage_arguments == 'Y')
1866: {
1867: printf("\n SWAPCNTXT ");
1868:
1869: if ((*s_etat_processus).langue == 'F')
1870: {
1871: printf("(échange de contextes)\n\n");
1872: }
1873: else
1874: {
1875: printf("(swap contexts)\n\n");
1876: }
1877:
1878: printf(" 1: %s\n", d_INT);
1879: return;
1880: }
1881: else if ((*s_etat_processus).test_instruction == 'Y')
1882: {
1883: (*s_etat_processus).nombre_arguments = -1;
1884: return;
1885: }
1886:
1887: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1888: {
1889: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1890: {
1891: return;
1892: }
1893: }
1894:
1895: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1896: &s_objet_argument) == d_erreur)
1897: {
1898: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1899: return;
1900: }
1901:
1902: if ((*s_objet_argument).type == INT)
1903: {
1904: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
1905: l_element_courant_taille = (*s_etat_processus)
1906: .l_base_pile_taille_contextes;
1907:
1908: i = (*((integer8 *) (*s_objet_argument).objet));
1909:
1910: while((l_element_courant != NULL) && (l_element_courant_taille != NULL))
1911: {
1912: i--;
1913:
1914: if (i == 0)
1915: {
1916: break;
1917: }
1918:
1919: l_element_courant = (*l_element_courant).suivant;
1920: l_element_courant_taille = (*l_element_courant_taille).suivant;
1921: }
1922:
1923: if ((l_element_courant == NULL) || (l_element_courant_taille == NULL))
1924: {
1925: liberation(s_etat_processus, s_objet_argument);
1926:
1927: (*s_etat_processus).erreur_execution = d_ex_contexte;
1928: return;
1929: }
1930:
1931: if ((*(*l_element_courant).donnee).type != LST)
1932: {
1933: (*s_etat_processus).erreur_systeme = d_es_contexte;
1934: return;
1935: }
1936:
1937: if ((*(*l_element_courant_taille).donnee).type != INT)
1938: {
1939: (*s_etat_processus).erreur_systeme = d_es_contexte;
1940: return;
1941: }
1942:
1943: registre = (*s_etat_processus).l_base_pile;
1944: registre_taille = (*s_etat_processus).hauteur_pile_operationnelle;
1945:
1946: (*s_etat_processus).l_base_pile = (*(*l_element_courant).donnee).objet;
1947: (*s_etat_processus).hauteur_pile_operationnelle =
1948: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet));
1949:
1950: (*(*l_element_courant).donnee).objet = registre;
1951: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet)) =
1952: registre_taille;
1953: }
1954: else
1955: {
1956: liberation(s_etat_processus, s_objet_argument);
1957:
1958: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1959: return;
1960: }
1961:
1962: liberation(s_etat_processus, s_objet_argument);
1963: }
1964:
1965: // 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