🚀 go-pugleaf

nazwa to troche zart (fonetycznie mozna tez czytac jako om)

chodzi mi o to ze chyab chcialbym sie pobawic w pisanie 
kompilatora (takiego ktoryby przerabial prosty jezyk
przeze mnie zdefiniowany na wirtualny asembler mojej tez 
mojej wlasnej produkcji)

aby to bylo mozliwie latwe pomyslalem ze powinno to byc cos prostszego od b (a bardziej skomplikowanego od a/asma więc ą ;-)

[ogolnie chodzi o dwa cele na raz 
1) chce napisac mozliwie prosty kompilator
2) chce sobie oszczedzic pisania procedur w asmie tak ze 
ten jezyk powinien jednak pozwalac pisac prosciej niz 
w asmie

pytanie jak powinien wygladac taki prosty jezyk - jakies idee?- ogolnie wyszlo mi ze to powinno byc cos c-podobnego (bo c jest najlepszy) powinno byc jednak maksymalnie proste tak 
by maksymalnie uproscic pisanie kompilatora

obecnie wymyslilem o tak ze moglbym sie pozbyc wszysttkich zmiennych lokalnych jako ze w asmie mam 26 rejestrow (od a do z) moge dozwolic po prostu uzywanie tylko tych rejestrow jako lokalnych (w razie potrzeby moge ich dodac nawet wiecej w asemblerze) byloby to raczej prostsze niz nawet b 
zastanawiam sie czy moze jednak powinienem to uproscic jeszcze 
bardziej (?)

pozatym musze sie zastanowic jak przerobic kodw c powiedzmy taki jak ponizej na to ą (om) no i jak napisac ten prosty kompilator

jak ktos ma jakies uwago to chetnie przeczytam, jak sie sam zastanowie moze dopisze pare uwag 

nizej przyklad kodu do przerobienia i pozniej skompilowania


int mandelbrot_n(  float cRe,  float cIm,  int max_iter )
{


   float re = cRe;
   float im = cIm;

   float     rere=re*re;
   float     imim=im*im;

   for(int n=1; n<=max_iter; n++)
   {

            im =  (re+re)*im    + cIm;
            re =   rere - imim  + cRe;

            rere=re*re;
            imim=im*im;

            if ( (rere + imim) > 4.0 ) 
             return n;


   }

   return 0;

}


void mandelbrot_test(int CLIENT_X, int CLIENT_Y, double ox, double oy, double lx, int max_iter)
{
   SetupPalette( 550, 455, 45 );

   double ly = lx * CLIENT_Y / CLIENT_X;

   double dx = lx / CLIENT_X;
   double dy = ly / CLIENT_Y;

   double ax = ox - lx * 0.5 + dx * 0.5;
   double ay = oy - ly * 0.5 + dy * 0.5;


   for( int j=0 ; j<CLIENT_Y; j++ )
   {
     double    c_im = ay + j * dy;

    for( int i=0 ; i<CLIENT_X;  i++ )
    {
       double    c_re = ax + i * dx;

      int n = mandelbrot_n(c_re, c_im, max_iter);


      SetPixelSafe(i ,j, palette[n]);

    }
   }

}