tests/invader/invader.e

+int push_button_get();
+void timer_set_and_wait(int period, int time);
+void clear_screen(int color);
+int read_pixel(int x, int y, int scale);
+void write_pixel_scaling(int pixel, int x, int y, int scale);
+void set_bg_color(int color);
+void set_fg_color(int color);
+void set_display_cur_pos(int x, int y);
+void display_string(char *msg);
+void set_display_scale(int s);
+int scale = 4;
+int TIMER_FREQ = 10000000;
+
+void dirty_exit(){
+  int x;
+  *(&x+1000000000) = 42;
+}
+
+/* Etats */
+
+struct etat {
+	int dx;
+	int dy;
+	int etat_suivant;
+};
+
+struct etat etats[5];
+
+void init_etat(int index, int dx, int dy, int next){
+  (etats[index]).dx = dx;
+  (etats[index]).dy = dy;
+  (etats[index]).etat_suivant = next;
+}
+
+/* Objets */
+
+struct Object {
+	int alive;
+	int period;
+	int deadline;
+	int x;
+  int y;
+	int dx;
+  int dy;
+	char *pattern;
+	int color;
+	int bg[64]; /* background */
+	int ax;
+  int ay;
+};
+
+struct Object object[7];
+
+int NOBJ = 7;
+
+void init_object(int index, int alive, int period, int deadline,
+                 int x, int y, int dx, int dy, char* pattern, int color){
+  (object[index]).alive = alive;
+  (object[index]).period = period;
+  (object[index]).deadline = deadline;
+  (object[index]).x = x;
+  (object[index]).y = y;
+  (object[index]).dx = dx;
+  (object[index]).dy = dy;
+  (object[index]).pattern = pattern;
+  (object[index]).color = color;
+}
+
+/* Sprites */
+
+char sprite_sship[8];
+char sprite_laser[8];
+char sprite_alien1[8];
+char sprite_alien2[8];
+char sprite_alien3[8];
+char sprite_alien4[8];
+char sprite_alien5[8];
+
+void init_sprite(char* t,  char a0, char a1, char a2, char a3,
+                 char a4, char a5, char a6, char a7){
+  t[0] = a0;
+  t[1] = a1;
+  t[2] = a2;
+  t[3] = a3;
+  t[4] = a4;
+  t[5] = a5;
+  t[6] = a6;
+  t[7] = a7;
+}
+
+void initialize()
+{
+	int i;
+  int dx;
+  int dy;
+	clear_screen(0x333333);
+  i = 0;
+	while(i < NOBJ) {
+		if (i == 1) {
+			/* laser */
+			(object[i]).alive = 0;
+			(object[i]).period = 1;
+		} else {
+			/* spaceship or aliens */
+			(object[i]).alive = 1;
+			if (i == 0){
+				/* spaceship */
+				(object[i]).period = 3;
+      }
+			else{
+				/* aliens */
+				(object[i]).period = 4;
+      }
+		}
+		(object[i]).deadline = 1;
+		if (i > 1) {
+			/* aliens */
+			if (i > 4) {
+				/* alien4 or alien5 */
+				(object[i]).y = 3; /* 3rd line */
+				(object[i]).x = 6 + (i - 4) * 8 ;
+			} else {
+
+				/* alien1, alien2 or alien3 */
+				(object[i]).y = 1; /* 1st line */
+				(object[i]).x = 10 + (i - 2) * 8;
+			}
+			(object[i]).dx = -1;
+			(object[i]).dy = 0;
+		}
+		(object[i]).ax = -1;
+		(object[i]).ay = -1;
+
+		/* initialization of object background considering the last one */
+    int* ptr = (object[i]).bg;
+    dx = 0;
+		while (dx < 8){
+      dy = 0;
+			while (dy < 8){
+        int p = read_pixel((((object[i]).x) * 8) + dx,
+                           (((object[i]).y) * 8) + dy, scale);
+				ptr[dx*8+dy] = p;
+        dy = dy + 1;
+      }
+      dx = dx + 1;
+    }
+    i = i + 1;
+	}
+}
+
+/* function to display the 8 pixels of a pattern line */
+void display_pattern_line(int m, int x, int y, int color)
+{
+	int i = 0;
+
+	while (i < 8){
+    if ((m & 1) == 1){
+      write_pixel_scaling(color, x + i, y, scale);
+    }
+		m = m / 2;
+    i = i + 1;
+	}
+}
+
+/* function to display an 8x8 object considering the last background */
+void display_pattern(char* pattern, int x, int y, int color)
+{
+	int i = 0;
+
+  while(i < 8){
+		display_pattern_line(pattern[i], x, y + i, color);
+    i = i + 1;
+  }
+}
+
+/* function to display an 8x8 object (spaceship, laser or alien) */
+void display_sprite(struct Object *object)
+{
+	int dx; int dy;
+	if ((object->ax > -1 && object->ay > -1) &&
+      (object->x != object->ax || object->y != object->ay || !(*object).alive))
+    {
+      int* ptr = object->bg;
+      dx = 0;
+      while(dx < 8) {
+        dy = 0;
+        while(dy < 8) {
+          write_pixel_scaling(ptr[dx*8+dy],
+                              ((object->ax) *8) + dx, ((object->ay) *8 ) + dy, scale);
+          if (!object->alive){
+            ptr[dx*8 + dy] = read_pixel(((object->x) *8) + dx,
+                                        ((object->y) *8) + dy, scale);
+          }
+          dy = dy + 1;
+        }
+        dx = dx + 1;
+      }
+    }
+	object->ax = object->x;
+	object->ay = object->y;
+	if ((*object).alive){
+		display_pattern(object->pattern, (object->x) * 8, (object->y) * 8,
+		                object->color);
+  }
+}
+
+int main(int argc, char* argv)
+{
+	/* declaration of local variables */
+	int i;
+  int dx;
+  int dy;
+	int push_state;
+  int alien_state;
+  int edge_reached;
+	int n_aliens;
+  struct Object *spaceship;
+  struct Object *laser;
+
+  init_etat(0, 0, 1, 1);
+  init_etat(1, 0, 1, 2);
+  init_etat(2, 1, 0, 3);
+  init_etat(3, 0, 1, 4);
+  init_etat(4, -1, 0, 1);
+
+  init_sprite(sprite_sship,  0x00, 0x3c, 0x7e, 0xff, 0xff, 0xe7, 0xc3, 0xc3);
+  init_sprite(sprite_laser,  231, 231, 255, 255, 126, 60, 24, 24);
+  init_sprite(sprite_alien1, 0xc3, 0x3c, 0x5a, 0xff, 0xff, 0x81, 0x42, 0x24);
+  init_sprite(sprite_alien2, 0xc3, 0x3c, 0x5a, 0xff, 0xff, 0xa5, 0xa5, 0x5a);
+  init_sprite(sprite_alien3, 0x42, 0x24, 0x3c, 0x5a, 0xff, 0xbd, 0x81, 0x42);
+  init_sprite(sprite_alien4, 0x81, 0x42, 0x3c, 0x5a, 0x5a, 0x3c, 0x42, 0x81);
+  init_sprite(sprite_alien5, 0x41, 0x22, 0x3e, 0x6b, 0x49, 0x7f, 0x3e, 0x55);
+  /*
+    0x41  .#....#.
+    0x22  ..#...#.
+    0x3e  ..#####.
+    0x6b  .##.#.##
+    0x49  .#..#..#
+    0x7f  .#######
+    0x3e  ..#####.
+    0x55  .#.#.#.#
+   */
+  init_object(0, 1, 3, 1, 18, 32, 0, 0, sprite_sship,  0x0000FF); /* blue spaceship */
+  init_object(1, 0, 1, 1, 18, 0,  0, 0, sprite_laser,  0xffc0cb); /* white laser */
+  init_object(2, 1, 4, 1, 10, 1, -1, 0, sprite_alien1, 0x00FF00); /* green alien */
+  init_object(3, 1, 4, 1, 18, 1, -1, 0, sprite_alien2, 0xFF0000); /* red alien */
+  init_object(4, 1, 4, 1, 26, 1, -1, 0, sprite_alien3, 0xFF00FF); /* magenta alien */
+  init_object(5, 1, 4, 1, 14, 3, -1, 0, sprite_alien4, 0xFFFF00); /* yellow alien */
+  init_object(6, 1, 4, 1, 22, 3, -1, 0, sprite_alien5, 0x00FFFF);  /* cyan alien */
+
+	/* initialization stage */
+	push_state = 0;           /* no button pressed at beginning */
+	alien_state = 0;          /* state of alien in a line */
+	edge_reached = 0;         /* no edge reached at beginning */
+	n_aliens = NOBJ - 2; /* number of displayed aliens */
+	spaceship = object;   /* spaceship is the first declared object */
+	laser = object + 1;       /* laser is the second declared object */
+
+
+
+  clear_screen(0xcccccc);
+  set_display_scale(8);
+  set_bg_color(0xcccccc);
+  set_fg_color(0x000000);
+  int started = 0;
+  while(!started){
+    char msg[60];
+    i = 0;
+    msg[i] = 'P'; i = i + 1;
+    msg[i] = 'o'; i = i + 1;
+    msg[i] = 'u'; i = i + 1;
+    msg[i] = 'r'; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 'c'; i = i + 1;
+    msg[i] = 'o'; i = i + 1;
+    msg[i] = 'm'; i = i + 1;
+    msg[i] = 'm'; i = i + 1;
+    msg[i] = 'e'; i = i + 1;
+    msg[i] = 'n'; i = i + 1;
+    msg[i] = 'c'; i = i + 1;
+    msg[i] = 'e'; i = i + 1;
+    msg[i] = 'r'; i = i + 1;
+    msg[i] = ','; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 'a'; i = i + 1;
+    msg[i] = 'p'; i = i + 1;
+    msg[i] = 'p'; i = i + 1;
+    msg[i] = 'u'; i = i + 1;
+    msg[i] = 'y'; i = i + 1;
+    msg[i] = 'e'; i = i + 1;
+    msg[i] = 'z'; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 's'; i = i + 1;
+    msg[i] = 'u'; i = i + 1;
+    msg[i] = 'r'; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 'H'; i = i + 1;
+    msg[i] = 'A'; i = i + 1;
+    msg[i] = 'U'; i = i + 1;
+    msg[i] = 'T'; i = i + 1;
+    msg[i] = '\n'; i = i + 1;
+    msg[i] = '\n'; i = i + 1;
+    msg[i] = 'P'; i = i + 1;
+    msg[i] = 'o'; i = i + 1;
+    msg[i] = 'u'; i = i + 1;
+    msg[i] = 'r'; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 'q'; i = i + 1;
+    msg[i] = 'u'; i = i + 1;
+    msg[i] = 'i'; i = i + 1;
+    msg[i] = 't'; i = i + 1;
+    msg[i] = 't'; i = i + 1;
+    msg[i] = 'e'; i = i + 1;
+    msg[i] = 'r'; i = i + 1;
+    msg[i] = ','; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 'a'; i = i + 1;
+    msg[i] = 'p'; i = i + 1;
+    msg[i] = 'p'; i = i + 1;
+    msg[i] = 'u'; i = i + 1;
+    msg[i] = 'y'; i = i + 1;
+    msg[i] = 'e'; i = i + 1;
+    msg[i] = 'z'; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 's'; i = i + 1;
+    msg[i] = 'u'; i = i + 1;
+    msg[i] = 'r'; i = i + 1;
+    msg[i] = ' '; i = i + 1;
+    msg[i] = 'B'; i = i + 1;
+    msg[i] = 'A'; i = i + 1;
+    msg[i] = 'S'; i = i + 1;
+    msg[i] = 0; i = i + 1;
+
+
+    set_display_cur_pos(10,10);
+    display_string(msg);
+
+    push_state = push_button_get();
+    if (push_state & 0x4) {
+      started = 1;
+    }
+    if (push_state & 0x8) {
+      dirty_exit();
+    }
+  }
+
+  clear_screen(0x333333);
+
+  initialize();
+
+	/* display stage */
+	while(1==1) {
+		edge_reached=0;
+
+    /* decrease deadline of alive objects */
+    i = 0;
+		while (i < NOBJ) {
+			if ((object[i]).alive == 1){
+				(object[i]).deadline = (object[i]).deadline - 1;
+      }
+      i = i + 1;
+		}
+
+		/* display all alive objects */
+    i = 0;
+		while (i < NOBJ) {
+			if ((object[i]).alive == 1){
+				display_sprite(object + i);
+      }
+      i = i + 1;
+		}
+
+		/* determine new positions of all alive objects */
+    i = 0;
+		while(i < NOBJ) {
+			/* update object state when deadline is reached */
+			if ((object[i]).alive == 1 && (object[i]).deadline == 0) {
+				/* reinitialize the object deadline to period */
+				(object[i]).deadline = (object[i]).period;
+				/* determine new position and manage screen edges */
+				(object[i]).x = (object[i]).x + (object[i]).dx;
+				if ((object[i]).x < 0){
+					(object[i]).x = 0;
+        }
+				if ((object[i]).x > 59){
+					(object[i]).x = 59;
+        }
+				(object[i]).y = (object[i]).y + (object[i]).dy;
+				/* test if an edge of the screen was reached by an alien */
+				if (i >= 2 && ((object[i]).x == 0 || (object[i]).x == 59)){
+					edge_reached = 1;
+        }
+				if (i > 1 && (object[i]).y >= spaceship->y){
+          // PERDU
+					clear_screen(0x0000FF); /* blue screen */
+          timer_set_and_wait(TIMER_FREQ, 1000);
+          dirty_exit();
+				}
+			}
+      i = i + 1;
+		}
+    /* test if alien is hit by an alive laser */
+		if (laser->alive) {
+      i = 2;
+			while(i < NOBJ) {
+				if ((object[i]).alive && !((laser->x > (object[i]).x + 1) || (laser->x + 1 < (object[i]).x)) &&
+            (laser->y) == (object[i]).y) {
+					n_aliens = n_aliens - 1;
+					(object[i]).alive = 0;
+					laser->alive = 0;
+					if (n_aliens == 0) {
+						/* no more aliens */
+						spaceship->alive = 0;
+						clear_screen(0xFF00); /* yellow screen */
+            timer_set_and_wait(TIMER_FREQ, 1000);
+            push_state = 0;           /* no button pressed at beginning */
+            alien_state = 0;          /* state of alien in a line */
+            edge_reached = 0;         /* no edge reached at beginning */
+            n_aliens = NOBJ - 2; /* number of displayed aliens */
+            spaceship = object;   /* spaceship is the first declared object */
+            laser = object + 1;       /* laser is the second declared object */
+            initialize();
+					} else {
+						display_sprite(object + i);
+						display_sprite(laser);
+					}
+				}
+        i = i + 1;
+			}
+		}
+    /* when an alien reaches a screen edge, the group of aliens is moved */
+		if (edge_reached) {
+      i = 2;
+			while (i < NOBJ) {
+				(object[i]).dx = (etats[alien_state]).dx;
+				(object[i]).dy = (etats[alien_state]).dy;
+        i = i + 1;
+			}
+			alien_state = (etats[alien_state]).etat_suivant;
+		}
+    /* laser disappears when it reaches the screen top */
+		if (laser->alive && laser->y == 0) {
+			laser->alive = 0;
+			display_sprite(laser);
+		}
+		/* manage push buttons */
+    push_state = push_button_get();
+
+		if (   (spaceship->deadline == 1)
+           || (n_aliens == 0)) {
+			spaceship->dx = 0;
+			if (push_state & 0x1) { // right
+        spaceship->dx = 1;
+      }
+			if (push_state & 0x2){ // left
+				spaceship->dx = -1;
+      }
+			if (push_state & 0x4) { // fire
+				if (!laser->alive) {
+					laser->alive = 1;
+					laser->dx = 0;
+					laser->dy = -1;
+					laser->x = spaceship->x;
+					laser->y = spaceship->y - 1;
+					laser->deadline = laser->period;
+				}
+			}
+      if (push_state & 0x8) {
+        dirty_exit();
+			}
+		}
+
+    timer_set_and_wait(TIMER_FREQ, 4);
+	}
+}

tests/invader/itoa.c

+#include<stdio.h>
+
+char * itoa(signed int i, char* buf){
+  char *s = buf + 10;
+  *s = '\0';
+  char neg = 0;
+  if (i < 0) {
+	  neg = 1;
+	  i = - i;
+  }
+  if (i == 0){
+	  *--s = '0';
+	  return s;
+  }
+  while(i > 0){
+	
+	*--s = (i % 10) + '0';
+	i = i / 10;
+  }
+  if (neg){
+	  *--s = '-';
+  }
+  return s;
+}
+
+/* int main(){ */
+/* char buf[20] = "abcdefghijklmnopqrst"; */
+/*  printf("itoa(-23467) = %s\n", itoa(-23467,buf)); */
+/*  printf("itoa(1238) = %s\n", itoa(1238,buf)); */
+/*  printf("itoa(0) = %s\n", itoa(0,buf)); */
+/*  printf("itoa(-0) = %s\n", itoa(-0,buf)); */
+
+/* 	return 0; */
+/* } */

tests/invader/libscreen.c

+#include "femto.h"
+#include "libscreen.h"
+#include "cep_platform.h"
+
+typedef unsigned int uint;
+
+volatile uint* IMG  = (volatile uint*) 0x80000000;
+volatile uint *push = (volatile uint *)0x30000008;
+volatile uint* led = (volatile uint *)REG_LEDS_ADDR;
+volatile uint *timer     = (volatile uint *)CLINT_TIMER;
+volatile uint *timer_hi =  (volatile uint *)CLINT_TIMER_HI;
+volatile uint *timer_lo =  (volatile uint *)CLINT_TIMER_LOW;
+volatile uint *timer_cmp = (volatile uint *)CLINT_TIMER_CMP;
+volatile uint *timer_cmp_hi = (volatile uint *)CLINT_TIMER_CMP_HI;
+volatile uint *timer_cmp_lo = (volatile uint *)CLINT_TIMER_CMP_LO;
+
+
+
+/* function to get the state of push buttons */
+uint push_button_get(void)
+{
+  uint v = (*push) >> 16;
+  //printf("push_button_get: @ %p, v = %x, %x\n", push, *push, v);
+  return v;
+}
+
+
+/* function to set the value displayed on leds */
+void led_set(uint value)
+{
+
+	*led = value;
+}
+
+/* function to set the timer to be reached in period*time/100 in the future */
+void timer_set(uint period, uint time)
+{
+  uint now = *timer;
+  *timer_cmp = now + ((uint)period/RATIO * time);
+}
+
+/* function to wait for timer zero value */
+void timer_wait(void)
+{
+	while(*timer <=  *timer_cmp);
+}
+
+void timer_set_and_wait(uint period, uint time)
+{
+  timer_set(period, time);
+  timer_wait();
+}
+
+void draw(uint color, uint x, uint y){
+  uint pos = (y * NBCOL + x);
+  if (pos < 1920 * 1080){
+    *(IMG + pos) = color;
+  }
+}
+
+void clear_screen(uint color){
+  for(uint j = 0; j < NBROW; j++){
+    for(uint i = 0; i < NBCOL; i++){
+      draw(color, i, j);
+    }
+  }
+}
+
+void draw_bitmap(char* bitmap){
+
+  for(uint j = 0; j < 8; j++){
+    for(uint i = 0; i < 8; i++){
+      uint set = (bitmap[j] & (1 << i)) >> i;
+      //draw pixel bitmap[j][i]
+      for(uint jy = 0; jy < display_scale; jy++){
+        for(uint ix = 0; ix < display_scale; ix++){
+          uint realx = display_cur_x + i * display_scale + ix;
+          uint realy = display_cur_y + j * display_scale + jy;
+          /* pruintf("Writing at %d, %d, color = %x\n", realx, realy, color); */
+          if(set){
+            draw(fgcolor, realx, realy);
+          }
+          else{
+            draw(bgcolor, realx, realy);
+          }
+        }
+      }
+    }
+  }
+}
+
+extern char* itoa(uint, char*);
+
+void newline(){
+  display_cur_x = 0;
+  display_cur_y += display_scale*10;
+}
+void tab(){
+  display_cur_x += display_scale*8*4;
+}
+
+/* Counts the number of characters of current word. Will be used to break lines, if possible not in the middle of words. */
+uint num_characters_until_white(char* str){
+  uint i = 0;
+  char c;
+  while(c = *str++){
+    if (c == ' ' || c == '\t' || c == '\n'){
+      return i;
+    }
+    if (c == '.' || c == ','){
+      return i + 1;
+    }
+    i++;
+  }
+  return i;
+}
+
+
+
+void display_string(char* str){
+  while(*str){
+    uint n = num_characters_until_white(str) + 1;
+    // If there's not enough space on current line for whole current word, newline
+    if (display_cur_x + (n-1) * display_scale * 8 > 1920){
+      newline();
+    }
+    for(uint i = 0; i < n; i++){
+      char c = str[i];
+      if(c == '\n'){
+        newline();
+      } else if (c == '\t'){
+        tab();
+      } else {
+        draw_bitmap(font8x8_basic[c]);
+        display_cur_x+=display_scale*8;
+      }
+      // Still, if the next character wouldn't fit on the screen, break in the middle of the word.
+      if (display_cur_x + display_scale * 8 > 1920){
+        newline();
+      }
+    }
+    str = str + n;
+  }
+}
+
+void display_uint(uint i){
+  char buf[10], *bu;
+  bu = itoa(i, buf);
+  display_string(bu);
+}
+
+void set_display_scale(int s){
+  display_scale = s;
+}
+void set_display_cur_pos(int x, int y){
+  display_cur_x = x;
+  display_cur_y = y;
+}
+
+
+void set_fg_color(uint color){
+  fgcolor = color;
+}
+void set_bg_color(uint color){
+  bgcolor = color;
+}
+
+
+
+/* function to read a pixel from a (x,y) position of video framebuffer */
+uint read_pixel(uint x, uint y, uint scale)
+{
+  // #SCALING
+  //return IMG[y * DISPLAY_WIDTH + x];
+	const uint pos = y * scale * NBCOL + x * scale;
+  if (pos < 1920*1080)
+    return IMG[pos];
+  return -1;
+}
+
+/* function to write a pixel in a (x,y) position of video framebuffer */
+void write_pixel(uint pixel, uint x, uint y)
+{
+  const uint pos = y * NBCOL + x;
+  if (pos < 1920*1080)
+  IMG[pos] = pixel;
+}
+
+void write_pixel_scaling(uint pixel, uint x, uint y, uint scale)
+{
+  uint i, j;
+	for (i = 0; i < scale; ++i) {
+		for (j = 0; j < scale; ++j) {
+			const uint real_y = (y * scale + i);
+			const uint real_x = x * scale + j;
+
+      write_pixel(pixel, real_x, real_y);
+		}
+	}
+
+}
+
+void show_pos ( int i, int x, int y){
+  /* printf("show_pos %d: @ %p, v = %x\n",x,  ptr, *(int*)(ptr+20)); */
+  /* printf("alive = %x\n", *(int*)(ptr+ 0 )); */
+  /* printf("period = %x\n", *(int*)(ptr+ 4 )); */
+  /* printf("deadline = %x\n", *(int*)(ptr+ 8 )); */
+  /* printf("x = %x\n", *(int*)(ptr+ 12 )); */
+  /* printf("y = %x\n", *(int*)(ptr+ 16 )); */
+  /* printf("dx = %x\n", *(int*)(ptr+ 20 )); */
+  /* printf("dy = %x\n", *(int*)(ptr+ 24 )); */
+  /* int i; */
+  /* asm("\t mv %0, sp" : "=r"(i)); */
+  /* printf("sp = %x\n", i); */
+  /* asm("\t mv %0, s0" : "=r"(i)); */
+  /* printf("s0 = %x\n", i); */
+  printf("i = %d, x = %d; y = %d\n",i, x,y);
+}

tests/invader/macros.S

+# See LICENSE for license details.
+
+.equ REGBYTES, 4
+
+.macro lx a, b
+lw \a, \b
+.endm
+
+.macro sx a, b
+sw \a, \b
+.endm
+
+.macro lxsp a, b
+lw \a, ((\b)*REGBYTES)(sp)
+.endm
+
+.macro sxsp a, b
+sw \a, ((\b)*REGBYTES)(sp)
+.endm
+
+.macro .ptr a
+.4byte \a
+.endm

tests/invader/setup.c

+// See LICENSE for license details.
+
+#include "femto.h"
+
+auxval_t __auxv[] = {
+    { UART0_CLOCK_FREQ,         32000000   },
+    { UART0_BAUD_RATE,          115200     },
+    { SIFIVE_UART0_CTRL_ADDR,   0x10013000 },
+    { SIFIVE_TEST_CTRL_ADDR,    0x100000   },
+    { 0, 0 }
+};
+
+void arch_setup()
+{
+#if defined(ENV_QEMU) 
+    register_console(&console_sifive_uart);
+    register_poweroff(&poweroff_sifive_test);
+#endif
+}

tests/ptr/ptr.e

+void f(int* z, int x, int y){
+  *z = x + y;
+}
+int main(int x, int y){
+  int z = 3;
+  f(&z, x, y);
+  return z;
+}

tests/ptr/ptr.e.expect_14_12_3_8_12

+{"output": "", "error": null, "retval": 26}
\ No newline at end of file

tests/ptr/ptr.e.expect_1_2_3

+{"output": "", "error": null, "retval": 3}
\ No newline at end of file

tests/ptr/ptr.e.expect_lexer

+SYM_VOID
+SYM_IDENTIFIER(f)
+SYM_LPARENTHESIS
+SYM_INT
+SYM_ASTERISK
+SYM_IDENTIFIER(z)
+SYM_COMMA
+SYM_INT
+SYM_IDENTIFIER(x)
+SYM_COMMA
+SYM_INT
+SYM_IDENTIFIER(y)
+SYM_RPARENTHESIS
+SYM_LBRACE
+SYM_ASTERISK
+SYM_IDENTIFIER(z)
+SYM_ASSIGN
+SYM_IDENTIFIER(x)
+SYM_PLUS
+SYM_IDENTIFIER(y)
+SYM_SEMICOLON
+SYM_RBRACE
+SYM_INT
+SYM_IDENTIFIER(main)
+SYM_LPARENTHESIS
+SYM_INT
+SYM_IDENTIFIER(x)
+SYM_COMMA
+SYM_INT
+SYM_IDENTIFIER(y)
+SYM_RPARENTHESIS
+SYM_LBRACE
+SYM_INT
+SYM_IDENTIFIER(z)
+SYM_ASSIGN
+SYM_INTEGER(3)
+SYM_SEMICOLON
+SYM_IDENTIFIER(f)
+SYM_LPARENTHESIS
+SYM_AMPERSAND
+SYM_IDENTIFIER(z)
+SYM_COMMA
+SYM_IDENTIFIER(x)
+SYM_COMMA
+SYM_IDENTIFIER(y)
+SYM_RPARENTHESIS
+SYM_SEMICOLON
+SYM_RETURN
+SYM_IDENTIFIER(z)
+SYM_SEMICOLON
+SYM_RBRACE
+SYM_EOF

tests/ptr/ptr2.e

+int main(){
+  int x = 0;
+  int *y = &x;
+  int** z = &y;
+  **z = 3;
+  return x;
+}

tests/ptr/ptr2.e.expect_14_12_3_8_12

+{"output": "", "error": null, "retval": 3}
\ No newline at end of file

tests/ptr/ptr2.e.expect_1_2_3

+{"output": "", "error": null, "retval": 3}
\ No newline at end of file

tests/ptr/ptr2.e.expect_lexer

+SYM_INT
+SYM_IDENTIFIER(main)
+SYM_LPARENTHESIS
+SYM_RPARENTHESIS
+SYM_LBRACE
+SYM_INT
+SYM_IDENTIFIER(x)
+SYM_ASSIGN
+SYM_INTEGER(0)
+SYM_SEMICOLON
+SYM_INT
+SYM_ASTERISK
+SYM_IDENTIFIER(y)
+SYM_ASSIGN
+SYM_AMPERSAND
+SYM_IDENTIFIER(x)
+SYM_SEMICOLON
+SYM_INT
+SYM_ASTERISK
+SYM_ASTERISK
+SYM_IDENTIFIER(z)
+SYM_ASSIGN
+SYM_AMPERSAND
+SYM_IDENTIFIER(y)
+SYM_SEMICOLON
+SYM_ASTERISK
+SYM_ASTERISK
+SYM_IDENTIFIER(z)
+SYM_ASSIGN
+SYM_INTEGER(3)
+SYM_SEMICOLON
+SYM_RETURN
+SYM_IDENTIFIER(x)
+SYM_SEMICOLON
+SYM_RBRACE
+SYM_EOF

tests/ptr/weird-ptr.e

+int ignore(int * x){
+  return 0;
+}
+int main(){
+  int x = 0;
+  int y = 0;
+  ignore(&x); // force x on the stack
+  int* p = &y - 1;
+  *p = 3;
+  return x;
+}

tests/ptr/weird-ptr.e.expect_14_12_3_8_12

+{"output": "", "error": null, "retval": 3}
\ No newline at end of file

tests/ptr/weird-ptr.e.expect_1_2_3

+{"output": "", "error": null, "retval": 3}
\ No newline at end of file

tests/ptr/weird-ptr.e.expect_lexer

+SYM_INT
+SYM_IDENTIFIER(ignore)
+SYM_LPARENTHESIS
+SYM_INT
+SYM_ASTERISK
+SYM_IDENTIFIER(x)
+SYM_RPARENTHESIS
+SYM_LBRACE
+SYM_RETURN
+SYM_INTEGER(0)
+SYM_SEMICOLON
+SYM_RBRACE
+SYM_INT
+SYM_IDENTIFIER(main)
+SYM_LPARENTHESIS
+SYM_RPARENTHESIS
+SYM_LBRACE
+SYM_INT
+SYM_IDENTIFIER(x)
+SYM_ASSIGN
+SYM_INTEGER(0)
+SYM_SEMICOLON
+SYM_INT
+SYM_IDENTIFIER(y)
+SYM_ASSIGN
+SYM_INTEGER(0)
+SYM_SEMICOLON
+SYM_IDENTIFIER(ignore)
+SYM_LPARENTHESIS
+SYM_AMPERSAND
+SYM_IDENTIFIER(x)
+SYM_RPARENTHESIS
+SYM_SEMICOLON
+SYM_INT
+SYM_ASTERISK
+SYM_IDENTIFIER(p)
+SYM_ASSIGN
+SYM_AMPERSAND
+SYM_IDENTIFIER(y)
+SYM_MINUS
+SYM_INTEGER(1)
+SYM_SEMICOLON
+SYM_ASTERISK
+SYM_IDENTIFIER(p)
+SYM_ASSIGN
+SYM_INTEGER(3)
+SYM_SEMICOLON
+SYM_RETURN
+SYM_IDENTIFIER(x)
+SYM_SEMICOLON
+SYM_RBRACE
+SYM_EOF

tests/real_args/show_args.e

-int main(int argc, char* argv[]){
-  print_string("Program launched with ");
-  print_int(argc);
-  print_string(" arguments\n");
-  int i = 0;
-  while(i < argc){
-    print_string("argv[");
-    print_int(i);
-    print_string("] = ");
-    print_string(argv[i]);
-    print_string("\n");
-    i = i + 1;
-  }
-  return argc;
-}

tests/strings/rot13.e

-int and(int a, int b){
-  if(a != 0){ return b; }
-  return 0;
-}
-
-int rot13c(char x){
-  if('A' <= x){
-    if (x <= 'Z'){
-      return 'A' + (x - 'A' + 13) % 26;
-    }
-  }
-  if('a' <= x){
-    if (x <= 'z'){
-      return 'a' + (x - 'a' + 13) % 26;
-    }
-  }
-  return x;
-}
-
-int rot13(char* c){
-  int i = 0;
-
-  while(c[i] != 0){
-    c[i] = rot13c(c[i]);
-    i = i + 1;
-  }
-  return 0;
-}
-int main(int argc,char* argv[]){
-  int a = atoi(argv[1]);
-  int b = atoi(argv[2]);
-  char c[10];
-  c[0] = 'C';
-  c[1] = 'o';
-  c[2] = 'u';
-  c[3] = 'c';
-  c[4] = 'o';
-  c[5] = 'u';
-  c[6] = 0;
-
-  rot13(c);
-  print_string(c);
-  return 0;
-}