/*
    Info (version 1.0 - 23/04/10)
    ce programme fournit tout un tas d'informations sur le fichier passé en argument, son nom, sa taille, ses attributs (caché, verrouillé ...), son type
    (extension, extension personnelle ...)
    L'utilisation est très simple : info("nom_du_programme")
*/

#define USE_TI89
#define USE_TI92PLUS
#define USE_V200

#include <tigcclib.h>

int create_int_var(char *name, unsigned short value)
{
    /* cree une variable valant value
       Prérequis : value entre 0 et 65535

        Format d'une variable int (en supposant valeur entre 0 et 65535 :
          2 octets : taille de la variable
          1 octet : bits de poids faible (reste de la division par 256)
          1 octet : bits de poids fort (quotient de la division par 256) si le nombre est supérieur à 256
          1 octet : 0 si le nombre est 0, 1 si le nombre est plus petit que 256, 2 sinon
          1 octet : INT_TAG (?) : 31
          1 octet : \0 de fin
         Total : 4-6 octets
    */

    unsigned short var_size;

    if (value > 255)
    {
       var_size = 6;
    }
    else
    {
       var_size = (value?5:4);
    }

    HSYM sym = SymAdd(SYMSTR(name));
    HANDLE h = HeapAlloc(var_size + 2);

    if (!h)   return(-1);

    SYM_ENTRY *sym_ptr = DerefSym(sym);
    sym_ptr->handle = h;

    char *ptr = HeapDeref(h); /* ptr pointe sur le debut du handle */
    *(unsigned short *)ptr = var_size - 2;
    ptr += 2;
    
    if (value > 255)
    {
       *ptr++ = value % 256;
       *ptr++ = value / 256;
       *ptr++ = 2;
    }
    else
    {
       *ptr++ = value;

       if (value)  *ptr++ = 1;
    }
   
    *ptr++ = 31;
    *ptr = 0;

    return 0;
}

int create_string_var(char *name, char *value)
{
    /* cree la variable name de type STR contenant value
       Format d'un fichier STR :
         2 octets : taille du fichier
         1 octet : '\0'
         n+1 octets : chaine avec '\0' de fin
         1 octet : STR_TAG (?) : 45
         1 octet : '\0'
       Total : n+5 octets
    */

    unsigned short len = strlen(value);
    unsigned short var_size = len+5;
    HSYM sym = SymAdd(SYMSTR(name));
    HANDLE h = HeapAlloc(var_size);

    if (!h)   return(-1);

    SYM_ENTRY *sym_ptr = DerefSym(sym);
    sym_ptr->handle = h;
    char *ptr = HeapDeref(h);
    *(unsigned short *)ptr = var_size - 2;
   ptr[2] = 0;

    /* copie de la chaine */
    memcpy(ptr+3,value,len);

    ptr[len+3] = 0;
    ptr[len+4] = 45;
    ptr[len+5] = 0;

    return 0;
}

void _main(void)
{
    ESI argptr;   /* pour les arguments */
    SYM_ENTRY *sym = NULL; /* pour toutes les informations dont on aura besoin */
    char* var = (char *)malloc(8*sizeof(char)); /* pour le nom du fichier */

    /* informations */
    unsigned short size; /* taille du fichier */
    unsigned short arc;  /* archivé ? */
    unsigned short lock; /* verrouillé ? */
    unsigned short hid;  /* caché ? */
    char p_ext[4];       /* extension personnelle si besoin */

    HANDLE h; /* HANDLE */
    unsigned char *ptr, *ext; /* pointeur qui va parcourir le fichier */
    char error;
    unsigned char read;  /* pour lire l'extension personnelle */

    InitArgPtr(argptr);
    memcpy(var,GetStrnArg(argptr),8); /* récupère le nom du fichier */

    sym = SymFindPtr(SYMSTR(var),0);

    if (!sym)  create_int_var("err",2);

    h = sym->handle;
    ptr = HeapDeref(h);

    size = *(unsigned short *)ptr + 2; /* récupère la taille (2 premiers octets) + 2 */
    error = create_int_var("size",size);

    if (error == -1)  create_int_var("err",3);

    arc = sym->flags.bits.archived;
    create_int_var("archived",arc);

    lock = sym->flags.bits.locked;
    create_int_var("locked",lock);

    hid = sym->flags.bits.hidden;
    create_int_var("hidden",hid);

    /* extension : avant-dernier octet */
    ext = ptr + size - 1;
    
    switch(*ext)
    {
       case POSINT_TAG:   /* entier */
          create_string_var("ext","INT");
       break;

       case NEGINT_TAG:
          create_string_var("ext","INT");
       break;

       case FLOAT_TAG:
          create_string_var("ext","FLOAT");
       break;

       case FALSE_TAG:
          create_string_var("ext","BOOL");
       break;

       case TRUE_TAG:
          create_string_var("ext","BOOL");
       break;

       case STR_TAG:
          create_string_var("ext","STR");
       break;

       case LIST_TAG:
          create_string_var("ext","LIST");
       break;         

       case FUNC_TAG:
          create_string_var("ext","PRGM");
       break;

       case PIC_TAG:
          create_string_var("ext","PIC");
       break;

       case MATRIX_TAG:
          create_string_var("ext","MAT");
       break;

       case TEXT_TAG:
          create_string_var("ext","TEXT");
       break;

       case ASM_TAG:
          create_string_var("ext","ASM");
       break;

       case OTH_TAG:
          create_string_var("ext","OTH");

          /* recuperation de l'extension personnelle */
          ext--;
          memset(p_ext, 0, 4*sizeof(char));
          read = 0;

          while (*ext)
          {
             ext--;
             p_ext[read] = *(unsigned char *)ext;
             read++;
          }
          create_string_var("extp",p_ext);          
       break;

       default:
          create_string_var("ext","UNKN");
       break;
    }

    free(var);
}