Bientôt un compilateur C en ligne pour TI-83 Prem CE / 84+CE

[Ti64CLi++]

@Adriweb aurais-tu une idée de quand sera-t-il mit en ligne?

[Lionel Debroux]

Quand il sera prêt

[Ti64CLi++]

Et quand sera-t-il pret?

[Lionel Debroux]

"Quand ce sera prêt" a souvent comme significations implicite "on ne sait pas quand"
On ne publie habituellement pas des choses mal fichues, et on ne sait pas quand ça sera dans un état publiable.

La communauté n'est pas une entreprise: nous contribuons chacun dans la mesure de notre temps libre et de nos moyens, en fonction de nos contraintes IRL et communautaires.

[Adriweb]

On peut avoir le code source complet stp ?

Sure: (les quelques premières lignes étant déjà mises pas défut par l'éditeur)

Code: Select all

#define USE_OS_CRT
 
#include <String.h>
#include "CE.h"
 
#pragma asm "DB %EF" // tExtTok
#pragma asm "DB %7B" // tAsm84CeCmp

#define min(a,b) (((a)<(b))?(a):(b))
#define max(a,b) (((a)>(b))?(a):(b))
#define abs(x)   (((x)<0)?-(x):(x))

typedef unsigned char   uint8_t;
typedef unsigned short  uint16_t;

//*******************************************
// System Stuff
//*******************************************

void cleanUp();
void print(const char* string, uint8_t xpos, uint8_t ypos);
void printSmall(const char* string, uint16_t xpos, uint8_t ypos);

#define getKey()    asm("CALL _GetKey");

//*******************************************
// Graphical Stuff (Nspire-Lua like)
//*******************************************

#define SCR_WIDTH   320
#define SCR_HEIGHT  240

static const uint16_t* screen_buf = (uint16_t*)0xD40000;

typedef uint16_t    color_t;

#define rgb2color(r, g, b)        ((color_t)(((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | (b >> 3)))

void gc_drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
void gc_drawRect(uint16_t x, uint16_t y, uint16_t w, uint16_t h);
void gc_fillRect(uint16_t x, uint16_t y, uint16_t w, uint16_t h);
#define gc_drawPixel(x, y)        *((uint16_t*)(screen_buf + x + y*SCR_WIDTH)) = globalColor;
#define gc_setColor(c)            globalColor = c;
#define gc_setColorRGB(r, g, b)   globalColor = rgb2color(r, g, b);

enum colorNames { Black = 0, Grey, White, Red, Green, Blue };
color_t Colors[6] = {
    rgb2color(0, 0, 0),
    rgb2color(127, 127, 127),
    rgb2color(255, 255, 255),
    rgb2color(255, 0, 0),
    rgb2color(0, 255, 0),
    rgb2color(0, 0, 255)
};
color_t globalColor = 0;

char tmpBuf[20] = {0};

uint8_t i = 0;

/********************************************/

void main()
{
    cleanUp();
   
    /*
    print("Hello world", 2, 8);

    gc_setColor(Colors[Black]);
   
    gc_drawPixel(120, 75);

    gc_setColor(Colors[Grey]);
    gc_drawPixel(125, 75);
   
    gc_setColor(Colors[Red]);
    gc_drawPixel(130, 75);
   
    gc_setColor(Colors[Red]);
    gc_drawRect(150, 100, 20, 50);
           
    gc_setColor(Colors[Blue]);
    gc_fillRect(50, 50, 30, 10);

    gc_setColor(Colors[Green]);
    gc_drawLine(80, 80, 200, 100);
       
    printSmall("Bye world", 5, 80);
    */
   
    for (i=0; i<240; i++)
    {
        gc_setColorRGB(i, 255-i, 255);
        gc_drawLine(0, i, 319, i);
    }
   
    getKey();
    cleanUp();
}

void gc_drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
{
    if (y1 == y0)
    {
        uint16_t *base = screen_buf + min(x0, x1) + y0*SCR_WIDTH;
        uint16_t end = abs(x0-x1) + 1;
        uint16_t i;
        for (i = 0; i < end; i++)
        {
            *(base++) = globalColor;
        }
    } else {
        int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
        int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
        int err = (dx>dy ? dx : -dy)/2, e2;
        for(;;)
        {
            gc_drawPixel(x0, y0);
            if (x0 == x1 && y0 == y1)
                break;
            e2 = err;
            if (e2 >-dx) { err -= dy; x0 += sx; }
            if (e2 < dy) { err += dx; y0 += sy; }
        }
    }
}

void gc_drawRect(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
    gc_drawLine(x, y, x+w-1, y);
    gc_drawLine(x, y+h-1, x+w-1, y+h-1);
    gc_drawLine(x, y, x, y+h-1);
    gc_drawLine(x+w-1, y, x+w-1, y+h-1);
}

void gc_fillRect(uint16_t x, uint16_t y, uint16_t w, uint16_t h)
{
    uint16_t i, j;
    uint16_t* base = screen_buf + x + y*SCR_WIDTH;
    for(j=0; j<h; j++)
    {
        uint16_t* lineBase = base;
        for(i=0; i<h; i++)
        {
            *(lineBase++) = globalColor;
        }
        base += SCR_WIDTH;
    }
}

void cleanUp()
{
    asm("CALL _DelRes");
    asm("CALL _Clrtxtshd");
    asm("CALL _Clrscrn");
    asm("set 0,(iy+3)"); //mark graph as dirty
    asm("CALL _HomeUp");
    asm("CALL _DrawStatusBar");
}

void print(const char* string, uint8_t xpos, uint8_t ypos)
{
    asm("LD A,(IX+9)");
    asm("LD (D00596h),A");
    asm("LD A,(IX+12)");
    asm("LD (D00595h),A");
    asm("LD HL,(IX+6)");
    asm("CALL _Puts");
}

void printSmall(const char* string, uint16_t xpos, uint8_t ypos)
{
    asm("LD DE,(IX+9)");
    asm("LD.SIS (08D2h),DE");
    asm("LD A,(IX+12)");
    asm("LD (D008D5h),A");
    asm("LD HL,(IX+6)");
    asm("SET 3,(IY+5)");
    asm("CALL _vPuts");
}

Ca met environ 0.7 seconde à remplir l'écran (quasiment pareil si on entour la boucle for principale d'un di / ei), mais avec des routines de graphismes fait en assembleur directement, ça devrait être plus performant.

Mais attention, ZDS compile du code en utilisant les index registers (IY...), ce qui créée des conflits avec l'OS qui utilise ça pour les flags. C'est particulièrement embêtant parce qu'apparemment, il n'y a pas d'options pour lui faire compiler autrement... (sans parler des nombreux autres trucs chiants de ZDS et de son interprétation du C89)...

[Lionel Debroux]

min, max et abs sont de vilaines définitions peu sûres (elles ne font pas attention aux effets de bord)... mais avec ce compilo pourri, à part faire une fonction out of line et dégrader la taille et la vitesse, je ne vois pas trop ce qu'on peut faire...

[Adriweb]

Il est en effet très désagréable de programmer en C avec ce compilateur pour le moment...
Et on est obligé de faire des choses qui sont à la fois moins jolies, mais surtout moins bien.

Edit: btw, il faut faire toutes les déclarations de variable au début du scope en court (trop facile sinon )

[Adriweb]

Mise-à-jour (même si c'est toujours pas public pour le moment parce que ce n'est pas terminé... ) :

• Intégration des headers de base
• Header de types communs
• Meilleur gestion de plusieurs codes en parallèle (id uniques dans le localStorage etc.)
• Support de codage collaboratif en temps-réel :
  

[critor]

On peut faire des jeux sympa avec ce compilateur, avec quasiment aucune connaissance requise en assembleur.

La preuve, voici Mandragore, un jeu basé sur un moteur de déplacement bloc par bloc sur carte :


Les performances sont véritablement impressionnantes.

[Adriweb]

En voici même une petite vidéo