sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
5167631d29
nuttx-apps/interpreters/bas/program.c

778 lines
19 KiB
C
Raw Blame History

/* Program storage. */
/* #includes */ /*{{{C}}}*//*{{{*/
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 2
#include "config.h"
#include <assert.h>
#include <errno.h>
#ifdef HAVE_GETTEXT
#include <libintl.h>
#define _(String) gettext(String)
#else
#define _(String) String
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "auto.h"
#include "error.h"
#include "fs.h"
#include "program.h"
/*}}}*/
struct Program *Program_new(struct Program *this) /*{{{*/
{
this->trace=0;
this->size=0;
this->numbered=1;
this->capacity=0;
this->runnable=0;
this->unsaved=0;
this->code=(struct Token**)0;
this->scope=(struct Scope*)0;
String_new(&this->name);
return this;
}
/*}}}*/
void Program_destroy(struct Program *this) /*{{{*/
{
while (this->size) Token_destroy(this->code[--this->size]);
if (this->capacity) free(this->code);
this->code=(struct Token**)0;
this->scope=(struct Scope*)0;
String_destroy(&this->name);
}
/*}}}*/
void Program_norun(struct Program *this) /*{{{*/
{
this->runnable=0;
this->scope=(struct Scope*)0;
}
/*}}}*/
void Program_store(struct Program *this, struct Token *line, long int where) /*{{{*/
{
int i;
assert(line->type==T_INTEGER || line->type==T_UNNUMBERED);
this->runnable=0;
this->unsaved=1;
if (line->type==T_UNNUMBERED) this->numbered=0;
if (where)
{
int last=-1;
for (i=0; i<this->size; ++i)
{
assert(this->code[i]->type==T_INTEGER || this->code[i]->type==T_UNNUMBERED);
if (where>last && where<this->code[i]->u.integer)
{
if ((this->size+1)>=this->capacity)
{
this->code=realloc(this->code,sizeof(struct Token*)*(this->capacity?(this->capacity*=2):(this->capacity=256)));
}
memmove(&this->code[i+1],&this->code[i],(this->size-i)*sizeof(struct Token*));
this->code[i]=line;
++this->size;
return;
}
else if (where==this->code[i]->u.integer)
{
Token_destroy(this->code[i]);
this->code[i]=line;
return;
}
last=this->code[i]->u.integer;
}
}
else i=this->size;
if ((this->size+1)>=this->capacity)
{
this->code=realloc(this->code,sizeof(struct Token*)*(this->capacity?(this->capacity*=2):(this->capacity=256)));
}
this->code[i]=line;
++this->size;
}
/*}}}*/
void Program_delete(struct Program *this, const struct Pc *from, const struct Pc *to) /*{{{*/
{
int i, first, last;
this->runnable=0;
this->unsaved=1;
first=from ? from->line : 0;
last=to ? to->line : this->size-1;
for (i=first; i<=last; ++i) Token_destroy(this->code[i]);
if ((last+1)!=this->size) memmove(&this->code[first],&this->code[last+1],(this->size-last+1)*sizeof(struct Token*));
this->size-=(last-first+1);
}
/*}}}*/
void Program_addScope(struct Program *this, struct Scope *scope) /*{{{*/
{
struct Scope *s;
s=this->scope;
this->scope=scope;
scope->next=s;
}
/*}}}*/
struct Pc *Program_goLine(struct Program *this, long int line, struct Pc *pc) /*{{{*/
{
int i;
for (i=0; i<this->size; ++i)
{
if (this->code[i]->type==T_INTEGER && line==this->code[i]->u.integer)
{
pc->line=i;
pc->token=this->code[i]+1;
return pc;
}
}
return (struct Pc*)0;
}
/*}}}*/
struct Pc *Program_fromLine(struct Program *this, long int line, struct Pc *pc) /*{{{*/
{
int i;
for (i=0; i<this->size; ++i)
{
if (this->code[i]->type==T_INTEGER && this->code[i]->u.integer>=line)
{
pc->line=i;
pc->token=this->code[i]+1;
return pc;
}
}
return (struct Pc*)0;
}
/*}}}*/
struct Pc *Program_toLine(struct Program *this, long int line, struct Pc *pc) /*{{{*/
{
int i;
for (i=this->size-1; i>=0; --i)
{
if (this->code[i]->type==T_INTEGER && this->code[i]->u.integer<=line)
{
pc->line=i;
pc->token=this->code[i]+1;
return pc;
}
}
return (struct Pc*)0;
}
/*}}}*/
int Program_scopeCheck(struct Program *this, struct Pc *pc, struct Pc *fn) /*{{{*/
{
struct Scope *scope;
if (fn==(struct Pc*)0) /* jump from global block must go to global pc */
{
for (scope=this->scope; scope; scope=scope->next)
{
if (pc->line<scope->begin.line) continue;
if (pc->line==scope->begin.line && pc->token<=scope->begin.token) continue;
if (pc->line>scope->end.line) continue;
if (pc->line==scope->end.line && pc->token>scope->end.token) continue;
return -1;
}
}
else /* jump from local block must go to local block */
{
scope=&(fn->token+1)->u.identifier->sym->u.sub.u.def.scope;
if (pc->line<scope->begin.line) return -1;
if (pc->line==scope->begin.line && pc->token<=scope->begin.token) return -1;
if (pc->line>scope->end.line) return -1;
if (pc->line==scope->end.line && pc->token>scope->end.token) return -1;
}
return 0;
}
/*}}}*/
struct Pc *Program_dataLine(struct Program *this, long int line, struct Pc *pc) /*{{{*/
{
if ((pc=Program_goLine(this,line,pc))==(struct Pc*)0) return (struct Pc*)0;
while (pc->token->type!=T_DATA)
{
if (pc->token->type==T_EOL) return (struct Pc*)0;
else ++pc->token;
}
return pc;
}
/*}}}*/
struct Pc *Program_imageLine(struct Program *this, long int line, struct Pc *pc) /*{{{*/
{
if ((pc=Program_goLine(this,line,pc))==(struct Pc*)0) return (struct Pc*)0;
while (pc->token->type!=T_IMAGE)
{
if (pc->token->type==T_EOL) return (struct Pc*)0;
else ++pc->token;
}
++pc->token;
if (pc->token->type!=T_STRING) return (struct Pc*)0;
return pc;
}
/*}}}*/
long int Program_lineNumber(const struct Program *this, const struct Pc *pc) /*{{{*/
{
if (pc->line==-1) return 0;
if (this->numbered) return (this->code[pc->line]->u.integer);
else return (pc->line+1);
}
/*}}}*/
struct Pc *Program_beginning(struct Program *this, struct Pc *pc) /*{{{*/
{
if (this->size==0) return (struct Pc*)0;
else
{
pc->line=0;
pc->token=this->code[0]+1;
return pc;
}
}
/*}}}*/
struct Pc *Program_end(struct Program *this, struct Pc *pc) /*{{{*/
{
if (this->size==0) return (struct Pc*)0;
else
{
pc->line=this->size-1;
pc->token=this->code[this->size-1];
while (pc->token->type!=T_EOL) ++pc->token;
return pc;
}
}
/*}}}*/
struct Pc *Program_nextLine(struct Program *this, struct Pc *pc) /*{{{*/
{
if (pc->line+1==this->size) return (struct Pc*)0;
else
{
pc->token=this->code[++pc->line]+1;
return pc;
}
}
/*}}}*/
int Program_skipEOL(struct Program *this, struct Pc *pc, int dev, int tr) /*{{{*/
{
if (pc->token->type==T_EOL)
{
if (pc->line==-1 || pc->line+1==this->size) return 0;
{
pc->token=this->code[++pc->line]+1;
Program_trace(this,pc,dev,tr);
return 1;
}
}
else return 1;
}
/*}}}*/
void Program_trace(struct Program *this, struct Pc *pc, int dev, int tr) /*{{{*/
{
if (tr && this->trace && pc->line!=-1)
{
char buf[40];
sprintf(buf,"<%ld>\n",this->code[pc->line]->u.integer);
FS_putChars(dev,buf);
}
}
/*}}}*/
void Program_PCtoError(struct Program *this, struct Pc *pc, struct Value *v) /*{{{*/
{
struct String s;
String_new(&s);
if (pc->line>=0)
{
if (pc->line<(this->size-1) || pc->token->type!=T_EOL)
{
String_appendPrintf(&s,_(" in line %ld at:\n"),Program_lineNumber(this,pc));
Token_toString(this->code[pc->line],(struct Token*)0,&s,(int*)0,-1);
Token_toString(this->code[pc->line],pc->token,&s,(int*)0,-1);
String_appendPrintf(&s,"^\n");
}
else
{
String_appendPrintf(&s,_(" at: end of program\n"));
}
}
else
{
String_appendPrintf(&s,_(" at: "));
if (pc->token->type!=T_EOL) Token_toString(pc->token,(struct Token*)0,&s,(int*)0,-1);
else String_appendPrintf(&s,_("end of line\n"));
}
Value_errorSuffix(v,s.character);
String_destroy(&s);
}
/*}}}*/
struct Value *Program_merge(struct Program *this, int dev, struct Value *value) /*{{{*/
{
struct String s;
int l,err=0;
l=0;
while (String_new(&s),(err=FS_appendToString(dev,&s,1))!=-1 && s.length)
{
struct Token *line;
++l;
if (l!=1 || s.character[0]!='#')
{
line=Token_newCode(s.character);
if (line->type==T_INTEGER && line->u.integer>0) Program_store(this,line,this->numbered?line->u.integer:0);
else if (line->type==T_UNNUMBERED) Program_store(this,line,0);
else
{
Token_destroy(line);
return Value_new_ERROR(value,INVALIDLINE,l);
}
}
String_destroy(&s);
}
String_destroy(&s);
if (err) return Value_new_ERROR(value,IOERROR,FS_errmsg);
return (struct Value*)0;
}
/*}}}*/
int Program_lineNumberWidth(struct Program *this) /*{{{*/
{
int i,w=0;
for (i=0; i<this->size; ++i) if (this->code[i]->type==T_INTEGER)
{
int nw,ln;
for (ln=this->code[i]->u.integer,nw=1; ln/=10; ++nw);
if (nw>w) w=nw;
}
return w;
}
/*}}}*/
struct Value *Program_list(struct Program *this, int dev, int watchIntr, struct Pc *from, struct Pc *to, struct Value *value) /*{{{*/
{
int i,w;
int indent=0;
struct String s;
w=Program_lineNumberWidth(this);
for (i=0; i<this->size; ++i)
{
String_new(&s);
Token_toString(this->code[i],(struct Token*)0,&s,&indent,w);
if ((from==(struct Pc *)0 || from->line<=i) && (to==(struct Pc*)0 || to->line>=i))
{
if (FS_putString(dev,&s)==-1) return Value_new_ERROR(value,IOERROR,FS_errmsg);
if (watchIntr && FS_intr) return Value_new_ERROR(value,BREAK);
}
String_destroy(&s);
}
return (struct Value*)0;
}
/*}}}*/
struct Value *Program_analyse(struct Program *this, struct Pc *pc, struct Value *value) /*{{{*/
{
int i;
for (i=0; i<this->size; ++i)
{
pc->token=this->code[i];
pc->line=i;
if (pc->token->type==T_INTEGER || pc->token->type==T_UNNUMBERED) ++pc->token;
for (;;)
{
if (pc->token->type==T_GOTO || pc->token->type==T_RESUME || pc->token->type==T_RETURN || pc->token->type==T_END || pc->token->type==T_STOP)
{
++pc->token;
while (pc->token->type==T_INTEGER)
{
++pc->token;
if (pc->token->type==T_COMMA) ++pc->token;
else break;
}
if (pc->token->type==T_COLON)
{
++pc->token;
switch (pc->token->type)
{
case T_EOL:
case T_DEFPROC:
case T_SUB:
case T_DEFFN:
case T_FUNCTION:
case T_COLON:
case T_REM:
case T_QUOTE: break; /* those are fine to be unreachable */
default: return Value_new_ERROR(value,UNREACHABLE);
}
}
}
if (pc->token->type==T_EOL) break;
else ++pc->token;
}
}
return (struct Value*)0;
}
/*}}}*/
void Program_renum(struct Program *this, int first, int inc) /*{{{*/
{
int i;
struct Token *token;
for (i=0; i<this->size; ++i)
{
for (token=this->code[i]; token->type!=T_EOL; )
{
if (token->type==T_GOTO || token->type==T_GOSUB || token->type==T_RESTORE || token->type==T_RESUME || token->type==T_USING)
{
++token;
while (token->type==T_INTEGER)
{
struct Pc dst;
if (Program_goLine(this,token->u.integer,&dst)) token->u.integer=first+dst.line*inc;
++token;
if (token->type==T_COMMA) ++token;
else break;
}
}
else ++token;
}
}
for (i=0; i<this->size; ++i)
{
assert(this->code[i]->type==T_INTEGER || this->code[i]->type==T_UNNUMBERED);
this->code[i]->type=T_INTEGER;
this->code[i]->u.integer=first+i*inc;
}
this->numbered=1;
this->runnable=0;
this->unsaved=1;
}
/*}}}*/
void Program_unnum(struct Program *this) /*{{{*/
{
char *ref;
int i;
struct Token *token;
ref=malloc(this->size);
memset(ref,0,this->size);
for (i=0; i<this->size; ++i)
{
for (token=this->code[i]; token->type!=T_EOL; ++token)
{
if (token->type==T_GOTO || token->type==T_GOSUB || token->type==T_RESTORE || token->type==T_RESUME)
{
++token;
while (token->type==T_INTEGER)
{
struct Pc dst;
if (Program_goLine(this,token->u.integer,&dst)) ref[dst.line]=1;
++token;
if (token->type==T_COMMA) ++token;
else break;
}
}
}
}
for (i=0; i<this->size; ++i)
{
assert(this->code[i]->type==T_INTEGER || this->code[i]->type==T_UNNUMBERED);
if (!ref[i])
{
this->code[i]->type=T_UNNUMBERED;
this->numbered=0;
}
}
free(ref);
this->runnable=0;
this->unsaved=1;
}
/*}}}*/
int Program_setname(struct Program *this, const char *filename) /*{{{*/
{
if (this->name.length) String_delete(&this->name,0,this->name.length);
if (filename) return String_appendChars(&this->name,filename);
else return 0;
}
/*}}}*/
/*
The list of line numbers is circular, which avoids the need to have one
extra pointer for the head (for ordered output). Instead only a pointer
to the tail is needed. The tail's next element is the head of the list.
tail --> last element <-- ... <-- first element <--,
\ /
\_________________________________/
*/
struct Xref
{
const void *key;
struct LineNumber
{
struct Pc line;
struct LineNumber *next;
} *lines;
struct Xref *l,*r;
};
static void Xref_add(struct Xref **root, int (*cmp)(const void*,const void*), const void *key, struct Pc *line) /*{{{*/
{
int res;
struct LineNumber **tail;
struct LineNumber *new;
while (*root && (res=cmp(key,(*root)->key))) root=(res<0)?&(*root)->l:&(*root)->r;
if (*root==(struct Xref*)0)
{
*root=malloc(sizeof(struct Xref));
(*root)->key=key;
(*root)->l=(*root)->r=(struct Xref*)0;
/* create new circular list */
(*root)->lines=new=malloc(sizeof(struct LineNumber));
new->line=*line;
new->next=new;
}
else
{
/* add to existing circular list */
tail=&(*root)->lines;
if ((*tail)->line.line!=line->line)
{
new=malloc(sizeof(struct LineNumber));
new->line=*line;
new->next=(*tail)->next;
(*tail)->next=new;
*tail=new;
}
}
}
/*}}}*/
static void Xref_destroy(struct Xref *root) /*{{{*/
{
if (root)
{
struct LineNumber *cur,*next,*tail;
Xref_destroy(root->l);
Xref_destroy(root->r);
cur=tail=root->lines;
do
{
next=cur->next;
free(cur);
cur=next;
} while (cur!=tail);
free(root);
}
}
/*}}}*/
static void Xref_print(struct Xref *root, void (*print)(const void *key, struct Program *p, int chn), struct Program *p, int chn) /*{{{*/
{
if (root)
{
const struct LineNumber *cur,*tail;
Xref_print(root->l,print,p,chn);
print(root->key,p,chn);
cur=tail=root->lines;
do
{
char buf[128];
cur=cur->next;
if (FS_charpos(chn)>72) FS_putChars(chn,"\n ");
sprintf(buf," %ld",Program_lineNumber(p,&cur->line));
FS_putChars(chn,buf);
} while (cur!=tail);
FS_putChar(chn,'\n');
Xref_print(root->r,print,p,chn);
}
}
/*}}}*/
static int cmpLine(const void *a, const void *b) /*{{{*/
{
const register struct Pc *pcA=(const struct Pc*)a,*pcB=(const struct Pc*)b;
return pcA->line-pcB->line;
}
/*}}}*/
static void printLine(const void *k, struct Program *p, int chn) /*{{{*/
{
char buf[80];
sprintf(buf,"%8ld",Program_lineNumber(p,(const struct Pc*)k));
FS_putChars(chn,buf);
}
/*}}}*/
static int cmpName(const void *a, const void *b) /*{{{*/
{
const register char *funcA=(const char*)a,*funcB=(const char*)b;
return strcmp(funcA,funcB);
}
/*}}}*/
static void printName(const void *k, struct Program *p, int chn) /*{{{*/
{
size_t len=strlen((const char*)k);
FS_putChars(chn,(const char*)k);
if (len<8) FS_putChars(chn," "+len);
}
/*}}}*/
void Program_xref(struct Program *this, int chn) /*{{{*/
{
struct Pc pc;
struct Xref *func,*var,*gosub,*goto_;
int nl=0;
assert(this->runnable);
func=(struct Xref*)0;
var=(struct Xref*)0;
gosub=(struct Xref*)0;
goto_=(struct Xref*)0;
for (pc.line=0; pc.line<this->size; ++pc.line)
{
struct On *on;
for (on=(struct On*)0,pc.token=this->code[pc.line]; pc.token->type!=T_EOL; ++pc.token)
{
switch (pc.token->type)
{
case T_ON: /*{{{*/
{
on=&pc.token->u.on;
break;
}
/*}}}*/
case T_GOTO: /*{{{*/
{
if (on)
{
int key;
for (key=0; key<on->pcLength; ++key) Xref_add(&goto_,cmpLine,&on->pc[key],&pc);
on=(struct On*)0;
}
else Xref_add(&goto_,cmpLine,&pc.token->u.gotopc,&pc);
break;
}
/*}}}*/
case T_GOSUB: /*{{{*/
{
if (on)
{
int key;
for (key=0; key<on->pcLength; ++key) Xref_add(&gosub,cmpLine,&on->pc[key],&pc);
on=(struct On*)0;
}
else Xref_add(&gosub,cmpLine,&pc.token->u.gosubpc,&pc);
break;
}
/*}}}*/
case T_DEFFN:
case T_DEFPROC:
case T_FUNCTION:
case T_SUB: /*{{{*/
{
++pc.token;
Xref_add(&func,cmpName,&pc.token->u.identifier->name,&pc);
break;
}
/*}}}*/
default: break;
}
}
}
for (pc.line=0; pc.line<this->size; ++pc.line)
{
for (pc.token=this->code[pc.line]; pc.token->type!=T_EOL; ++pc.token)
{
switch (pc.token->type)
{
case T_DEFFN:
case T_DEFPROC:
case T_FUNCTION:
case T_SUB: /* skip identifier already added above */ /*{{{*/
{
++pc.token;
break;
}
/*}}}*/
case T_IDENTIFIER: /*{{{*/
{
/* formal parameters have no assigned symbol */
if (pc.token->u.identifier->sym) switch (pc.token->u.identifier->sym->type)
{
case GLOBALVAR:
{
Xref_add(&var,cmpName,&pc.token->u.identifier->name,&pc);
break;
}
case USERFUNCTION:
{
Xref_add(&func,cmpName,&pc.token->u.identifier->name,&pc);
break;
}
default: break;
}
break;
}
/*}}}*/
default: break;
}
}
}
if (func)
{
FS_putChars(chn,_("Function Referenced in line\n"));
Xref_print(func,printName,this,chn);
Xref_destroy(func);
nl=1;
}
if (var)
{
if (nl) FS_putChar(chn,'\n');
FS_putChars(chn,_("Variable Referenced in line\n"));
Xref_print(var,printName,this,chn);
Xref_destroy(func);
nl=1;
}
if (gosub)
{
if (nl) FS_putChar(chn,'\n');
FS_putChars(chn,_("Gosub Referenced in line\n"));
Xref_print(gosub,printLine,this,chn);
Xref_destroy(gosub);
nl=1;
}
if (goto_)
{
if (nl) FS_putChar(chn,'\n');
FS_putChars(chn,_("Goto Referenced in line\n"));
Xref_print(goto_,printLine,this,chn);
Xref_destroy(goto_);
nl=1;
}
}
/*}}}*/
Reference in New Issue View Git Blame Copy Permalink