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;
}
