int main(int argc, char **argv) {
/*
* L'utilisation de volatile empêche le compilateur
* d'optimiser (i.e. supprimer) les variables.
*
* (void) var; évite l'avertissement concernant une variable non-utilisée
*
*/
/*
* Variables sur la pile (stack)
*/
volatile int cafe1 = 0x1111CAFE; (void) cafe1;
volatile int cafe2 = 0x2222CAFE; (void) cafe2;
volatile int cafe3[2] = { 0x3333CAFE, 0x4444CAFE }; (void) cafe3;
/*
* Variables sur le monceau (heap)
*/
volatile int *beef1 = malloc(sizeof(int)); (void) beef1;
volatile int *beef2 = malloc(sizeof(int)); (void) beef2;
volatile int *beef3 = malloc(2 * sizeof(int)); (void) beef3;
*beef1 = 0x1111BEEF;
*beef2 = 0x2222BEEF;
beef3[0] = 0x3333BEEF;
beef3[1] = 0x4444BEEF;
save_page("beef.page", (void *)beef1);
save_page("cafe.page", (void *)&cafe1);
return 0;
}
/*=========================================================================*
* function save_snapshot
* parameters: save to an Atari++ snapshot
*
* this functions creates an Atari++ snapshot based on a snapshot template
*=========================================================================*/
int save_snapshot(char *fin, char *fout) {
FILE *in, *out;
char *buf;
unsigned char *page;
int pageNum;
int okay;
in=fopen(fin,"rt");
if (!in) {
fprintf(stderr,"Could not open template state file '%s'.\n",fin);
return 0;
}
buf=(char *)malloc(512);
if (!buf) {
fprintf(stderr,"Could not allocate work space.\n");
return 0;
}
page=(unsigned char *)malloc(256);
if (!page) {
fprintf(stderr,"Could not allocate work space.\n");
return 0;
}
/* try to see if we are really an atari++ state file */
okay=0;
while(!feof(in)) {
buf[0]=0;
fgets(buf,512,in);
if (!strncmp("+RAM::",buf,6)) {
okay=1;
break;
}
}
if (!okay) {
fprintf(stderr,"Template snapshot '%s' not an Atari++ snapshot.\n",fin);
fclose(in);
free(buf);
free(page);
return 0;
}
out=fopen(fout,"wt");
if (!out) {
fprintf(stderr,"Cannot open snapshot '%s' for writing.\n",fout);
free(buf);
free(page);
return 0;
}
pageNum=0;
in=fopen(fin,"rt");
if (in) {
while(!feof(in)) {
buf[0]=0;
fgets(buf,512,in);
if (!strncmp("+RAM::",buf,6)) {
fprintf(out,"%s",buf);
if (!read_page(in,buf,page)) {
fprintf(stderr,"Error reading template Atari++ snapshot.\n");
fclose(in);
fclose(out);
free(buf);
free(page);
return 0;
}
merge_page(pageNum,page);
save_page(out,page);
pageNum++;
} else {
fprintf(out,"%s",buf);
}
}
}
fclose(in);
fclose(out);
free(buf);
free(page);
fprintf(stderr,"Created Atari++ snapshot file '%s'\n",fout);
return 1;
}
static gboolean read_syms()
{
FILE *fp;
static char symbol_table[] = "symbol-table";
static time_t file_modify_time;
if ((fp=watch_fopen(symbol_table, &file_modify_time))==NULL)
return FALSE;
skip_utf8_sigature(fp);
int pg;
for(pg=0; pg < pagesN; pg++) {
syms = pages[pg].syms;
symsN = pages[pg].symsN;
int i;
for(i=0; i < symsN; i++) {
int j;
for(j=0; j < syms[i].symN; j++)
if (syms[i].sym[j])
free(syms[i].sym[j]);
}
free(syms);
}
pagesN = 0; pages = NULL;
syms = NULL; symsN = 0;
while (!feof(fp)) {
char tt[1024];
bzero(tt, sizeof(tt));
myfgets(tt, sizeof(tt), fp);
// dbg("%d] %s\n",strlen(tt), tt);
int len=strlen(tt);
#if 0
if (!len)
continue;
if (tt[len-1]=='\n') {
tt[len-1]=0;
}
#endif
if (tt[0]==0)
save_page();
if (tt[0]=='#')
continue;
char *p=tt;
syms=trealloc(syms, SYM_ROW, symsN+1);
SYM_ROW *psym = &syms[symsN++];
bzero(psym, sizeof(SYM_ROW));
while (*p) {
char *n = p;
while (*n && *n!='\t')
n++;
*n = 0;
psym->sym=trealloc(psym->sym, char *, psym->symN+1);
psym->sym[psym->symN++] = strdup(p);
p = n + 1;
}
if (!psym->symN) {
free(syms);
syms=NULL;
symsN=0;
}
}
if (symsN)
save_page();
fclose(fp);
idx = 0;
syms = pages[idx].syms;
symsN = pages[idx].symsN;
return TRUE;
}
void *get_vmvarlib (struct varlist *varlist, S4 vind, S8 ind, U1 access, struct vm_mem *vm_mem)
{
// get address of array variable index
U1 type, cache_hit = 0;
S8 i ALIGN;
S8 addr ALIGN;
S8 hits ALIGN;
S8 page ALIGN;
S8 read_ind ALIGN;
S8 new_ind ALIGN;
U1 *new_s_memptr;
S2 *new_i_memptr;
S4 *new_li_memptr;
S8 *new_q_memptr;
F8 *new_d_memptr;
void *ret_memptr = NULL;
vm_mem->error = FALSE;
type = varlist[vind].type;
if (!varlist[vind].vm)
{
/* variable not in virtual memory, read from normal array */
if (varlist[vind].size > 0)
{
/* array variable allocated, get pointer */
switch (type)
{
case INT_VAR:
new_i_memptr = varlist[vind].i_m;
new_i_memptr = new_i_memptr + ind;
ret_memptr = (S2 *) new_i_memptr;
break;
case LINT_VAR:
new_li_memptr = varlist[vind].li_m;
new_li_memptr = new_li_memptr + ind;
ret_memptr = (S4 *) new_li_memptr;
break;
case QINT_VAR:
new_q_memptr = varlist[vind].q_m;
new_q_memptr = new_q_memptr + ind;
ret_memptr = (S8 *) new_q_memptr;
break;
case DOUBLE_VAR:
new_d_memptr = varlist[vind].d_m;
new_d_memptr = new_d_memptr + ind;
ret_memptr = (F8 *) new_d_memptr;
break;
case BYTE_VAR:
new_s_memptr = varlist[vind].s_m;
new_s_memptr = new_s_memptr + ind;
ret_memptr = (U1 *) new_s_memptr;
break;
}
}
else
{
/* array variable is deallocated, set error flag */
vm_mem->error = TRUE;
return (NULL);
}
}
else
{
/* variable is in virtual memory */
for (i = 0; i < MAXVMPAGES; i++)
{
/*
printf ("get_vmvarlib: page_hits: %lli\n", varlist[vind].vm_pages.page_hits[i]);
printf ("get_vmvarlib: page_start_addr: %lli\n", varlist[vind].vm_pages.page_start_addr[i]);
printf ("get_vmvarlib: page_end_addr: %lli\n", varlist[vind].vm_pages.page_end_addr[i]);
*/
if ((varlist[vind].vm_pages.page_end_addr[i] != 0) && (ind >= varlist[vind].vm_pages.page_start_addr[i] && ind <= varlist[vind].vm_pages.page_end_addr[i]))
{
// found page
cache_hit = 1;
/* correct index */
new_ind = ind - varlist[vind].vm_pages.page_start_addr[i];
/* DEBUG */
/*
if (new_ind > varlist[vind].vmcachesize - 1)
{
vm_mem->error = TRUE;
printf ("get_vmvarlib: FATAL ERROR: page index out of range! [cache hit]\n");
return (NULL);
}
*/
switch (type)
{
case INT_VAR:
new_i_memptr = (S2 *) (varlist[vind].vm_pages.pages[i] + (new_ind * sizeof (S2)));
ret_memptr = (S2 *) new_i_memptr;
break;
case LINT_VAR:
new_li_memptr = (S4 *) (varlist[vind].vm_pages.pages[i] + (new_ind * sizeof (S4)));
ret_memptr = (S4 *) new_li_memptr;
break;
case QINT_VAR:
new_q_memptr = (S8 *) (varlist[vind].vm_pages.pages[i] + (new_ind * sizeof (S8)));
ret_memptr = (S8 *) new_q_memptr;
break;
case DOUBLE_VAR:
new_d_memptr = (F8 *) (varlist[vind].vm_pages.pages[i] + (new_ind * sizeof (F8)));
ret_memptr = (F8 *) new_d_memptr;
break;
case BYTE_VAR:
new_s_memptr = (U1 *) (varlist[vind].vm_pages.pages[i] + (new_ind * sizeof (U1)));
ret_memptr = (U1 *) new_s_memptr;
break;
}
varlist[vind].vm_pages.page_hits[i]++;
if (access == VM_WRITE)
{
varlist[vind].vm_pages.page_mod[i] = PAGE_MODIFIED; // set page modified flag
}
break; /* BREAK for and continue */
}
}
if (cache_hit == 0)
{
/* no cache hit, search page memory to load */
hits = varlist[vind].vm_pages.page_hits[0]; page = 0;
for (i = 1; i < MAXVMPAGES; i++)
{
// printf ("page hits: page %lli, hits %lli\n", i, varlist[vind].vm_pages.page_hits[i]);
if (varlist[vind].vm_pages.page_hits[i] < hits)
{
hits = varlist[vind].vm_pages.page_hits[i]; page = i;
}
}
if (varlist[vind].vm_pages.page_mod[page] == PAGE_MODIFIED)
{
if (save_page (varlist, vind, page) == FALSE)
{
vm_mem->error = TRUE;
return (NULL);
}
}
if (ind + varlist[vind].vmcachesize > varlist[vind].size - 1)
{
/* correct page read position */
read_ind = varlist[vind].size - varlist[vind].vmcachesize;
if (load_page (varlist, vind, page, read_ind) == FALSE)
{
vm_mem->error = TRUE;
return (NULL);
}
}
else
{
if (load_page (varlist, vind, page, ind) == FALSE)
{
vm_mem->error = TRUE;
return (NULL);
}
}
varlist[vind].vm_pages.page_mod[page] = PAGE_READ;
new_ind = ind - varlist[vind].vm_pages.page_start_addr[page];
/* DEBUG */
/*
if (new_ind > varlist[vind].vmcachesize - 1)
{
vm_mem->error = TRUE;
printf ("get_vmvarlib: FATAL ERROR: page index out of range! [cache load]\n");
return (NULL);
}
*/
switch (type)
{
case INT_VAR:
new_i_memptr = (S2 *) (varlist[vind].vm_pages.pages[page] + (new_ind * sizeof (S2)));
ret_memptr = (S2 *) new_i_memptr;
break;
case LINT_VAR:
new_li_memptr = (S4 *) (varlist[vind].vm_pages.pages[page] + (new_ind * sizeof (S4)));
ret_memptr = (S4 *) new_li_memptr;
break;
case QINT_VAR:
new_q_memptr = (S8 *) (varlist[vind].vm_pages.pages[page] + (new_ind * sizeof (S8)));
ret_memptr = (S8 *) new_q_memptr;
break;
case DOUBLE_VAR:
new_d_memptr = (F8 *) (varlist[vind].vm_pages.pages[page] + (new_ind * sizeof (F8)));
ret_memptr = (F8 *) new_d_memptr;
break;
case BYTE_VAR:
new_s_memptr = (U1 *) (varlist[vind].vm_pages.pages[page] + (new_ind * sizeof (U1)));
ret_memptr = (U1 *) new_s_memptr;
break;
}
if (access == VM_WRITE)
{
varlist[vind].vm_pages.page_mod[page] = PAGE_MODIFIED; // set page modified flag
}
}
}
return (ret_memptr);
}
FilerSave::~FilerSave() {
save_page(true);
m_valid = false;
if (m_node_p)
save_node(0);
}
