Head

GCC Code Coverage Report

Directory:	../src/		Exec	Total	Coverage
File:	/home/joels/Current/lispbm/src/stack.c	Lines:	46	54	85.2 %
Date:	2024-12-05 14:36:58	Branches:	5	12	41.7 %


/*
    Copyright 2019, 2021, 2024 Joel Svensson  svenssonjoel@yahoo.se

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    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.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <lbm_memory.h>
#include <lbm_types.h>
#include <string.h>

#include "stack.h"
#include "print.h"

#define STACK_UNUSED_BYTE 0x55
#ifndef LBM64
#define STACK_UNUSED_WORD 0x55555555
#else
#define STACK_UNUSED_WORD 0x5555555555555555
#endif

int lbm_stack_allocate(lbm_stack_t *s, lbm_uint stack_size) {
  int r = 0;
  s->data = lbm_memory_allocate(stack_size);
  if (s->data) {
    memset(s->data, STACK_UNUSED_BYTE, stack_size * sizeof(lbm_uint));
    s->sp = 0;
    s->size = stack_size;
    r = 1;
  }
  return r;
}

int lbm_stack_create(lbm_stack_t *s, lbm_uint* data, lbm_uint stack_size) {
  s->data = data;
  memset(s->data, STACK_UNUSED_BYTE, stack_size * sizeof(lbm_uint));
  s->sp = 0;
  s->size = stack_size;
  return 1;
}

lbm_uint lbm_get_max_stack(lbm_stack_t *s) {
  lbm_uint unused = 0;
  for (int i = (int)s->size-1 ; i >= 0; i --) {
    if (s->data[i] == STACK_UNUSED_WORD) {
      unused ++;
    } else {
      break;
    }
  }
  return s->size - unused;
}

void lbm_stack_free(lbm_stack_t *s) {
  if (s->data) {
    lbm_memory_free(s->data);
  }
}

void lbm_stack_clear(lbm_stack_t *s) {
  s->sp = 0;
}

int lbm_stack_drop(lbm_stack_t *s, lbm_uint n) {

  if (n > s->sp) return 0;

  s->sp -= n;
  return 1;
}

int lbm_push(lbm_stack_t *s, lbm_uint val) {
  int res = 1;
  if (s->sp == s->size) {
    return 0;
  }
  s->data[s->sp++] = val;
  return res;
}

int lbm_pop(lbm_stack_t *s, lbm_uint *val) {
  s->sp--;
  *val = s->data[s->sp];
  return 1;
}

int lbm_pop_2(lbm_stack_t *s, lbm_uint *r0, lbm_uint *r1) {
  s->sp--;
  *r0 = s->data[s->sp--];
  *r1 = s->data[s->sp];
  return 1;
}

int lbm_pop_3(lbm_stack_t *s, lbm_uint *r0, lbm_uint *r1, lbm_uint *r2) {
  s->sp--;
  *r0 = s->data[s->sp--];
  *r1 = s->data[s->sp--];
  *r2 = s->data[s->sp];
  return 1;
}



Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			Copyright 2019, 2021, 2024 Joel Svensson svenssonjoel@yahoo.se
3
4			This program is free software: you can redistribute it and/or modify
5			it under the terms of the GNU General Public License as published by
6			the Free Software Foundation, either version 3 of the License, or
7			(at your option) any later version.
8
9			This program is distributed in the hope that it will be useful,
10			but WITHOUT ANY WARRANTY; without even the implied warranty of
11			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			GNU General Public License for more details.
13
14			You should have received a copy of the GNU General Public License
15			along with this program. If not, see <http://www.gnu.org/licenses/>.
16			*/
17
18			#include <lbm_memory.h>
19			#include <lbm_types.h>
20			#include <string.h>
21
22			#include "stack.h"
23			#include "print.h"
24
25			#define STACK_UNUSED_BYTE 0x55
26			#ifndef LBM64
27			#define STACK_UNUSED_WORD 0x55555555
28			#else
29			#define STACK_UNUSED_WORD 0x5555555555555555
30			#endif
31
32		22764	int lbm_stack_allocate(lbm_stack_t *s, lbm_uint stack_size) {
33		22764	int r = 0;
34		22764	s->data = lbm_memory_allocate(stack_size);
35	✓✓	22764	if (s->data) {
36		22708	memset(s->data, STACK_UNUSED_BYTE, stack_size * sizeof(lbm_uint));
37		22708	s->sp = 0;
38		22708	s->size = stack_size;
39		22708	r = 1;
40			}
41		22764	return r;
42			}
43
44		43344	int lbm_stack_create(lbm_stack_t s, lbm_uint data, lbm_uint stack_size) {
45		43344	s->data = data;
46		43344	memset(s->data, STACK_UNUSED_BYTE, stack_size * sizeof(lbm_uint));
47		43344	s->sp = 0;
48		43344	s->size = stack_size;
49		43344	return 1;
50			}
51
52			lbm_uint lbm_get_max_stack(lbm_stack_t *s) {
53			lbm_uint unused = 0;
54			for (int i = (int)s->size-1 ; i >= 0; i --) {
55			if (s->data[i] == STACK_UNUSED_WORD) {
56			unused ++;
57			} else {
58			break;
59			}
60			}
61			return s->size - unused;
62			}
63
64		22483	void lbm_stack_free(lbm_stack_t *s) {
65	✓✗	22483	if (s->data) {
66		22483	lbm_memory_free(s->data);
67			}
68		22483	}
69
70		45679	void lbm_stack_clear(lbm_stack_t *s) {
71		45679	s->sp = 0;
72		45679	}
73
74		215465255	int lbm_stack_drop(lbm_stack_t *s, lbm_uint n) {
75
76	✗✓	215465255	if (n > s->sp) return 0;
77
78		215465255	s->sp -= n;
79		215465255	return 1;
80			}
81
82		18731550	int lbm_push(lbm_stack_t *s, lbm_uint val) {
83		18731550	int res = 1;
84	✗✓	18731550	if (s->sp == s->size) {
85			return 0;
86			}
87		18731550	s->data[s->sp++] = val;
88		18731550	return res;
89			}
90
91		452424231	int lbm_pop(lbm_stack_t s, lbm_uint val) {
92		452424231	s->sp--;
93		452424231	*val = s->data[s->sp];
94		452424231	return 1;
95			}
96
97		6503602	int lbm_pop_2(lbm_stack_t s, lbm_uint r0, lbm_uint *r1) {
98		6503602	s->sp--;
99		6503602	*r0 = s->data[s->sp--];
100		6503602	*r1 = s->data[s->sp];
101		6503602	return 1;
102			}
103
104		352526	int lbm_pop_3(lbm_stack_t s, lbm_uint r0, lbm_uint r1, lbm_uint r2) {
105		352526	s->sp--;
106		352526	*r0 = s->data[s->sp--];
107		352526	*r1 = s->data[s->sp--];
108		352526	*r2 = s->data[s->sp];
109		352526	return 1;
110			}
111