int Get_While (node* tree) { int err_index; ASSERT_NODE_OK (tree); if ((*CUR) -> op != OP_WHILE) return ERR_CALL_GET_WHILE; CUR++; if ((*CUR) -> op != SEP_OPEN_BRACKET) return ERR_WHILE_OPEN_BRACKET; CUR++; node* new_tree = Node_NEW(); int ret = Get_Cmp (new_tree); if (ret != HAPPY) if (ret == 0) return ret; if ((*CUR) -> op != SEP_CLOSE_BRACKET) return ERR_WHILE_CLOSE_BRACKET; CUR++; if ((*CUR) -> op == SEP_OPEN_BRACE) ret = Get_Block (new_tree); else { Tree_Add_Right (new_tree, Node_NEW()); ret = Get_Op (new_tree -> right); if (ret != HAPPY) if (ret == 0) return ret; new_tree -> right -> type = OP; } new_tree -> type = OP_WHILE; Tree_Add_Left (tree, new_tree); ASSERT_NODE_OK (tree); return HAPPY; }
int Get_Else (node* tree) { int err_index; int ret = 0; ASSERT_NODE_OK (tree); node* new_tree = Node_NEW(); ret = Tree_Add_Left (new_tree, Node_NEW()); if (ret != HAPPY) return ret; if ((*CUR) -> op == SEP_OPEN_BRACE) { ret = Get_Block (new_tree -> left); if (ret != HAPPY) if (ret == 0) return ret; Tree_Replace_Right (new_tree -> left); } else { ret = Get_Op (new_tree -> left); if (ret != HAPPY) if (ret == 0) return ret; } if ((*CUR) -> op == OP_ELSE) { CUR++; if ((*CUR) -> op == SEP_OPEN_BRACE) ret = Get_Block (new_tree); else { Tree_Add_Right (new_tree, Node_NEW()); ret = Get_Op (new_tree -> right); if (ret != HAPPY) if (ret == 0) return ret; new_tree -> right -> type = OP; } new_tree -> type = OP_ELSE; Tree_Add_Right (tree, new_tree); ASSERT_NODE_OK (tree); return HAPPY; } Tree_Add_Right (tree, new_tree); Tree_Replace_Left (new_tree); ASSERT_NODE_OK (tree); return HAPPY; }
/*! * \ingroup cache_interface * * Cette fonction permet de lire un enregistrement à travers le cache. * * La fonction \c Get_Block retourne le bloc du cache contenant l'enregistrement à * l'index-fichier \a irfile. Il n'y a plus qu'à faire la copie physique dans la zone * de l'utilisateur. On doit également notifier la stratégie de ce qu'on vient * de faire. * * La fonction \c Do_Sync_If_Needed effectue une synchronisation à * intervalle régulier. * * \param pcache un pointeur sur le cache à synchroniser * \param irfile index de l'enregistrement dans le fichier * \param precord adresse où ranger l'enregistrement dans l'espace utilisateur * \return le code d'erreur */ Cache_Error Cache_Read(struct Cache *pcache, int irfile, void *precord) { struct Cache_Block_Header *pbh; pcache->instrument.n_reads++; if ((pbh = Get_Block(pcache, irfile)) == NULL) return CACHE_KO; (void)memcpy(precord, ADDR(pcache, irfile, pbh), pcache->recordsz); Strategy_Read(pcache, pbh); return Do_Sync_If_Needed(pcache); }
/*! * \ingroup cache_interface * * Cette fonction permet d'écrire un enregistrement à travers le cache. * * La fonction Get_Block retourne le bloc du cache contenant l'enregistrement à * l'indice-fichier irfile. Il n'y a plus qu'à faire la copie physique depuis la * zone de l'utilisateur. Le bloc est marqué modifié (flag MODIF). * La fonction Do_Sync_If_Needed effectue une synchronisation à intervalle * régulier. * * \param pcache un pointeur sur le cache à synchroniser * \param irfile index de l'enregistrement dans le fichier * \param precord adresse où lire l'enregistrement dans l'espace utilisateur * \return le code d'erreur */ Cache_Error Cache_Write(struct Cache *pcache, int irfile, const void *precord) { struct Cache_Block_Header *pbh; pcache->instrument.n_writes++; if ((pbh = Get_Block(pcache, irfile)) == NULL) return CACHE_KO; (void)memcpy(ADDR(pcache, irfile, pbh), precord, pcache->recordsz); pbh->flags |= MODIF; Strategy_Write(pcache, pbh); return Do_Sync_If_Needed(pcache); }
int Get_Pgm (const token** code, node** tree) { int err_index; assert (tree); CUR = (const token**) code; node* new_tree = Node_NEW(); new_tree -> type = PGM; int ret = Get_Block (new_tree); if (ret != HAPPY) if (ret == 0) return ret; *tree = new_tree; ASSERT_TREE_OK (*tree); return HAPPY; }