static void disallowoverlap(IDTEM * head){
if(head == NULL){return ;}else{
disallowoverlap(head->next);
disallowoverlap(head->forward);
}
if(head->overlap == DISALLOW){
if(head->forward != NULL){
}else{
head->forward = malloc(sizeof(IDTEM));
memset(head->forward,0,sizeof(IDTEM));
head->forward->backward = head ;
head->forward->name = malloc(strlen(head->name)+1);
strcpy(head->forward->name ,head->name);
head->forward->overlap = UNSPECIFIED ;
}
if(head->previous != NULL)
head->previous->next = head->forward ;
if(head->next != NULL)
head->next->previous = head->forward ;
head->forward->previous = head->previous ;
head->forward->next = head->next ;
head->previous = head->next = NULL ;
setcur(head->forward);
}
if(head->overlap != UNSPECIFIED){
head->overlap -= 1;
}
}
void KontextListList::delete_cur_context()
{
if (empty())
return;
unsigned idx = cur();
delete *cc;
erase(cc);
if (idx >= size())
idx = 0;
setcur(idx);
}
void clrscreen()
{
/* Declare the variables to be used */
union REGS inreg,outreg; // input,output registers
setcur(0,0);
inreg.h.ah = 10;
inreg.h.bh = 0;
inreg.x.cx = 2048;
inreg.h.al = ' ';
int86 (0x10,&inreg,&outreg);
} // End of clrscreen().
/* mode: ('A') append
* ('R') replace one or more different characters
* ('r') replace 1 character
* ('i') insert characters
* ('a') insert after cursor
* a precount can be used
*
* for insert and append we misuse the undo buffer for the inserted
* characters (for "." command)
*/
off_t edit(int mode)
{
int ch, ch1;
size_t len;
off_t count = 0L;
off_t buffer = BUFFER;
off_t psize;
if(!filesize && mode == 'i') {
mode = 'A';
}
if(mode != 'A' && mode != 'a') {
if(current - mem >= filesize) {
beep();
return 0L;
}
}
if(precount < 1) {
precount = 1;
}
len = strlen(rep_buf);
if(mode == 'r' && current + precount > maxpos) {
beep();
rep_buf[len] = '\0';
return 0L;
}
if(alloc_buf(buffer, &undo_buf) == 0L) {
rep_buf[len] = '\0';
return 0L;
}
switch(mode) {
case 'A':
edits = U_APPEND;
break;
case 'R':
edits = U_EDIT;
smsg("REPLACE MODE");
break;
case 'r':
edits = U_EDIT;
smsg("REPLACE 1 CHAR");
break;
case 'a':
case 'i':
edits = U_INSERT;
smsg("INSERT MODE");
break;
}
undo_start = current;
while((ch = vgetc()) != ESC) {
ch &= 0xff;
rep_buf[len++] = ch;
if(ch == '\t') {
toggle();
setcur();
continue;
}
if(ch == KEY_BACKSPACE || ch == ASCII_DEL || ch == BVICTRL('H')) {
if(count > 0) {
len--;
count--;
if(mode == 'A' || mode == 'a' || mode == 'i') {
filesize--;
maxpos--;
}
current--;
cur_back();
setcur();
} else {
beep();
}
continue;
}
if(loc == HEX) {
if(isxdigit(ch)) {
mvaddch(y, x + 1, ' ');
mvaddch(y, x, ch);
do {
ch1 = vgetc() & 0xff;
if(ch1 == ESC) {
mvaddch(y, x, ' ');
current--;
cur_back();
goto escape;
}
if(!isxdigit(ch1)) {
beep();
ch1 = -1;
}
} while(ch1 == -1);
rep_buf[len++] = ch1;
mvaddch(y, x + 1, ch1);
sprintf(tmpbuf, "%c%c", ch, ch1);
sscanf(tmpbuf, "%2x", &ch);
} else {
beep();
len--;
goto wrong;
}
} else { /*** ASCII - Bereich ***/
if(isprint(ch)) {
mvaddch(y, x, ch);
} else {
beep();
goto wrong;
}
}
curpos = current++;
if(mode == 'i' || mode == 'a') {
memmove(current, curpos, maxpos - curpos);
}
if(mode == 'A' || mode == 'i' || mode == 'a') {
maxpos++;
filesize++;
/* NEU
undo_buf[count++] = ch;
*/
count++;
} else {
undo_buf[count++] = *curpos;
}
if(count == buffer) {
buffer += BUFFER;
if(alloc_buf(buffer, &undo_buf) == 0L) {
rep_buf[len] = '\0';
return count;
}
}
*curpos = (char)ch;
cur_forw(0);
statpos();
if(mode == 'i' || mode == 'a') {
repaint();
} else {
lineout();
}
setcur();
if(filesize > memsize - 2L) {
if(enlarge(100L)) {
break;
}
}
if((mode != 'A' && mode != 'a') && curpos == maxpos - 1) {
break;
}
if(mode == 'r') {
break;
}
wrong:
continue;
}
rep_buf[len++] = ESC;
rep_buf[len] = '\0';
if(!count) {
goto escape;
}
if(precount > 1) {
switch(mode) {
case 'i':
case 'a':
case 'A':
psize = count * (precount - 1);
if(filesize + psize > memsize - 2L) {
if(enlarge(psize + 100L)) {
return count;
}
}
if(psize + count > buffer) {
if(alloc_buf(psize + count, &undo_buf) == 0L) {
return count;
}
}
if(mode == 'i' || mode == 'a') {
memmove(current + psize, current, maxpos - curpos);
}
/* NEU
undo_pos = undo_buf + count - 1L;
*/
while(--precount) {
/* NEU
memcpy(undo_pos + 1L, undo_pos - count + 1L, count);
undo_pos += count;
*/
memcpy(curpos + 1L, curpos - count + 1L, count);
curpos += count;
}
filesize += psize;
count += psize;
maxpos += psize;
undo_count += psize;
current = curpos + 1L;
setpage(current);
repaint();
break;
case 'R':
if(current + count * (precount - 1) > maxpos) {
break;
}
psize = count;
while(--precount) {
memcpy(undo_buf + psize, curpos + 1L, count);
psize += count;
memcpy(curpos + 1L, curpos - count + 1L, count);
curpos += count;
}
count = psize;
setpage(++curpos);
repaint();
break;
case 'r':
while(--precount) {
undo_buf[count++] = *(++curpos);
*curpos = (char)ch;
cur_forw(0);
statpos();
lineout();
}
break;
}
}
cur_back();
escape:
setcur();
smsg("");
return(count);
}
static FILE *alsaSelectPcmOut(struct modlistentry *entry)
{
char *t;
int card, device;
if (!strcmp(entry->name, "default.dev"))
{
strcpy(alsaCardName, "default");
} else if (!strcmp(entry->name, "custom.dev"))
{
int mlTop=mlDrawBox();
char str[DEVICE_NAME_MAX+1];
unsigned int curpos;
unsigned int cmdlen;
int insmode=1;
unsigned int scrolled=0;
strcpy(str, alsaCardName);
displaystr(mlTop+1, 5, 0x0b, "Give me something to crunch!!", 29);
displaystr(mlTop+3, 5, 0x0b, "-- Finish with enter, abort with escape --", 32);
curpos=strlen(str);
cmdlen=strlen(str);
setcurshape(1);
while (1)
{
uint16_t key;
displaystr(mlTop+2, 5, 0x8f, str+scrolled, plScrWidth-10);
setcur(mlTop+2, 5+curpos-scrolled);
while (!ekbhit())
framelock();
key=egetch();
if ((key>=0x20)&&(key<=0x7f))
{
if (insmode)
{
if ((cmdlen+1)<sizeof(str))
{
memmove(str+curpos+1, str+curpos, cmdlen-curpos+1);
str[curpos++]=key;
cmdlen++;
}
} else if (curpos==cmdlen)
{
if ((cmdlen+1)<(sizeof(str)))
{
str[curpos++]=key;
str[curpos]=0;
cmdlen++;
}
} else
str[curpos++]=key;
} else switch (key)
{
case KEY_ESC:
setcurshape(0);
return NULL;
case KEY_LEFT:
if (curpos)
curpos--;
break;
case KEY_RIGHT:
if (curpos<cmdlen)
curpos++;
break;
case KEY_HOME:
curpos=0;
break;
case KEY_END:
curpos=cmdlen;
break;
case KEY_INSERT:
{
insmode=!insmode;
setcurshape(insmode?1:2);
}
break;
case KEY_DELETE:
if (curpos!=cmdlen)
{
memmove(str+curpos, str+curpos+1, cmdlen-curpos);
cmdlen--;
}
break;
case KEY_BACKSPACE:
if (curpos)
{
memmove(str+curpos-1, str+curpos, cmdlen-curpos+1);
curpos--;
cmdlen--;
}
break;
case _KEY_ENTER:
strcpy(alsaCardName, str);
setcurshape(0);
goto out;
}
while ((curpos-scrolled)>=(plScrWidth-10))
scrolled+=8;
while (((signed)curpos-(signed)scrolled)<0)
scrolled-=8;
}
} else {
if (!(t=strchr(entry->name, ':')))
return NULL;
card=atoi(t+1);
if (!(t=strchr(entry->name, ',')))
return NULL;
device=atoi(t+1);
snprintf(alsaCardName, sizeof(alsaCardName), "plughw:%d,%d", card, device);
snprintf(alsaMixerName, sizeof(alsaMixerName), "hw:%d", card);
}
out:
/* #ifdef ALSA_DEBUG */
fprintf(stderr, "ALSA: Selected card %s\n", alsaCardName);
/* #endif */
{
if (customfileref!=0xffffffff)
{
struct moduleinfostruct mi;
mdbGetModuleInfo(&mi, customfileref);
snprintf(mi.modname, sizeof(mi.modname), "%s", alsaCardName);
mdbWriteModuleInfo(customfileref, &mi);
}
}
return NULL;
}
docommand() {
register char *p;
register int i;
register ADDR addr, bkaddr;
struct proct *procp;
char s[4];
cntval = 1;
adrflg = 0;
errflg = 0;
if (scallf) {
doscall();
setcur(1);
lastcom = NOCOM;
return;
}
if (reflag) { /* search for regular expression */
dore();
lastcom = PRCOM;
return;
}
if (cmd == '\0') {
if (integ != 0 && var[0] != '\0') {
error("Invalid command (1)");
return;
}
if (integ != 0) { /* print line number */
ffind(integ);
fprint();
lastcom = PRCOM;
return;
}
if (var[0] != 0) {
printf("Unexpected null command\n");
return;
}
}
switch (cmd) {
case 'Y':
debug = !debug;
break;
case 'V':
version();
break;
case 'M':
if (args[0]) {
setmap(args);
} else {
printmap("? map", &txtmap);
printmap("/ map", &datmap);
}
break;
case 'x':
printregs();
break;
case 'X':
printpc();
break;
case 'a':
if (integ) {
cpstr(args, "l\n");
} else if (proc[0]) {
cpall(args, "T\n");
} else {
error("Bad arguments");
break;
}
goto setbrk;
break;
case 'l':
setcur(1);
lastcom = NOCOM;
break;
case 'T':
prfrx(1);
lastcom = NOCOM;
break;
case 't':
prframe();
lastcom = NOCOM;
break;
case 'e':
p = args;
if (*p == '\0') {
#ifndef FLEXNAMES
printf("%.16s() in \"%s\"\n",
curproc()->pname, curfile);
#else
printf("%s() in \"%s\"\n",
curproc()->pname, curfile);
#endif
break;
}
while (*p != '\0')
if (*p++ == '.') goto l1;
/* argument is procedure name */
procp = findproc(args);
if ((procp->pname[0] != '\0') && (procp->sfptr != badfile)) {
finit(adrtofilep(procp->paddr)->sfilename);
ffind(procp->lineno);
}
else printf("Can't find %s\n", args);
#ifndef FLEXNAMES
printf("%.16s() in \"%s\"\n", curproc()->pname, curfile);
#else
printf("%s() in \"%s\"\n", curproc()->pname, curfile);
#endif
lastcom = PRCOM;
break;
l1: /* argument is filename */
finit(args);
printf("\"%s\"\n", curfile);
lastcom = PRCOM;
break;
case 'p':
if (integ) ffind(integ);
fprint();
lastcom = PRCOM;
break;
case 'q':
exit(0);
case 'w':
if (integ) ffind(integ);
i = fline;
fback(WINDOW/2);
fprintn(WINDOW);
ffind(i);
lastcom = PRCOM;
break;
case 'Q':
prdebug();
break;
case 'z':
if (integ) ffind(integ);
fprintn(WINDOW);
lastcom = PRCOM;
break;
case '-':
fback(integ ? integ : 1);
fpargs();
lastcom = PRCOM;
break;
case '+':
fforward(integ ? integ : 1);
fpargs();
lastcom = PRCOM;
break;
case '\n':
switch (lastcom) {
case PRCOM:
fforward(1);
fprint();
break;
case DSCOM:
oaddr += oincr ? oincr : typetosize(otype, WORDSIZE);
printf("0x%x/ ", oaddr);
dispf((ADDR) oaddr, odesc,
oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0, DSP);
break;
case DSICOM:
dot += oincr;
prisploc();
dispi(dot, odesc, N_GSYM, 0, 0);
break;
}
break;
case '\004':
if (!isatty(0))
exit(0);
switch (lastcom) {
case PRCOM:
fforward(1);
printf("\b");
fprintn(WINDOW);
lastcom = PRCOM;
break;
case DSICOM:
printf("\b");
for (i=0; i<WINDOW; i++) {
dot += oincr;
prisploc();
if (dispi(dot, odesc, N_GSYM, 0, 0) == -1)
break;
}
break;
case DSCOM:
printf("\b");
for (i=0; i<WINDOW; i++) {
oaddr += oincr ?
oincr : typetosize(otype, WORDSIZE);
printf("0x%x/ ", oaddr);
if (dispf((ADDR) oaddr, odesc,
oclass == N_RSYM ? oclass :
N_GSYM, otype, 0, 0, DSP) == -1)
break;
}
break;
default:
printf("\n");
}
break;
case 'r':
if (args[0] == '\0') getargs();
case 'R':
signo = 0;
cpstr(oldargs, args);
if (debug) error("calling dopcs");
if (integ) cntval = integ;
if (!executing) {
executing = TRUE;
if (integ) cntval = integ;
dopcs('r');
executing = FALSE;
}
if (debug) error("exiting dopcs");
bkaddr = -1;
goto f1;
case 'c':
signo = 0;
case 'C':
if (proc[0] != '\0' || integ != 0) {
setdot();
if (dot == -1) {
error("Cannot set temporary breakpoint");
break;
}
dopcs('b');
bkaddr = dot;
} else
bkaddr = -1;
integ = atoi(args);
f1: if (debug) error("calling dopcs");
if (integ) cntval = integ;
dopcs('c');
if (debug) error("exiting dopcs");
if (bkaddr != -1) {
ADDR dotsave;
dotsave = dot;
dot = bkaddr;
dopcs('d');
dot = dotsave;
}
if (!signo) printf("Breakpoint");
printf(" at\n");
setcur(1);
lastcom = NOCOM;
break;
case 'S':
case 's':
signo = 0;
integ = atoi(args);
singstep(integ ? integ : 1, cmd);
if (signo) printf("\n");
setcur(1);
lastcom = NOCOM;
break;
case 'g':
if (pid == 0 || signo) {
error("Not stopped at breakpoint");
break;
}
setdot();
if (dot == -1) {
error("Bad address");
break;
}
adrflg = 1;
integ = atoi(args);
if (integ) cntval = integ;
dopcs('c');
if (!signo) printf("Breakpoint");
printf(" at\n");
setcur(1);
lastcom = NOCOM;
break;
case 'k':
if (scallx) {
userpc = dot = *(ADDR *)(((ADDR)&u)+PC) = pcs;
*(ADDR *)(((ADDR)&u)+FP) = fps;
*(ADDR *)(((ADDR)&u)+AP) = aps;
if (bkpts)
bkpts->flag = flagss;
scallx = 0;
error("Procedure killed");
longjmp(env, 0);
} else {
dopcs('k');
printf("\n");
lastcom = NOCOM;
break;
}
case 'B':
prbkpt();
break;
case 'b':
setbrk:
if (proc[0] == '\0' && integ == 0) {
integ = fline;
}
setdot();
if (dot == -1 || dot == 0) {
error("Cannot set breakpoint");
break;
}
dopcs('b');
s[0] = ' ';
s[1] = cmd;
s[2] = '\n';
s[3] = 0;
s[1] = cmd;
printbkpt(s, adrtoprocp(dot), dot);
break;
case 'd':
if (proc[0] == '\0' && integ == 0) {
idbkpt();
break;
}
setdot();
if (dot == -1) {
error("Non existent breakpoint");
break;
}
dopcs('d');
break;
case 'D':
dabkpt();
error("All breakpoints deleted");
break;
case 'm':
addr = varaddr(proc[0] ? proc : curproc()->pname, var);
printf("stopped with value %d\n", monex(addr, 'd'));
setcur(1);
lastcom = NOCOM;
break;
case '?':
if (!(var[0] == '.' && var[1] == '\0'))
setdot();
if (errflg) {
error(errflg);
break;
}
prisploc();
dispi(dot, args[0] ? args : "i", N_GSYM, 0, 0);
lastcom = DSICOM;
break;
case '/':
if (var[0] == '.' && var[1] == '\0') {
if (integ == 0) integ = oaddr;
dispf((ADDR) integ, args[0] ? args : odesc,
oclass == N_RSYM ? oclass : N_GSYM, otype, 0, 0, DSP);
oaddr = integ;
} else
if (integ && (var[0] == '\0')) {
dispf((ADDR) integ, args, N_GSYM, 0, 0, 0, DSP);
oaddr = integ;
cpstr(odesc, args);
oclass = N_GSYM;
otype = 0;
} else
dispvar(proc, var, args);
lastcom = DSCOM;
break;
case '=':
if (var[0] == '\0') {
if (proc[0]) {
addr = getaddr(proc, integ);
if (addr == -1) {
error("Unknown address");
break;
}
}
else
addr = integ;
dispf(addr, args[0] ? args : "x", 0, -1, 0, 0, DSP);
} else
findvar(proc, var, args[0] ? args : "x", 2);
break;
case '!':
if (var[0] == '\0')
addr = getaddr(proc, integ);
else
addr = varaddr(proc, var);
if (addr == -1)
error("Unknown variable");
else {
if (number(args[0]) || eqany(args[0], ".-")) {
char *p;
double atof();
union {
struct{
int w1, w2;
} ww;
double d;
} dbl;
p = (args[0] == '-') ? args+1 : args;
for (; *p != '.' && *p != 'e'; p++) {
if (!number(*p)) goto l2;
}
dbl.d = atof(args);
putval(addr, 'd', dbl.ww.w1);
if (typetodesc(sl_type,0)[0] == 'g')
putval(addr+WORDSIZE, 'd', dbl.ww.w2);
break;
}
l2: if (percentflag)
*(ADDR *)(((ADDR)&u)+addr) = argvalue(args);
else if (sl_class == N_RSYM && addr < 16)
putreg(addr,typetodesc(sl_type,subflag)[0],
argvalue(args));
else
putval(addr,typetodesc(sl_type,subflag)[0],
argvalue(args));
}
lastcom = NOCOM;
break;
case '"':
printf(args);
break;
}
}
static int addvar(int kind,NODE* idnode){
IDTEM* tid = ((IDTEM*)idnode->value.type_p)->cur ;
NODE* head = idnode->parent ;//VarDec
switch(tid->overlap){
IDTEM* newid ;
case ALLOW:
newid = malloc(sizeof(IDTEM));
memcpy(newid,tid,sizeof(IDTEM));
newid->cur = newid ;
if(newid->next != NULL)
newid->next->previous = newid ;
if(newid->previous != NULL)
newid->previous->next = newid ;
tid->next = tid->previous = NULL;
tid->backward = newid ;
newid->forward = tid ;
tid = newid ;
setcur(newid);
case UNSPECIFIED:
tid->overlap = DISALLOW ;
tid->kind = kind ;
switch(kind){
case VARIABLE_KIND:
tid->u.t = head->attr ;
break ;
case STRUCTUREFIELD_KIND:
if(head->next_sister == NULL){
}else if(head->next_sister->name == terminal_name[ASSIGNOP - WHILE]){
error("initialize a field of a struct",15,idnode->line);
break ;
}else if(head->next_sister->name == terminal_name[LB - WHILE]){
}else{
perror("unknown error: impossible nest_sister in addvar");
exit(EXIT_FAILURE);
}
tid->u.structurefieldtype.structure = idnode->attr ;
tid->u.structurefieldtype.t = head->attr;
{
Type* structuretype = idnode->attr ;
if(structuretype->u.structure.field == NULL){
structuretype->u.structure.field = malloc(sizeof(FieldList));
memset(structuretype->u.structure.field,0,sizeof(FieldList));
structuretype->u.structure.field->type = tid->u.structurefieldtype.t ;
structuretype->u.structure.field->name = tid->name ;
}else{
FieldList* fieldlist = structuretype->u.structure.field ;
if(fieldlist->tail != NULL){
fieldlist = fieldlist->tail ;
}
fieldlist->tail = malloc(sizeof(FieldList));
memset(fieldlist->tail,0,sizeof(FieldList));
fieldlist->tail->type = tid->u.structurefieldtype.t ;
fieldlist->tail->name = tid->name ;
}
}
break ;
default:
perror("unknown error :unknown kind");
exit(EXIT_FAILURE);
break ;
}
break;
case DISALLOW:
if(kind == VARIABLE_KIND){
error("Symbol redeclared as variable",3,head->child_head->line);
}else if(kind == STRUCTUREFIELD_KIND){
error("Symbol redeclared as variable in a struct defination",15,head->child_head->line);
}
break;
default:
perror("unknown error :unknown overlap state");
exit(EXIT_FAILURE);
break;
}
idnode->value.type_p = tid ;
}
