main.c

Aller à la documentation de ce fichier.

/*

An example of license ...

This source file is part of Scol
For the latest info, see http://www.scolring.org

Copyright (c) 2010 Iri <iri@irizone.net>

This source is under the terms of the Scol License. See the COPYING included file
for more informations.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.

For others informations, please contact us from http://www.scolring.org/

*/

#include "main.h"


/*
    Définition de deux variables globales établissant la liaison avec les structures partagées du noyau
    la structure cbmachine n'est toutefois définie que dans la version MS Windows
*/
#if defined _WIN32 || defined __WIN32__
cbmachine ww;
#endif
mmachine  mm;

int sc_increment (mmachine m)
{
    int mnumber;

    MMechostr (MSKDEBUG, "sc_increment : entering\n");

    mnumber = MTOI (MMget (m, 0));
    mnumber++;
    MMset (m, 0, ITOM (mnumber));
    return 0;
}



int sc_hello (mmachine m)
{
    int menter;             
    char * enter = NULL;    
    char * result = NULL;   
    MMechostr (MSKDEBUG, "sc_hello : entering\n");

    menter = MTOP (MMpull (m));    
    enter = MMstartstr (m, menter); 
    result = (char *) malloc (sizeof (char) * (strlen (enter) +7)); /* allocation dynamique selon la taille de la chaine */
    sprintf (result, "%s %s", "Hello", enter);

    Mpushstrbloc (m, result);   
    free (result);  /* on libère ce qu'on a alloué précédemment */
    return 0;
}


int sc_division (mmachine m)
{
    int mtuple, mdividende, mdiviseur;
    int quotient, reste;

    MMechostr (MSKDEBUG, "sc_division : entering\n");

    mtuple = MTOI (MMpull (m));                     /* 1 */
    mdividende = MTOI (MMfetch (m, mtuple, 0));     /* 2 */
    mdiviseur = MTOI (MMfetch (m, mtuple, 1));      /* 2 */

    if (mdiviseur == 0)     /* on teste le cas de la division par zéro */
        return MMpush (m, NIL);

    quotient = mdividende / mdiviseur;
    reste = mdividende % mdiviseur;

    MMpush (m, ITOM (quotient));                    /* 3 */
    MMpush (m, ITOM (reste));                       /* 3 */
    MMpush (m, ITOM (2));                           /* 4 */
    return MBdeftab (m);                            /* 5 */
}

int sc_calcul_list (mmachine m)
{
    int mlist_enter, mnumber, mflag;
    int element_list, i, compteur = 0;

    MMechostr (MSKDEBUG, "sc_calcul_list : entering\n");

    mflag = MTOI (MMpull (m));
    mnumber = MTOI (MMpull (m));
    mlist_enter = MMpull (m)>>1;

    while (mlist_enter != NIL)
    {
         element_list = MTOI (MMfetch (m, mlist_enter, 0));
         if (element_list != NIL)
         {
             MMpush (m, ITOM (element_list + (mnumber * mflag)));
             compteur++;
         }
         mlist_enter = MTOI (MMfetch(m, mlist_enter, 1));
    }

    MMpush (m, NIL);

    for (i = 0; i < compteur; i++)
    {
        MMpush (m, ITOM (2));
        MBdeftab (m);
    }
    return 0;
}







char* example_name[EXAMPLE_PKG_NB] =
{
    /* nouvelles fonctions Scol */
    "example_increment",    /* fonction de l'API appelable depuis l'extérieur */
    "example_hello",
    "example_calcul",
    "example_list",

    /* nouveaux flags Scol */
    "EXAMPLE_MOINS",
    "EXAMPLE_PLUS"
};

int (*example_fun[EXAMPLE_PKG_NB]) (mmachine m) =
{
    sc_increment,   /* nom interne où le code de cette fonction est développé */
    sc_hello,
    sc_division,
    sc_calcul_list,

    (void*) ((-1)*2),
    (void*) (1*2)
};

int example_narg[EXAMPLE_PKG_NB] =
{
    1,      /* nombre d'argument attendu par cette fonction */
    1,
    1,
    3,

    TYPVAR,
    TYPVAR
};

char* example_type[EXAMPLE_PKG_NB] =
{
    "fun [I] I",    /* prototype Scol de cette fonction : on notera que le nombre d'argument est bien 1 */
    "fun [S] S",
    "fun [[I I]] [I I]",
    "fun [[I r1] I I] [I r1]",

    "I",
    "I"
};


int SCOLinitEXAMPLEclass (mmachine m)
{
    int k = 0;

    MMechostr (MSKDEBUG, "SCOLinitEXAMPLEclass library : loading\n");

    k = PKhardpak (m, "EXAMPLEengine", EXAMPLE_PKG_NB, example_name, example_fun, example_narg, example_type);
    return k;
}





#if defined _WIN32 || defined __WIN32__
__declspec (dllexport) int SCOLloadEXAMPLE (mmachine m, cbmachine w)
{
    int k = 0;
    /* Affectation aux variables globales ww et mm des valeurs envoyées par le noyau des structures partagées.
    Il est impératif de les ajouter AVANT tout appel à des fonctions ou macros Scol sous peine de crash immédiat
    lors de l'exécution de Scol. */
    ww = w;
    mm = m;

    MMechostr (0, "EXAMPLE library : loading\n");

    if ((k = SCOLinitEXAMPLEclass (m))) return k;

    MMechostr (0, "\nEXAMPLE library loaded !\n");
    return k;
}


#elif defined linux || defined __linux
int SCOLloadEXAMPLE (mmachine m)
{
    int k = 0;
    /* Affectation à la variable globale mm des valeurs envoyées par le noyau des structures partagées.
    Il est impératif de l'ajouter AVANT tout appel à des fonctions ou macros Scol sous peine de crash immédiat
    lors de l'exécution de Scol. */
    mm = m;

    MMechostr (0, "EXAMPLE library : loading\n");

    if ((k = SCOLinitEXAMPLEclass (m))) return k;

    MMechostr (0, "\nEXAMPLE library loaded !\n");
    return k;
}

/* Autres plateformes (le compilateur retournera l'erreur et s'arrêtera) */
#else
#error no platform supported
#endif



#if defined linux || defined __linux
int SCOLfreeEXAMPLE ()

#elif defined _WIN32 || defined __WIN32__
__declspec (dllexport) int SCOLfreeEXAMPLE ()

#else
#error no platform supported
#endif

{
    MMechostr(MSKDEBUG, "\nEXAMPLE library release !\n");
    return 0;
}

---