/*
* Evaluate an expression.
*/
double
eval(void)
{
double val;
double rop;
int c;
if ((c=getnb())=='+' || c=='-') {
val = primary();
if (c == '-')
val = -val;
} else {
--ctp;
val = primary();
}
while ((c=getnb())=='+' || c=='-') {
rop = primary();
if (c == '+')
val = val + rop;
else
val = val - rop;
}
--ctp;
return (val);
}
struct sym *
getsym(void)
{
int c;
char id[NID];
char *cp;
struct sym *sp;
int subs = 0, type;
int ix;
if (isalpha(c = getnb()) == 0)
diag("Missing variable");
cp = &id[0];
do {
if (cp < &id[NID-1])
*cp++ = c;
c = *ctp++;
} while (isalnum(c));
*cp = 0;
type = S_SCAL;
while (c==' ' || c=='\t')
c = *ctp++;
if (c == '(') {
type = S_ARRAY;
subs = (int) eval();
if (getnb() != ')')
diag("Bad subscript");
} else
--ctp;
if ((sp=lookup(id, type, subs)) == NULL) {
sp = allocsym(id);
if (sp == NULL)
diag("Out of space (symbols)");
ix = hashsym(id, type, subs);
sp->s_fp = sym[ix];
sym[ix] = sp;
sp->s_type = type;
sp->s_subs = subs;
}
return (sp);
}
a_uint
eval()
{
int c, v;
a_uint n;
c = getnb();
n = 0;
while ((v = digit(c, radix)) >= 0) {
n = n*radix + v;
c = get();
}
unget(c);
return((n & s_mask) ? n | ~v_mask : n & v_mask);
}
/*
* Enter admode() to search a specific addressing mode table
* for a match. Return the addressing value on a match or
* -1 for no match.
*/
int
admode(struct adsym *sp)
{
char *ptr;
int i;
unget(getnb());
i = 0;
while ( *(ptr = &sp[i].a_str[0]) ) {
if (srch(ptr)) {
return(sp[i].a_val);
}
i++;
}
return(-1);
}
double
primary(void)
{
double val;
double rop;
int c;
val = term();
while ((c = getnb())=='*' || c=='/' || c=='^') {
rop = term();
if (c == '*')
val = val * rop;
else if (c == '/')
val = val / rop;
else
val = pow(val, rop);
}
--ctp;
return (val);
}
/*
* Process the library command.
* This command (sadly) requires a rather
* detailed knowledge of the file system of
* the operating system.
*/
void library(void)
{
char *p;
int c;
int d;
char *sctp;
struct line *lp1;
struct line *lp2;
FILE *fp;
c = getnb();
if (c!='c' && c!='s' && c!='l' && c!='d')
diag("Bad library command");
while (isalpha(*ctp))
++ctp;
while ((d = *ctp)==' ' || d=='\t')
++ctp;
if (c!='l' && d==0)
diag("Missing file name");
p = ctp;
while (*ctp != 0)
++ctp;
switch (c) {
case 'c':
if ((fp=fopen(p, "r")) == NULL)
diag("Cannot open");
lp1 = line;
while (lp1 != NULL) {
lp2 = lp1->l_fp;
freeline(lp1);
lp1 = lp2;
}
line = NULL;
sctp = ctp;
while (focal_getline(abuf, fp) != 0) {
ctp = abuf;
if ((c=getnb()) != 0) {
if (isdigit(c) == 0)
diag("Direct line in call");
inject(c);
}
}
fclose(fp);
ctp = sctp;
break;
case 'd':
if (remove(p) < 0)
diag("Cannot delete");
break;
case 'l':
#ifndef DIR_SUPPORT
diag("Library list not implemented");
#else
{
#ifdef DOS
int attr = _A_RDONLY | _A_ARCH;
int rc;
static struct find_t de;
static char fname[FILENAME_MAX];
char *s;
if (d == 0)
strcpy(fname, "*.*");
else {
strcpy(fname, p);
s = fname + strlen(fname) - 1;
if (*s == '\\')
strcat(fname, "*.*");
else if (*s == '.')
strcat(fname, "\\*.*");
}
rc = _dos_findfirst(fname, attr, &de);
while (!rc) {
if ((de.attrib & _A_SUBDIR) == 0
&& strcmp(de.name, ".") != 0
&& strcmp(de.name, "..") != 0)
printf("%-13s\n", de.name);
rc = _dos_findnext(&de);
}
#else
#ifdef DIRENT
struct dirent *de;
DIR *dp;
if (d == 0)
p = ".";
if ((dp = opendir(p)) == NULL) {
perror("focal");
diag("Bad directory");
}
while ((de = readdir(dp)) != NULL) {
if (de->d_ino == 0
|| strcmp(de->d_name, ".") == 0
|| strcmp(de->d_name, "..") == 0)
continue;
printf("%s\n", de->d_name);
}
closedir(dp);
#else
int fd = 0;
if (d == 0)
p = ".";
if (stat(p, &sb) < 0
|| (sb.st_mode&S_IFMT) != S_IFDIR
|| (fd = open(p, 0)) < 0)
diag("Bad directory");
while (read(fd, &db, sizeof(db)) == sizeof(db)) {
if (db.d_ino == 0
|| strncmp(db.d_name, ".", DIRSIZ) == 0
|| strncmp(db.d_name, "..", DIRSIZ) == 0)
continue;
printf("%.*s\n", DIRSIZ, db.d_name);
}
close(fd);
#endif
#endif
}
#endif
break;
case 's':
if ((fp=fopen(p, "w")) == NULL)
diag("Cannot create");
save(NULL, fp);
fclose(fp);
break;
}
}
/*
* Find/Create a global symbol entry.
*
* S xxxxxx Defnnnn
* | | |
* | | `-- sp->s_addr
* | `----- sp->s_type
* `------------ sp->s_id
*
*/
struct sym *
newsym()
{
a_uint ev;
int c, i, nsym;
struct sym *tsp;
struct sym **s;
char id[NCPS];
if (headp == NULL) {
fprintf(stderr, "No header defined\n");
lkexit(ER_FATAL);
}
/*
* Create symbol entry
*/
getid(id, -1);
tsp = lkpsym(id, 1);
c = getnb();get();get();
if (c == 'R') {
tsp->s_type |= S_REF;
if (eval()) {
fprintf(stderr, "Non zero S_REF\n");
lkerr++;
}
} else
if (c == 'D') {
ev = eval();
if (tsp->s_type & S_DEF) {
if (tsp->s_addr != ev) {
fprintf(stderr,
"Multiple definition of %s\n", id);
lkerr++;
}
} else {
/*
* Set value and area extension link.
*/
tsp->s_addr = ev;
tsp->s_axp = axp;
tsp->s_type |= S_DEF;
tsp->m_id = hp->m_id;
}
} else {
fprintf(stderr, "Invalid symbol type %c for %s\n", c, id);
lkexit(ER_FATAL);
}
/*
* Place pointer in header symbol list
*/
nsym = hp->h_nsym;
s = hp->s_list;
for (i=0; i < nsym ;++i) {
if (s[i] == NULL) {
s[i] = tsp;
return(tsp);
}
}
fprintf(stderr, "Header symbol list overflow\n");
lkexit(ER_FATAL);
return(NULL);
}
double
term(void)
{
int c;
char *cp;
double val;
int fsign;
int fdot;
int fexp;
int type;
int subs = 0;
struct sym *sp;
char id[NID];
char nbuf[20];
if ((c = getnb())=='(' || c=='[' || c=='<') {
val = eval();
if (++c != ')')
++c;
if (c != getnb())
diag("Mismatched enclosures");
return (val);
}
if (c=='.' || isdigit(c)) {
fsign = 1;
fexp = 0;
fdot = 0;
if (c == '.')
++fdot;
cp = &nbuf[0];
for (;;) {
if (cp >= &nbuf[19])
diag("Number too long");
*cp++ = c;
if ((c = *ctp++) == '.') {
if (fdot++)
break;
} else if (c == 'e') {
if (fexp++)
break;
fsign = 0;
fdot = 1;
} else if (c=='+' || c=='-') {
if (fsign++)
break;
} else if (!isdigit(c))
break;
}
--ctp;
*cp = '\0';
return (atof(nbuf));
}
if (!isalpha(c))
diag("Expression syntax");
cp = &id[0];
do {
if (cp < &id[NID-1])
*cp++ = c;
c = *ctp++;
} while (isalnum(c));
*cp = 0;
if (id[0]=='f' && (sp=lookup(id, S_FUNC, 0))!=NULL) {
while (c==' ' || c=='\t')
c = *ctp++;
if (c != '(')
diag("Missing `(' for function");
val = eval();
if (getnb() != ')')
diag("Missing `)' for function");
return ((*sp->s_un.s_fp)(val));
}
type = S_SCAL;
while (c==' ' || c=='\t')
c = *ctp++;
if (c == '(') {
type = S_ARRAY;
subs = (int) eval();
if (getnb() != ')')
diag("Missing ) in subscript");
} else
--ctp;
if ((sp=lookup(id, type, subs)) == NULL)
diag("Undefined variable");
return (sp->s_un.s_value);
}
const straintensor& SANISAND_alpha_Eij::Hij(const PlasticFlow& plastic_flow, const stresstensor& Stre,
const straintensor& Stra, const MaterialParameter& material_parameter)
{
// const double rt23 = sqrt(2.0/3.0);
// stresstensor a_a_in;
// double a_in = 0.0;
double e0 = gete0(material_parameter);
double e_r = gete_r(material_parameter);
double lambda = getlambda(material_parameter);
double xi = getxi(material_parameter);
double Pat = getPat(material_parameter);
double alpha_cc = getalpha_cc(material_parameter);
double c = getc(material_parameter);
double nb = getnb(material_parameter);
double h0 = geth0(material_parameter);
double ch = getch(material_parameter);
double G0 = getG0(material_parameter);
double m = getm(material_parameter);
stresstensor alpha = getalpha(material_parameter);
stresstensor n;
stresstensor s_bar;
double norm_s = 0.0;
double r_ef = 0.0;
double cos3theta = 0.0;
double g = 0.0;
double ec = e_r;
double e = e0;
double psi = 0.0;
double alpha_b_c = 0.0;
stresstensor alpha_b_tensor;
stresstensor b_ref;
stresstensor temp_tensor;
double lower = 0.0;
double h = G0*h0;
double p = Stre.p_hydrostatic();
stresstensor s = Stre.deviator();
s_bar = s - (alpha *p);
norm_s = sqrt( (s_bar("ij")*s_bar("ij")).trace() );
if (p > 0.0 && norm_s > 0.0)
{
n = s_bar * (1.0/norm_s);
r_ef = rt32 * norm_s / p;
cos3theta = -3.0 * sqrt(6.0) * n.Jinvariant3();
}
if (p <= 0.0)
cos3theta = 1.0;
if (cos3theta > 1.0)
cos3theta = 1.0;
if (cos3theta < -1.0)
cos3theta = -1.0;
g = getg(c, cos3theta);
if ( p >= 0.0 )
ec = getec(e_r, lambda, xi, Pat, p);
e = e0 + (1.0 + e0) * Stra.Iinvariant1();
psi = e - ec;
alpha_b_c = alpha_cc * exp(-nb*psi);
alpha_b_tensor = n * (rt23 * g * alpha_b_c);
b_ref = n * rt23 * alpha_b_c * (1.0+c);
// b_ref = n * rt23 * alpha_cc * (1.0+c);
// Method 1
temp_tensor = b_ref - (alpha_b_tensor - alpha);
//// Method 2, better to use this when "p" is small
//temp_tensor = b_ref - (alpha_b_tensor - s*(1.0/p));
lower = rt32*(temp_tensor("ij")*n("ij")).trace();
if ( lower>0 )
h = G0 * h0 * (1-ch*e) * sqrt(Pat/p) / (lower*lower);
// h = G0 * h0 * (1-ch*e) * sqrt(Pat/p);
// h = h0;
// Method 1
temp_tensor = alpha_b_tensor - alpha;
// Method 2
//temp_tensor = alpha_b_tensor+n*m - s*(1.0/p);
TensorEvolution::TensorEvolutionHij = temp_tensor * (h*r_ef);
return TensorEvolution::TensorEvolutionHij;
}
/* Classify argument as to address mode */
int
addr(struct expr *esp)
{
int c;
unsigned rd;
if ((c = getnb()) == '#') {
/* Immediate mode */
expr(esp, 0);
esp->e_mode = S_IMMED;
}
else if (c == '@') {
/* choices are @R0, @R1, @DPTR, @A+PC, @A+DPTR */
switch (reg()) {
case R0:
esp->e_mode = S_AT_R;
esp->e_addr = R0;
break;
case R1:
esp->e_mode = S_AT_R;
esp->e_addr = R1;
break;
case DPTR:
esp->e_mode = S_AT_DP;
esp->e_addr = DPTR;
break;
case A:
if (getnb() == '+') {
rd = reg();
if (rd == PC) {
esp->e_mode = S_AT_APC;
esp->e_addr = 0;
} else if (rd == DPTR) {
esp->e_mode = S_AT_ADP;
esp->e_addr = 0;
} else {
aerr();
}
} else
aerr();
break;
}
esp->e_flag = 0;
esp->e_base.e_ap = NULL;
}
else if (c == '*') {
if ((c = getnb()) == '/') {
/* Force inverted bit */
expr(esp, 0);
esp->e_mode = S_NOT_BIT;
} else {
unget(c);
/* Force direct page */
expr(esp, 0);
esp->e_mode = S_DIR;
}
if (esp->e_addr & ~0xFF)
err('d');
}
else if (c == '/') {
/* Force inverted bit */
expr(esp, 0);
esp->e_mode = S_NOT_BIT;
}
else {
unget(c);
/* try for register: A, AB, R0-R7, DPTR, PC, Cy */
if ((esp->e_addr = admode(reg51)) != -1) {
switch (esp->e_addr) {
case A:
esp->e_mode = S_A;
break;
case AB:
esp->e_mode = S_RAB;
break;
case DPTR:
esp->e_mode = S_DPTR;
break;
case PC:
esp->e_mode = S_PC;
break;
case C:
esp->e_mode = S_C;
break;
default:
/* R0-R7 */
esp->e_mode = S_REG;
}
} else {
/* Must be an expression */
esp->e_addr = 0;
expr(esp, 0);
if ((!esp->e_flag)
&& (esp->e_base.e_ap==NULL)
&& !(esp->e_addr & ~0xFF)) {
esp->e_mode = S_DIR;
} else {
esp->e_mode = S_EXT;
}
}
}
return (esp->e_mode);
}
/*
* Process machine ops.
*/
VOID
machine(struct mne *mp)
{
char *p, *str;
char pid[NINPUT], id[NINPUT];
int c, d, t, t1, v1;
a_uint op;
struct sym *sp;
struct expr e, e1, e2;
clrexpr(&e);
clrexpr(&e1);
clrexpr(&e2);
op = mp->m_valu;
switch (mp->m_type) {
case S_CPU:
opcycles = OPCY_CPU;
lmode = SLIST;
switch(op) {
default: op = DS8XCXXX;
case DS8XCXXX: v1 = 2; str = "DS8XCXXX"; sym[2].s_addr = X_DS8XCXXX; break;
case DS80C310: v1 = 2; str = "DS80C310"; sym[2].s_addr = X_DS80C310; break;
case DS80C320: v1 = 2; str = "DS80C320"; sym[2].s_addr = X_DS80C320; break;
case DS80C323: v1 = 2; str = "DS80C323"; sym[2].s_addr = X_DS80C323; break;
case DS80C390: v1 = 3; str = "DS80C390"; sym[2].s_addr = X_DS80C390; break;
case DS83C520: v1 = 2; str = "DS83C520"; sym[2].s_addr = X_DS83C520; break;
case DS83C530: v1 = 2; str = "DS83C530"; sym[2].s_addr = X_DS83C530; break;
case DS83C550: v1 = 2; str = "DS83C550"; sym[2].s_addr = X_DS83C550; break;
case DS87C520: v1 = 2; str = "DS87C520"; sym[2].s_addr = X_DS87C520; break;
case DS87C530: v1 = 2; str = "DS87C530"; sym[2].s_addr = X_DS87C530; break;
case DS87C550: v1 = 2; str = "DS87C550"; sym[2].s_addr = X_DS87C550; break;
case DS______: v1 = 2; str = "DS______"; sym[2].s_addr = X_DS______;
if (more()) {
str = p = pid;
d = getnb();
while ((c = get()) != d) {
if (c == '\0') {
qerr();
}
if (p < &pid[sizeof(pid)-3]) {
*p++ = c;
} else {
break;
}
}
*p = 0;
}
break;
}
if (op != 0) {
ds8_bytes = v1;
exprmasks(v1);
}
mchtyp = (int) op;
sprintf(id, "__%s", str);
sp = lookup(id);
if (sp->s_type != S_NEW && (sp->s_flag & S_ASG) == 0) {
err('m');
}
sp->s_type = S_USER;
sp->s_addr = 1;
sp->s_flag |= S_ASG;
sprintf(buff, "%s %s", DS_CPU, str);
cpu = buff;
sp = lookup("__SFR_BITS");
if (sp->s_type != S_NEW && (sp->s_flag & S_ASG) == 0) {
err('m');
}
sp->s_type = S_USER;
sp->s_flag |= S_ASG;
if (more()) {
expr(&e, 0);
abscheck(&e);
sp->s_addr = e.e_addr;
} else {
sp->s_addr = 1;
}
break;
case S_AMODE:
opcycles = OPCY_AMODE;
if ((mchtyp != 0) && (mchtyp != DS80C390)) {
err('o');
break;
}
expr(&e, 0);
abscheck(&e);
amode = (int) e.e_addr;
if ((amode < 0) || (amode > 2)) {
amode = 0;
err('o');
}
if ((c = getnb()) == ',') {
expr(&e1, 0);
abscheck(&e1);
if (e1.e_addr != 0) {
/* mov ta,#0aah */ outab(0x075); outab(0x0C7); outab(0x0AA);
/* mov ta,#055h */ outab(0x075); outab(0x0C7); outab(0x055);
/* mov acon,#amode */ outab(0x075); outab(0x09D); outab(amode);
} else {
lmode = SLIST;
}
} else {
unget(c);
lmode = SLIST;
}
break;
case S_BITS:
if (ds8_bytes == 0) {
ds8_bytes = (int) op;
exprmasks(ds8_bytes);
} else
if (ds8_bytes != (int) op) {
err('m');
}
opcycles = OPCY_BITS;
lmode = SLIST;
break;
case S_INH:
outab(op);
break;
case S_JMP11:
expr(&e, 0);
if (amode == 2) {
outr3bm(&e, R_J19, op);
} else {
outrwm(&e, R_J11, op);
}
break;
case S_JMP16:
expr(&e, 0);
outab(op);
if (amode == 2) {
outr3b(&e, R_NORM);
} else {
outrw(&e, R_NORM);
}
break;
case S_ACC:
t = addr(&e);
if (t != S_A)
aerr();
outab(op);
break;
case S_TYP1:
/* A, direct, @R0, @R1, R0 to R7. "INC" also allows DPTR */
t = addr(&e);
switch (t) {
case S_A:
outab(op + 4);
break;
case S_DIR:
case S_EXT:
/* Direct is also legal */
outab(op + 5);
outrb(&e, R_PAG0);
break;
case S_AT_R:
outab(op + 6 + e.e_addr);
break;
case S_REG:
outab(op + 8 + e.e_addr);
break;
case S_DPTR:
if (op != 0)
/* only INC (op=0) has DPTR mode */
aerr();
else
outab( 0xA3);
break;
default:
aerr();
}
break;
case S_TYP2:
/* A,#imm; A,direct; A,@R0; A,@R1; A,R0 to A,R7 */
t = addr(&e);
if (t != S_A)
aerr();
comma(1);
t1 = addr(&e1);
switch (t1) {
case S_IMMED:
outab(op + 4);
outrb(&e1, R_NORM);
break;
case S_DIR:
case S_EXT:
outab(op + 5);
outrb(&e1, R_PAG0);
break;
case S_AT_R:
outab(op + 6 + e1.e_addr);
break;
case S_REG:
outab(op + 8 + (e1.e_addr));
break;
default:
aerr();
}
break;
case S_TYP3:
/* dir,A; dir,#imm;
* A,#imm; A,direct; A,@R0; A,@R1; A,R0 to A,R7
* C,direct; C,/direct
*/
t = addr(&e);
comma(1);
t1 = addr(&e1);
switch (t) {
case S_DIR:
case S_EXT:
switch (t1) {
case S_A:
outab(op + 2);
outrb(&e, R_PAG0);
break;
case S_IMMED:
outab(op + 3);
outrb(&e, R_PAG0);
outrb(&e1, R_NORM);
break;
default:
aerr();
}
break;
case S_A:
switch (t1) {
case S_IMMED:
outab(op + 4);
outrb(&e1, R_NORM);
break;
case S_DIR:
case S_EXT:
outab(op + 5);
outrb(&e1, R_PAG0);
break;
case S_AT_R:
outab(op + 6 + e1.e_addr);
break;
case S_REG:
outab(op + 8 + e1.e_addr);
break;
default:
aerr();
}
break;
case S_C:
/* XRL has no boolean version. Trap it */
if (op == 0x60)
aerr();
switch (t1) {
case S_DIR:
case S_EXT:
outab(op + 0x32);
outrb(&e1, R_PAG0);
break;
case S_NOT_BIT:
outab(op + 0x60);
outrb(&e1, R_PAG0);
break;
default:
aerr();
}
break;
default:
aerr();
}
break;
case S_TYP4:
/* A,direct; A,@R0; A,@R1; A,R0 to A,R7 */
t = addr(&e);
if (t != S_A)
aerr();
comma(1);
t1 = addr(&e1);
switch (t1) {
case S_DIR:
case S_EXT:
outab(op + 5);
outrb(&e1, R_PAG0);
break;
case S_AT_R:
outab(op + 6 + e1.e_addr);
break;
case S_REG:
outab(op + 8 + e1.e_addr);
break;
default:
aerr();
}
break;
/* MOV instruction, all modes */
case S_MOV:
t = addr(&e);
comma(1);
t1 = addr(&e1);
switch (t) {
case S_A:
switch (t1) {
case S_IMMED:
outab(0x74);
outrb(&e1, R_NORM);
break;
case S_DIR:
case S_EXT:
outab(0xE5);
outrb(&e1, R_PAG0);
break;
case S_AT_R:
outab(0xE6 + e1.e_addr);
break;
case S_REG:
outab(0xE8 + e1.e_addr);
break;
default:
aerr();
}
break;
case S_REG:
switch (t1) {
case S_A:
outab(0xF8 + e.e_addr);
break;
case S_IMMED:
outab(0x78 + e.e_addr);
outrb(&e1, R_NORM);
break;
case S_DIR:
case S_EXT:
outab(0xA8 + e.e_addr);
outrb(&e1, R_PAG0);
break;
default:
aerr();
}
break;
case S_DIR:
case S_EXT:
switch (t1) {
case S_A:
outab(0xF5);
outrb(&e, R_PAG0);
break;
case S_IMMED:
outab(0x75);
outrb(&e, R_PAG0);
outrb(&e1, R_NORM);
break;
case S_DIR:
case S_EXT:
outab(0x85);
outrb(&e1, R_PAG0);
outrb(&e, R_PAG0);
break;
case S_AT_R:
outab(0x86 + e1.e_addr);
outrb(&e, R_PAG0);
break;
case S_REG:
outab(0x88 + e1.e_addr);
outrb(&e, R_PAG0);
break;
case S_C:
outab(0x92);
outrb(&e, R_PAG0);
break;
default:
aerr();
}
break;
case S_AT_R:
switch (t1) {
case S_IMMED:
outab(0x76 + e.e_addr);
outrb(&e1, R_NORM);
break;
case S_DIR:
case S_EXT:
outab(0xA6 + e.e_addr);
outrb(&e1, R_PAG0);
break;
case S_A:
outab(0xF6 + e.e_addr);
break;
default:
aerr();
}
break;
case S_C:
if ((t1 != S_DIR) && (t1 != S_EXT))
aerr();
outab(0xA2);
outrb(&e1, R_PAG0);
break;
case S_DPTR:
if (t1 != S_IMMED)
aerr();
outab(0x90);
if (amode == 2)
outr3b(&e1, R_NORM);
else
outrw(&e1, R_NORM);
break;
default:
aerr();
}
break;
case S_BITBR: /* JB, JBC, JNB bit,rel */
/* Branch on bit set/clear */
t = addr(&e);
if ((t != S_DIR) && (t != S_EXT))
aerr();
/* sdcc svn rev #4994: fixed bug 1865114 */
comma(1);
expr(&e1, 0);
outab(op);
outrb(&e, R_PAG0);
if (mchpcr(&e1)) {
v1 = (int) (e1.e_addr - dot.s_addr - 1);
/* sdcc svn rev #602: Fix some path problems */
if (pass == 2 && ((v1 < -128) || (v1 > 127)))
aerr();
outab(v1);
} else {
outrb(&e1, R_PCR);
}
if (e1.e_mode != S_USER)
rerr();
break;
case S_BR: /* JC, JNC, JZ, JNZ */
/* Relative branch */
/* sdcc svn rev #4994: fixed bug 1865114 */
expr(&e1, 0);
outab(op);
if (mchpcr(&e1)) {
v1 = (int) (e1.e_addr - dot.s_addr - 1);
/* sdcc svn rev #602: Fix some path problems */
if (pass == 2 && ((v1 < -128) || (v1 > 127)))
aerr();
outab(v1);
} else {
outrb(&e1, R_PCR);
}
if (e1.e_mode != S_USER)
rerr();
break;
case S_CJNE:
/* A,#; A,dir; @R0,#; @R1,#; Rn,# */
t = addr(&e);
comma(1);
t1 = addr(&e1);
/* Benny */
comma(1);
expr(&e2, 0);
switch (t) {
case S_A:
if (t1 == S_IMMED) {
outab(op + 4);
outrb(&e1, R_NORM);
}
else if ((t1 == S_DIR) || (t1 == S_EXT)) {
outab(op + 5);
outrb(&e1, R_PAG0);
}
else
aerr();
break;
case S_AT_R:
outab(op + 6 + e.e_addr);
if (t1 != S_IMMED)
aerr();
outrb(&e1, R_NORM);
break;
case S_REG:
outab(op + 8 + e.e_addr);
if (t1 != S_IMMED)
aerr();
outrb(&e1, R_NORM);
break;
default:
aerr();
break;
}
/* branch destination */
if (mchpcr(&e2)) {
v1 = (int) (e2.e_addr - dot.s_addr - 1);
/* sdcc svn rev #602: Fix some path problems */
if (pass == 2 && ((v1 < -128) || (v1 > 127)))
aerr();
outab(v1);
} else {
outrb(&e2, R_PCR);
}
if (e2.e_mode != S_USER)
rerr();
break;
case S_DJNZ:
/* Dir,dest; Reg,dest */
t = addr(&e);
/* sdcc svn rev #4994: fixed bug 1865114 */
comma(1);
expr(&e1, 0);
switch (t) {
case S_DIR:
case S_EXT:
outab(op + 5);
outrb(&e, R_PAG0);
break;
case S_REG:
outab(op + 8 + e.e_addr);
break;
default:
aerr();
}
/* branch destination */
/* sdcc svn rev #4994: fixed bug 1865114 */
if (mchpcr(&e1)) {
v1 = (int) (e1.e_addr - dot.s_addr - 1);
/* sdcc svn rev #602: Fix some path problems */
if (pass == 2 && ((v1 < -128) || (v1 > 127)))
aerr();
outab(v1);
} else {
outrb(&e1, R_PCR);
}
if (e1.e_mode != S_USER)
rerr();
break;
case S_JMP:
/* @A+DPTR */
t = addr(&e);
if (t != S_AT_ADP)
aerr();
outab(op);
break;
case S_MOVC:
/* A,@A+DPTR A,@A+PC */
t = addr(&e);
if (t != S_A)
aerr();
comma(1);
t1 = addr(&e1);
if (t1 == S_AT_ADP)
outab(0x93);
else if (t1 == S_AT_APC)
outab(0x83);
else
aerr();
break;
case S_MOVX:
/* A,@DPTR A,@R0 A,@R1 @DPTR,A @R0,A @R1,A */
t = addr(&e);
comma(1);
t1 = addr(&e1);
switch (t) {
case S_A:
switch (t1) {
case S_AT_DP:
outab(0xE0);
break;
case S_AT_R:
outab(0xE2 + e1.e_addr);
break;
default:
aerr();
}
break;
case S_AT_DP:
if (t1 == S_A)
outab(0xF0);
else
aerr();
break;
case S_AT_R:
if (t1 == S_A)
outab(0xF2 + e.e_addr);
else
aerr();
break;
default:
aerr();
}
break;
/* MUL/DIV A,B */
case S_AB:
t = addr(&e);
if (t != S_RAB)
aerr();
outab(op);
break;
/* CLR or CPL: A, C, or bit */
case S_ACBIT:
t = addr(&e);
switch (t) {
case S_A:
if (op == 0xB2)
outab(0xF4);
else
outab(0xE4);
break;
case S_C:
outab(op+1);
break;
case S_DIR:
case S_EXT:
outab(op);
outrb(&e, R_PAG0);
break;
default:
aerr();
}
break;
/* SETB C or bit */
case S_SETB:
t = addr(&e);
switch (t) {
case S_C:
outab(op+1);
break;
case S_DIR:
case S_EXT:
outab(op);
outrb(&e, R_PAG0);
break;
default:
aerr();
}
break;
/* direct */
case S_DIRECT:
t = addr(&e);
if (t == S_A) {
e.e_addr = 0xE0;
e.e_mode = S_DIR;
} else
if ((t != S_DIR) && (t != S_EXT)) {
aerr();
break;
}
outab(op);
outrb(&e, R_PAG0);
break;
/* XCHD A,@Rn */
case S_XCHD:
t = addr(&e);
if (t != S_A)
aerr();
comma(1);
t1 = addr(&e1);
switch (t1) {
case S_AT_R:
outab(op + e1.e_addr);
break;
default:
aerr();
}
break;
default:
opcycles = OPCY_ERR;
err('o');
break;
}
if (opcycles == OPCY_NONE) {
opcycles = ds8pg1[cb[0] & 0xFF];
}
}
