version 1.75, 2012/10/01 11:04:57
|
version 1.117, 2021/03/13 12:50:37
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.11 |
RPL/2 (R) version 4.1.33 |
Copyright (C) 1989-2012 Dr. BERTRAND Joël |
Copyright (C) 1989-2021 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 61 creation_instruction(struct_processus *s
|
Line 61 creation_instruction(struct_processus *s
|
(*(*s_etat_processus).arbre_instructions).feuille = NULL; |
(*(*s_etat_processus).arbre_instructions).feuille = NULL; |
|
|
if (((*(*s_etat_processus).arbre_instructions).noeuds = |
if (((*(*s_etat_processus).arbre_instructions).noeuds = |
malloc((*s_etat_processus).nombre_caracteres |
malloc(((size_t) (*s_etat_processus).nombre_caracteres) |
* sizeof(struct_instruction))) == NULL) |
* sizeof(struct_instruction))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 101 creation_instruction(struct_processus *s
|
Line 101 creation_instruction(struct_processus *s
|
|
|
if (((*(*l_instruction_courante).noeuds[(*s_etat_processus) |
if (((*(*l_instruction_courante).noeuds[(*s_etat_processus) |
.pointeurs_caracteres[*ptr]]).noeuds = |
.pointeurs_caracteres[*ptr]]).noeuds = |
malloc((*s_etat_processus).nombre_caracteres |
malloc(((size_t) (*s_etat_processus).nombre_caracteres) |
* sizeof(struct_instruction))) == NULL) |
* sizeof(struct_instruction))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 180 initialisation_instructions(struct_proce
|
Line 180 initialisation_instructions(struct_proce
|
} |
} |
|
|
if (((*s_etat_processus).pointeurs_caracteres = |
if (((*s_etat_processus).pointeurs_caracteres = |
malloc(longueur_tableau * sizeof(int))) == NULL) |
malloc(((size_t) longueur_tableau * sizeof(int)))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return; |
Line 323 initialisation_instructions(struct_proce
|
Line 323 initialisation_instructions(struct_proce
|
INSTRUCTION("EGV", instruction_egv); |
INSTRUCTION("EGV", instruction_egv); |
INSTRUCTION("END", instruction_end); |
INSTRUCTION("END", instruction_end); |
INSTRUCTION("ENG", instruction_eng); |
INSTRUCTION("ENG", instruction_eng); |
|
INSTRUCTION("EQV", instruction_eqv); |
INSTRUCTION("EXP", instruction_exp); |
INSTRUCTION("EXP", instruction_exp); |
INSTRUCTION("FC?", instruction_fc_test); |
INSTRUCTION("FC?", instruction_fc_test); |
INSTRUCTION("FFT", instruction_fft); |
INSTRUCTION("FFT", instruction_fft); |
Line 513 initialisation_instructions(struct_proce
|
Line 514 initialisation_instructions(struct_proce
|
INSTRUCTION("RECV", instruction_recv); |
INSTRUCTION("RECV", instruction_recv); |
INSTRUCTION("REGV", instruction_regv); |
INSTRUCTION("REGV", instruction_regv); |
INSTRUCTION("REPL", instruction_repl); |
INSTRUCTION("REPL", instruction_repl); |
|
INSTRUCTION("RGDL", instruction_rgdl); |
|
INSTRUCTION("RGDR", instruction_rgdr); |
INSTRUCTION("RNRM", instruction_rnrm); |
INSTRUCTION("RNRM", instruction_rnrm); |
INSTRUCTION("ROLL", instruction_roll); |
INSTRUCTION("ROLL", instruction_roll); |
//INSTRUCTION("ROOT") |
//INSTRUCTION("ROOT") |
Line 722 initialisation_instructions(struct_proce
|
Line 725 initialisation_instructions(struct_proce
|
INSTRUCTION("ATEXIT", instruction_atexit); |
INSTRUCTION("ATEXIT", instruction_atexit); |
INSTRUCTION("ATPOKE", instruction_atpoke); |
INSTRUCTION("ATPOKE", instruction_atpoke); |
INSTRUCTION("BESSEL", instruction_bessel); |
INSTRUCTION("BESSEL", instruction_bessel); |
|
INSTRUCTION("CIPHER", instruction_cipher); |
INSTRUCTION("CLRERR", instruction_clrerr); |
INSTRUCTION("CLRERR", instruction_clrerr); |
INSTRUCTION("CLRMTX", instruction_clrmtx); |
INSTRUCTION("CLRMTX", instruction_clrmtx); |
INSTRUCTION("CLRSWI", instruction_clrswi); |
INSTRUCTION("CLRSWI", instruction_clrswi); |
Line 746 initialisation_instructions(struct_proce
|
Line 750 initialisation_instructions(struct_proce
|
INSTRUCTION("DETACH", instruction_spawn); |
INSTRUCTION("DETACH", instruction_spawn); |
# endif |
# endif |
INSTRUCTION("DIAG->", instruction_diag_fleche); |
INSTRUCTION("DIAG->", instruction_diag_fleche); |
|
INSTRUCTION("DIGEST", instruction_digest); |
//INSTRUCTION("DOLIST") |
//INSTRUCTION("DOLIST") |
//Instruction HP48 (application d'une fonction à une liste) |
//Instruction HP48 (application d'une fonction à une liste) |
//liste(s) nombre_de_listes_a_traiter fonction DOLIST |
//liste(s) nombre_de_listes_a_traiter fonction DOLIST |
Line 770 initialisation_instructions(struct_proce
|
Line 775 initialisation_instructions(struct_proce
|
INSTRUCTION("RCLSWI", instruction_rclswi); |
INSTRUCTION("RCLSWI", instruction_rclswi); |
INSTRUCTION("RECALL", instruction_recall); |
INSTRUCTION("RECALL", instruction_recall); |
INSTRUCTION("RECODE", instruction_recode); |
INSTRUCTION("RECODE", instruction_recode); |
|
INSTRUCTION("RECORD", instruction_record); |
INSTRUCTION("REDRAW", instruction_redraw); |
INSTRUCTION("REDRAW", instruction_redraw); |
INSTRUCTION("REMOVE", instruction_remove); |
INSTRUCTION("REMOVE", instruction_remove); |
INSTRUCTION("REPEAT", instruction_repeat); |
INSTRUCTION("REPEAT", instruction_repeat); |
Line 820 initialisation_instructions(struct_proce
|
Line 826 initialisation_instructions(struct_proce
|
INSTRUCTION("INQUIRE", instruction_inquire); |
INSTRUCTION("INQUIRE", instruction_inquire); |
INSTRUCTION("MEMLOCK", instruction_memlock); |
INSTRUCTION("MEMLOCK", instruction_memlock); |
INSTRUCTION("MTXLOCK", instruction_mtxlock); |
INSTRUCTION("MTXLOCK", instruction_mtxlock); |
|
INSTRUCTION("NBRCPUS", instruction_nbrcpus); |
INSTRUCTION("PERSIST", instruction_persist); |
INSTRUCTION("PERSIST", instruction_persist); |
INSTRUCTION("PLOTTER", instruction_plotter); |
INSTRUCTION("PLOTTER", instruction_plotter); |
INSTRUCTION("PRIVATE", instruction_private); |
INSTRUCTION("PRIVATE", instruction_private); |
Line 840 initialisation_instructions(struct_proce
|
Line 847 initialisation_instructions(struct_proce
|
|
|
INSTRUCTION("CLRCNTXT", instruction_clrcntxt); |
INSTRUCTION("CLRCNTXT", instruction_clrcntxt); |
INSTRUCTION("CLRSMPHR", instruction_clrsmphr); |
INSTRUCTION("CLRSMPHR", instruction_clrsmphr); |
|
INSTRUCTION("COMPRESS", instruction_compress); |
INSTRUCTION("CONTINUE", instruction_continue); |
INSTRUCTION("CONTINUE", instruction_continue); |
INSTRUCTION("CRITICAL", instruction_critical); |
INSTRUCTION("CRITICAL", instruction_critical); |
INSTRUCTION("DUPCNTXT", instruction_dupcntxt); |
INSTRUCTION("DUPCNTXT", instruction_dupcntxt); |
Line 899 initialisation_instructions(struct_proce
|
Line 907 initialisation_instructions(struct_proce
|
//pentes |
//pentes |
//représentent la valeur de la fonction (x,y) en leur milieu. |
//représentent la valeur de la fonction (x,y) en leur milieu. |
//=> utile pour y'=F(x,y) |
//=> utile pour y'=F(x,y) |
|
INSTRUCTION("UNCOMPRESS", instruction_uncompress); |
|
|
INSTRUCTION("LOCALIZATION", instruction_localization); |
INSTRUCTION("LOCALIZATION", instruction_localization); |
INSTRUCTION("SMPHRTRYDECR", instruction_smphrtrydecr); |
INSTRUCTION("SMPHRTRYDECR", instruction_smphrtrydecr); |
Line 960 analyse_instruction(struct_processus *s_
|
Line 969 analyse_instruction(struct_processus *s_
|
void |
void |
analyse(struct_processus *s_etat_processus, void (*fonction)()) |
analyse(struct_processus *s_etat_processus, void (*fonction)()) |
{ |
{ |
static logical1 initialisation = d_faux; |
|
|
|
real8 attente; |
real8 attente; |
real8 pourcentage; |
real8 pourcentage; |
real8 temps_cpu; |
real8 temps_cpu; |
Line 1101 analyse(struct_processus *s_etat_process
|
Line 1108 analyse(struct_processus *s_etat_process
|
if ((position = index((*s_etat_processus).instruction_courante, '$')) |
if ((position = index((*s_etat_processus).instruction_courante, '$')) |
!= NULL) |
!= NULL) |
{ |
{ |
if ((bibliotheque_candidate = malloc((position + 1 |
if ((bibliotheque_candidate = malloc(((size_t) (position + 1 |
- (*s_etat_processus).instruction_courante) |
- (*s_etat_processus).instruction_courante)) |
* sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
Line 1111 analyse(struct_processus *s_etat_process
|
Line 1118 analyse(struct_processus *s_etat_process
|
|
|
(*bibliotheque_candidate) = d_code_fin_chaine; |
(*bibliotheque_candidate) = d_code_fin_chaine; |
strncat(bibliotheque_candidate, |
strncat(bibliotheque_candidate, |
(*s_etat_processus).instruction_courante, |
(*s_etat_processus).instruction_courante, ((size_t) |
position - (*s_etat_processus).instruction_courante); |
(position - (*s_etat_processus).instruction_courante))); |
|
|
position++; |
position++; |
|
|
Line 1157 analyse(struct_processus *s_etat_process
|
Line 1164 analyse(struct_processus *s_etat_process
|
{ |
{ |
if ((*s_etat_processus).test_instruction == 'N') |
if ((*s_etat_processus).test_instruction == 'N') |
{ |
{ |
if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) |
if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) |
|
!= 0) |
{ |
{ |
affectation_interruptions_logicielles(s_etat_processus); |
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
} |
|
else |
|
{ |
|
if ((*s_etat_processus).nombre_interruptions_non_affectees != 0) |
|
{ |
|
affectation_interruptions_logicielles(s_etat_processus); |
|
} |
|
|
|
if (pthread_mutex_unlock(&(*s_etat_processus) |
|
.mutex_interruptions) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
} |
} |
} |
|
|
if (((*s_etat_processus).nombre_interruptions_en_queue != 0) && |
if (((*s_etat_processus).nombre_interruptions_en_queue != 0) && |
Line 1192 analyse(struct_processus *s_etat_process
|
Line 1213 analyse(struct_processus *s_etat_process
|
|
|
gettimeofday(&horodatage_final, NULL); |
gettimeofday(&horodatage_final, NULL); |
|
|
if (initialisation == d_vrai) |
if ((*s_etat_processus).initialisation_scheduler == d_vrai) |
{ |
{ |
temps_reel = ((real8) (horodatage_final.tv_sec - |
temps_reel = ((real8) (horodatage_final.tv_sec - |
horodatage_initial.tv_sec)) + |
horodatage_initial.tv_sec)) + |
Line 1230 analyse(struct_processus *s_etat_process
|
Line 1251 analyse(struct_processus *s_etat_process
|
(*s_etat_processus).pourcentage_maximal_cpu) |
(*s_etat_processus).pourcentage_maximal_cpu) |
- (pourcentage * temps_cpu / 100); |
- (pourcentage * temps_cpu / 100); |
|
|
temporisation.tv_sec = floor(attente); |
temporisation.tv_sec = (time_t) floor(attente); |
temporisation.tv_nsec = (attente - temporisation.tv_sec) * |
temporisation.tv_nsec = (suseconds_t) ((attente |
1E9; |
- ((real8) temporisation.tv_sec)) * 1E9); |
|
|
while(nanosleep(&temporisation, &temporisation) == -1) |
while(nanosleep(&temporisation, &temporisation) == -1) |
{ |
{ |
Line 1249 analyse(struct_processus *s_etat_process
|
Line 1270 analyse(struct_processus *s_etat_process
|
} |
} |
else |
else |
{ |
{ |
initialisation = d_vrai; |
(*s_etat_processus).initialisation_scheduler = d_vrai; |
|
|
horodatage_initial = horodatage_final; |
horodatage_initial = horodatage_final; |
usage_initial = usage_final; |
usage_initial = usage_final; |
Line 1257 analyse(struct_processus *s_etat_process
|
Line 1278 analyse(struct_processus *s_etat_process
|
} |
} |
else |
else |
{ |
{ |
initialisation = d_faux; |
(*s_etat_processus).initialisation_scheduler = d_faux; |
} |
} |
|
|
/* |
/* |