void readdht11()
{
uchar TEMP;
DSET;
CLR;
delay_20ms();
SET;
delay_40us();
SET;
DCLR;
if(!(P1IN&BIT5));
{
FLAG=2;
while((!(P1IN&BIT5))&&FLAG++);
FLAG=2;
while((P1IN&BIT5)&&FLAG++);
RH_DATA_H_TEMP=COM();
RH_DATA_L_TEMP=COM();
T_DATA_H_TEMP=COM();
T_DATA_L_TEMP=COM();
CHECKDATA=COM();
TEMP=(T_DATA_H_TEMP+T_DATA_L_TEMP+RH_DATA_H_TEMP+RH_DATA_L_TEMP);
if(TEMP==CHECKDATA)
{
RH_DATA_H=RH_DATA_H_TEMP;
RH_DATA_L=RH_DATA_L_TEMP;
T_DATA_H=T_DATA_H_TEMP;
T_DATA_L=T_DATA_L_TEMP;
}
}
}
void DHT11(void) //温湿传感启动
{
DATA_PIN=0;
Delay_ms(19); //>18MS
DATA_PIN=1;
P1DIR &= ~0x02; //重新配置IO口方向
Delay_10us();
Delay_10us();
Delay_10us();
Delay_10us();
if(!DATA_PIN)
{
ucharFLAG=2;
while((!DATA_PIN)&&ucharFLAG++);
ucharFLAG=2;
while((DATA_PIN)&&ucharFLAG++);
COM();
ucharRH_data_H_temp=ucharcomdata;
COM();
ucharRH_data_L_temp=ucharcomdata;
COM();
ucharT_data_H_temp=ucharcomdata;
COM();
ucharT_data_L_temp=ucharcomdata;
COM();
ucharcheckdata_temp=ucharcomdata;
DATA_PIN=1;
uchartemp=(ucharT_data_H_temp+ucharT_data_L_temp+ucharRH_data_H_temp+ucharRH_data_L_temp);
if(uchartemp==ucharcheckdata_temp)
{
ucharRH_data_H=ucharRH_data_H_temp;
ucharRH_data_L=ucharRH_data_L_temp;
ucharT_data_H=ucharT_data_H_temp;
ucharT_data_L=ucharT_data_L_temp;
ucharcheckdata=ucharcheckdata_temp;
}
wendu_shi=ucharT_data_H/10;
wendu_ge=ucharT_data_H%10;
shidu_shi=ucharRH_data_H/10;
shidu_ge=ucharRH_data_H%10;
}
else //没用成功读取，返回0
{
wendu_shi=0;
wendu_ge=0;
shidu_shi=0;
shidu_ge=0;
}
P1DIR |= 0x02; //IO口需要重新配置
}
/**********************************************************************************
函数功能：点亮或者熄灭某'8'中的某一个元素:'A'~'G'
入口：
offset----具体的设备对应的偏移
Bit---------------清除还是显示的具体位:0~6('A'~'G')
出口： 1-----------成功;0-------------失败
**********************************************************************************/
INT8U SetOnPixyLED8(INT16U Device,INT8U DisChar)
{
INT16U Seg,Com,Pos;
//找合理位置
Pos=GetPixySegPos_SxNxDx(Device,Nx);
if(!Pos)
return 0;
if(Pos>=MAX_N_NUM) //防止越界
return 0;
//检查显示的字段是否合法
if(DisChar<'A')
return 0;
if(DisChar>'G')
return 0;
DisChar=DisChar-'A';
Seg=SEG(LCD_N_Const[Pos+DisChar].x);
Com=COM(LCD_N_Const[Pos+DisChar].y);
if((Seg<=MAX_SEG)&&(Com<=MAX_COL)) //防止越界
{
Show_Lcd_Flag=1;
SET_BIT(Show_Lcd_Ram[Seg],Com);
}
return 1;
}
int
main (int argc, char **argv)
{
VERBOSE = 1;
struct params p;
processArgsAnalyze (argc, argv, p);
gsl_matrix *atomsNonCrop = ReadFitsImg_gsl_matrix (p.atomsfile);
//gsl_matrix *noatoms = ReadFitsImg_gsl_matrix (p.noatomsfile);
gsl_matrix *atoms = cropImage (p.reportfile, atomsNonCrop);
//gsl_matrix *cnoatoms = cropImage (p.reportfile, noatoms);
double com[2];
COM (atoms, com);
cout << "COM_X = " << com[0] << endl;
cout << "COM_Y = " << com[1] << endl;
setINI_num (p.reportfile, "CPP", "COM_X", com[0]);
setINI_num (p.reportfile, "CPP", "COM_Y", com[1]);
gsl_matrix_free (atomsNonCrop);
gsl_matrix_free (atoms);
}
int add_table_name(int index, const char *name) {
set_table_name(name, index);
if (add_symbol(name, 10, 1, COM(TABTYPE, index)) < 0)
return 1;
return 0;
}
/**********************************************************************************
函数功能：点亮或者熄灭某一个显示标志
入口： Flag----1:显示;0:熄灭
出口： 1---------有此设备；0------找不到设备
**********************************************************************************/
INT8U SetOrClrPixPiyDot(INT16U ShouID,INT8U ClrOrSet,INT8U Type)
{
INT16U Pos,Seg,Com;
INT8U Flag,i,temp;
Pos=GetPixySegPos_SxNxDx(ShouID,Type);
if(!Pos)
return 0;
switch(Type)
{
case Sx:
Seg=SEG(LCD_S_Const[Pos].x);
Com=COM(LCD_S_Const[Pos].y);
Flag=SetOrClrAndChkSEGCOM(Seg,Com,Type,ClrOrSet);
return Flag;
case Dx:
Seg=SEG(LCD_D_Const[Pos].x);
Com=COM(LCD_D_Const[Pos].y);
Flag=SetOrClrAndChkSEGCOM(Seg,Com,Type,ClrOrSet);
return Flag;
case Nx:
//#ifdef CONFLICT_TAB_CHKEN
// temp=7;
//#else
temp=1;
//#endif
for(i=0;i<temp;i++)
{
Seg=SEG(LCD_N_Const[Pos+i].x);
Com=COM(LCD_N_Const[Pos+i].y);
Flag=SetOrClrAndChkSEGCOM(Seg,Com,Type,ClrOrSet);
if(!Flag)
return 0;
}
return 1;
}
return 0;
}
int add_kernel(const char *name, double mu, const char *expr) {
int ki = volterra2_add_kernel(expr, mu);
if (ki < 0)
return 1;
if (add_symbol(name, 10, 0, COM(KERTYPE, ki)) < 0) {
volterra2_remove_kernel(ki);
return 1;
}
return 0;
}
void RH_(void)
{
dht11=0;
Delay18ms();
dht11=1;
Delay_10us();
Delay_10us();
dht11=1;
if(!dht11)
{
U8FLAG=2;
while((!dht11)&&U8FLAG++);
U8FLAG=2;
while((dht11)&&U8FLAG++);
COM();
U8RH_data_H_temp=U8comdata;
COM();
U8RH_data_L_temp=U8comdata;
COM();
U8T_data_H_temp=U8comdata;
COM();
U8T_data_L_temp=U8comdata;
COM();
U8checkdata_temp=U8comdata;
dht11=1;
U8temp=(U8T_data_H_temp+U8T_data_L_temp+U8RH_data_H_temp+U8RH_data_L_temp);
if(U8temp==U8checkdata_temp)
{
U8RH_data_H = U8RH_data_H_temp;
U8RH_data_L = U8RH_data_L_temp;
U8T_data_H=U8T_data_H_temp;
U8T_data_L=U8T_data_L_temp;
U8checkdata=U8checkdata_temp;
}
}
}
int add_con(const char *name, double value) {
double *p = parser_doubles_append(&constants);
if (!p) return 1;
*p = value;
if (add_symbol(name, 10, 0, COM(CONTYPE, constants.len - 1)) < 0) {
parser_doubles_remove(&constants, constants.len - 1, 1);
return 1;
}
return 0;
}
int add_var(const char *name, double value) {
double *p = parser_doubles_append(&variables);
if (!p) return 1;
*p = value;
if (add_symbol(name, 10, 0, COM(VARTYPE, variables.len - 1)) < 0) {
parser_doubles_remove(&variables, variables.len - 1, 1);
return 1;
}
return 0;
}
void Molecule::rotate(Vector axis, double theta) {
Eigen::Vector3d axisEig = {axis[0], axis[1], axis[2]};
Eigen::AngleAxisd ax(theta, axisEig);
Eigen::Matrix3d rot;
rot = ax;
Vector com = COM();
Eigen::Vector3d comEig= {com[0], com[1], com[2]};
for (int id : ids) {
Atom &a = state->idToAtom(id);
Eigen::Vector3d posEig = {a.pos[0], a.pos[1], a.pos[2]};
Eigen::Vector3d relEig = posEig-comEig;
relEig = rot * relEig;
a.pos = Vector(relEig[0], relEig[1], relEig[2]) + com;
}
}
int add_ufun_name(char *name, int narg) {
UserFunction *p = parser_ufuns_append(&ufuns);
if (!p) return 1;
strncpy(p->name, name, sizeof(p->name));
p->name[sizeof(p->name) - 1] = '\0';
if (add_symbol(name, 10, narg, COM(UFUNTYPE, ufuns.len - 1)) < 0) {
parser_ufuns_remove(&ufuns, ufuns.len - 1, 1);
return 1;
}
return 0;
}
int add_ufun(const char *name, const char *expr, int narg) {
int i, l;
int end;
UserFunction *p = parser_ufuns_append(&ufuns);
if (!p) return 1;
if ((p->rpn = malloc(1024)) == NULL) {
plintf("not enough memory!!\n");
return 1;
}
if ((p->def = malloc(MAXEXPLEN)) == NULL) {
free(p->rpn);
parser_ufuns_remove(&ufuns, ufuns.len - 1, 1);
plintf("not enough memory!!\n");
return 1;
}
strcpy(p->def, expr);
l = strlen(p->def);
p->def[l - 1] = '\0';
strcpy(p->name, name);
p->narg = narg;
for (i = 0; i < narg; i++) {
sprintf(p->args[i], "ARG%d", i + 1);
}
if (parse_expr(expr, p->rpn, &end)) {
free(p->def);
free(p->rpn);
parser_ufuns_remove(&ufuns, ufuns.len - 1, 1);
plintf("ERROR IN FUNCTION DEFINITION\n");
return 1;
}
fixup_endfun(p->rpn, end, narg);
if (add_symbol(name, 10, narg, COM(UFUNTYPE, ufuns.len - 1)) < 0) {
free(p->def);
free(p->rpn);
parser_ufuns_remove(&ufuns, ufuns.len - 1, 1);
return 1;
}
return 0;
}
int touch(const char* filename, mode_t mode)
{
size_t bytes = 0;
int fd = -1;
if((fd = open(filename, O_CREAT | O_WRONLY, mode)) < 0)
{
COM(SELF, "FATAL: %s: %s: %s\n", filename, strerror(errno));
fprintf(stderr, "FATAL: %s: %s: %s\n", SELF, filename, strerror(errno));
return errno;
}
char byte = '\0';
if((bytes = write(fd, &byte, 1)) < 1)
{
return errno;
}
close(fd);
return 0;
}
int
arch_pdp11_translate_instr(cpu_t *cpu, addr_t pc, BasicBlock *bb) {
uint16_t opcode = cpu->RAM[pc];
//LOG("%s:%d PC=$%04X\n", __func__, __LINE__, pc);
switch (get_instr(opcode)) {
/* flags */
case INSTR_CLC: LET1(cpu->ptr_C, FALSE); break;
case INSTR_CLD: LET1(ptr_D, FALSE); break;
case INSTR_CLI: LET1(ptr_I, FALSE); break;
case INSTR_CLV: LET1(cpu->ptr_V, FALSE); break;
case INSTR_SEC: LET1(cpu->ptr_C, TRUE); break;
case INSTR_SED: LET1(ptr_D, TRUE); break;
case INSTR_SEI: LET1(ptr_I, TRUE); break;
/* register transfer */
case INSTR_TAX: SET_NZ(LET(X,R(A))); break;
case INSTR_TAY: SET_NZ(LET(Y,R(A))); break;
case INSTR_TXA: SET_NZ(LET(A,R(X))); break;
case INSTR_TYA: SET_NZ(LET(A,R(Y))); break;
case INSTR_TSX: SET_NZ(LET(X,R(S))); break;
case INSTR_TXS: SET_NZ(LET(S,R(X))); break;
/* load */
case INSTR_LDA: SET_NZ(LET(A,OPERAND)); break;
case INSTR_LDX: SET_NZ(LET(X,OPERAND)); break;
case INSTR_LDY: SET_NZ(LET(Y,OPERAND)); break;
/* store */
case INSTR_STA: STORE(R(A),LOPERAND); break;
case INSTR_STX: STORE(R(X),LOPERAND); break;
case INSTR_STY: STORE(R(Y),LOPERAND); break;
/* stack */
case INSTR_PHA: PUSH(R(A)); break;
case INSTR_PHP: PUSH(arch_flags_encode(cpu, bb)); break;
case INSTR_PLA: SET_NZ(LET(A,PULL)); break;
case INSTR_PLP: arch_flags_decode(cpu, PULL, bb); break;
/* shift */
case INSTR_ASL: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, false)); break;
case INSTR_LSR: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, false)); break;
case INSTR_ROL: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, true, true)); break;
case INSTR_ROR: SET_NZ(SHIFTROTATE(LOPERAND, LOPERAND, false, true)); break;
/* bit logic */
case INSTR_AND: SET_NZ(LET(A,AND(R(A),OPERAND))); break;
case INSTR_ORA: SET_NZ(LET(A,OR(R(A),OPERAND))); break;
case INSTR_EOR: SET_NZ(LET(A,XOR(R(A),OPERAND))); break;
case INSTR_BIT: SET_NZ(OPERAND); break;
/* arithmetic */
case INSTR_ADC: SET_NZ(ADC(ptr_A, ptr_A, OPERAND, true, false)); break;
case INSTR_SBC: SET_NZ(ADC(ptr_A, ptr_A, COM(OPERAND), true, false)); break;
case INSTR_CMP: SET_NZ(ADC(NULL, ptr_A, COM(OPERAND), false, true)); break;
case INSTR_CPX: SET_NZ(ADC(NULL, ptr_X, COM(OPERAND), false, true)); break;
case INSTR_CPY: SET_NZ(ADC(NULL, ptr_Y, COM(OPERAND), false, true)); break;
/* increment/decrement */
case INSTR_INX: SET_NZ(LET(X,INC(R(X)))); break;
case INSTR_INY: SET_NZ(LET(Y,INC(R(Y)))); break;
case INSTR_DEX: SET_NZ(LET(X,DEC(R(X)))); break;
case INSTR_DEY: SET_NZ(LET(Y,DEC(R(Y)))); break;
case INSTR_INC: SET_NZ(STORE(INC(OPERAND),LOPERAND)); break;
case INSTR_DEC: SET_NZ(STORE(DEC(OPERAND),LOPERAND)); break;
/* control flow */
case INSTR_JMP:
if (get_addmode(opcode) == ADDMODE_IND) {
Value *v = LOAD_RAM16(CONST32(OPERAND_16));
new StoreInst(v, cpu->ptr_PC, bb);
}
break;
case INSTR_JSR: PUSH16(pc+2); break;
case INSTR_RTS: STORE(ADD(PULL16, CONST16(1)), cpu->ptr_PC); break;
/* branch */
case INSTR_BEQ:
case INSTR_BNE:
case INSTR_BCS:
case INSTR_BCC:
case INSTR_BMI:
case INSTR_BPL:
case INSTR_BVS:
case INSTR_BVC:
break;
/* other */
case INSTR_NOP: break;
case INSTR_BRK: arch_6502_trap(cpu, pc, bb); break;
case INSTR_RTI: arch_6502_trap(cpu, pc, bb); break;
case INSTR_XXX: arch_6502_trap(cpu, pc, bb); break;
}
return get_length(get_addmode(opcode));
}
int add_net_name(int index, const char *name) {
if (add_symbol(name, 10, 1, COM(NETTYPE, index)) < 0)
return 1;
return 0;
}
/* communicate objects using point to point communication */
int COMOBJS (MPI_Comm comm, int tag,
OBJ_Pack pack,
void *data,
OBJ_Unpack unpack,
COMOBJ *send, int nsend,
COMOBJ **recv, int *nrecv) /* recv is contiguous => free (*recv) releases all memory */
{
COMDATA *send_data,
*recv_data,
*cd, *cc;
int recv_count,
i, n,
ret;
COMOBJ *co;
MAP *map;
MEM mem;
ERRMEM (send_data = malloc (nsend * sizeof (COMDATA)));
MEM_Init (&mem, sizeof (MAP), MAX (nsend, 64));
/* pack objects */
for (i = 0, cd = send_data, co = send, map = NULL; i < nsend; i ++, cd ++, co ++)
{
int isize = 0,
dsize = 0;
cd->rank = co->rank;
if ((cc = MAP_Find (map, co->o, NULL))) /* same object was already packed */
{
cd->ints = cc->ints;
cd->doubles = cc->doubles;
cd->i = cc->i;
cd->d = cc->d;
}
else
{
cd->ints = 0;
cd->doubles = 0;
cd->i = NULL;
cd->d = NULL;
pack (co->o, &dsize, &cd->d, &cd->doubles, &isize, &cd->i, &cd->ints);
MAP_Insert (&mem, &map, co->o, cd, NULL);
}
}
/* send and receive packed data */
if (tag == INT_MIN) ret = COMALL (comm, send_data, nsend, &recv_data, &recv_count); /* all to all */
else ret = COM (comm, tag, send_data, nsend, &recv_data, &recv_count); /* point to point */
#if PARDEBUG
{
int debug_send_count, *ip, *jp, ii [2], jj [2];
COMDATA *debug_send_data;
double *qq, *pp;
/* send backwards */
if (tag == INT_MIN) COMALL (comm, recv_data, recv_count, &debug_send_data, &debug_send_count);
else COM (comm, tag, recv_data, recv_count, &debug_send_data, &debug_send_count);
ii[0] = 0, ii[1] = 0;
jj[0] = 0, jj[1] = 0;
do
{
ip = next_int (send_data, nsend, ii);
jp = next_int (debug_send_data, debug_send_count, jj);
if (ip && jp)
{
ASSERT_DEBUG (*ip == *jp, "Integer values mismatch");
}
else
{
ASSERT_DEBUG (!ip && !jp, "Integer count mismatch");
}
}
while (ip && jp);
ii[0] = 0, ii[1] = 0;
jj[0] = 0, jj[1] = 0;
do
{
qq = next_double (send_data, nsend, ii);
pp = next_double (debug_send_data, debug_send_count, jj);
if (qq && pp)
{
ASSERT_DEBUG (*qq == *pp, "Double values mismatch");
}
else
{
ASSERT_DEBUG (!qq && !pp, "Double count mismatch");
}
}
while (qq && pp);
free (debug_send_data);
}
#endif
if (recv_count)
{
*nrecv = recv_count;
ERRMEM (*recv = malloc ((*nrecv) * sizeof (COMOBJ)));
/* unpack received objects */
for (n = i = 0, cd = recv_data, co = *recv; i < recv_count; i ++, cd ++)
{
int ipos = 0,
dpos = 0;
do
{
if (n == *nrecv)
{
*nrecv *= 2; /* resize the receive buffer */
ERRMEM (*recv = realloc (*recv, (*nrecv) * sizeof (COMOBJ)));
co = *recv + n; /* and reset the current pointer */
}
co->rank = cd->rank;
co->o = unpack (data, &dpos, cd->d, cd->doubles, &ipos, cd->i, cd->ints);
co ++;
n ++;
} while (ipos < cd->ints || dpos < cd->doubles); /* while something is left to unpack */
}
/* truncate output */
if (n) ERRMEM (*recv = realloc (*recv, n * sizeof (COMOBJ)));
*nrecv = n;
}
else
{
*recv = NULL;
*nrecv = 0;
}
/* cleanup */
for (MAP *item = MAP_First (map); item; item = MAP_Next (item))
{ cd = item->data; free (cd->i); free (cd->d); }
MEM_Release (&mem);
free (send_data);
free (recv_data); /* contiguous */
return ret;
}
static double eval_rpn(int *equat) {
int i;
double temx, temy, temz;
union /* WARNING -- ASSUMES 32 bit int and 64 bit double */
{
struct {
int int1;
int int2;
} pieces;
struct {
double z;
} num;
} encoder;
while ((i = *equat++) != ENDEXP) {
switch (i) {
case NUMSYM:
encoder.pieces.int2 = *equat++;
encoder.pieces.int1 = *equat++;
PUSH(encoder.num.z);
break;
case ENDFUN:
i = *equat++;
uptr -= i;
break;
case MYIF: {
int ijmp;
temx = POP;
ijmp = *equat++;
if (temx == 0.0)
equat += ijmp;
break;
}
case MYTHEN: {
int ijmp = *equat++;
equat += ijmp;
break;
}
case MYELSE:
break;
case ENDDELSHFT:
temx = POP;
temy = POP;
temz = POP;
PUSH(do_delay_shift(temx, temy, temz));
break;
case ENDDELAY:
temx = POP;
temy = POP;
PUSH(do_delay(temx, temy));
break;
case ENDSHIFT:
temx = POP;
temy = POP;
PUSH(do_shift(temx, temy));
break;
case ENDISHIFT:
temx = POP;
temy = POP;
PUSH(do_ishift(temx, temy));
break;
case SUMSYM: {
int high;
int low;
int ijmp;
double sum;
temx = POP;
high = (int)temx;
temx = POP;
low = (int)temx;
ijmp = *equat++;
sum = 0.0;
if (low <= high) {
for (int is = low; is <= high; is++) {
constants.elems[SumIndex] = (double)is;
sum += eval_rpn(equat);
}
}
equat += ijmp;
PUSH(sum);
break;
}
case ENDSUM:
return (POP);
case INDXCOM:
PUSH(0.0);
break;
default: {
int it = i / MAXTYPE;
int in = i % MAXTYPE;
switch (it) {
case FUN1TYPE:
PUSH(expr_fun1[in](POP));
break;
case FUN2TYPE:
switch (in) {
case 0:
temx = POP;
temy = POP;
PUSH(temx + temy);
break;
case 1:
temx = POP;
temy = POP;
PUSH(temy - temx);
break;
case 2:
temx = POP;
temy = POP;
PUSH(temx * temy);
break;
case 3:
temx = POP;
if (temx == 0.0)
temx = DOUB_EPS;
temy = POP;
PUSH(temy / temx);
break;
default:
temx = POP;
temy = POP;
PUSH(expr_fun2[in](temy, temx));
break;
}
break;
case CONTYPE:
PUSH(constants.elems[in]);
break;
case NETTYPE:
PUSH(network_value(POP, in));
break;
case TABTYPE:
PUSH(lookup(POP, in));
break;
case USTACKTYPE:
/* ram: so this means ustacks really do need to be of USTACKTYPE */
PUSH(ustack[uptr - 1 - in]);
break;
case KERTYPE:
PUSH(ker_val(in));
break;
case VARTYPE:
PUSH(variables.elems[in]);
break;
/* indexes for shift and delay operators... */
case SCONTYPE:
PUSH((double)(COM(CONTYPE, in)));
break;
case SVARTYPE:
PUSH((double)(COM(VARTYPE, in)));
break;
case UFUNTYPE:
i = *equat++;
for (int j = 0; j < i; j++) {
ustack[uptr] = POP;
uptr++;
}
PUSH(eval_rpn(ufuns.elems[in].rpn));
break;
}
break;
}
}
}
return (POP);
}
static int alg_to_rpn(int *toklist, int *command) {
int tokstak[500], comptr = 0, stakptr = 0, lstptr = 0, temp;
int ncomma = 0;
int loopstk[100];
int loopptr = 0;
int nif = 0, nthen = 0, nelse = 0;
tokstak[0] = STARTTOK;
stakptr = 1;
for (;;) {
int newtok = toklist[lstptr++];
int oldtok;
switch (newtok) {
case DELSYM:
temp = my_symb.elems[toklist[lstptr + 1]].com;
if (!is_uvar(temp)) {
printf("Illegal use of DELAY \n");
return 1;
}
/* ram -- is this right? not sure I understand what was happening here */
/* create a temporary sybol */
my_symb.elems[shift_index].com = COM(SVARTYPE, temp % MAXTYPE);
NDELAYS++;
toklist[lstptr + 1] = shift_index;
break;
case DELSHFTSYM:
temp = my_symb.elems[toklist[lstptr + 1]].com;
if (!is_uvar(temp)) {
printf("Illegal use of DELAY Shift \n");
return 1;
}
/* ram -- same issue */
/* create a temporary sybol */
my_symb.elems[shift_index].com = COM(SVARTYPE, temp % MAXTYPE);
NDELAYS++;
toklist[lstptr + 1] = shift_index;
break;
case SHIFTSYM:
case ISHIFTSYM:
temp = my_symb.elems[toklist[lstptr + 1]].com;
if (!is_uvar(temp) && !is_ucon(temp)) {
printf("Illegal use of SHIFT \n");
return 1;
}
/* ram -- same issue */
/* create a temporary sybol */
if (is_uvar(temp))
my_symb.elems[shift_index].com = COM(SVARTYPE, temp % MAXTYPE);
if (is_ucon(temp))
my_symb.elems[shift_index].com = COM(SCONTYPE, temp % MAXTYPE);
toklist[lstptr + 1] = shift_index;
break;
}
next:
oldtok = tokstak[stakptr - 1];
if (newtok == ENDTOK && oldtok == STARTTOK)
break;
if (newtok == LPAREN) {
tokstak[stakptr++] = LPAREN;
continue;
}
if (newtok == RPAREN) {
switch (oldtok) {
case LPAREN:
stakptr--;
continue;
case COMMA:
stakptr--;
ncomma++;
goto next;
}
}
if (newtok == COMMA && oldtok == COMMA) {
tokstak[stakptr++] = COMMA;
continue;
}
if (my_symb.elems[oldtok].pri >= my_symb.elems[newtok].pri) {
int my_com = my_symb.elems[oldtok].com;
command[comptr] = my_com;
comptr++;
switch (my_com) {
case NUMSYM:
/* NUMSYM stores the encoded value as two extra integers. */
stakptr--;
command[comptr] = tokstak[stakptr - 1];
comptr++;
stakptr--;
command[comptr] = tokstak[stakptr - 1];
comptr++;
break;
case SUMSYM:
/* SUMSYM has a jump location to be filled in. */
loopstk[loopptr] = comptr;
comptr++;
loopptr++;
ncomma -= 1;
break;
case ENDSUM:
/* Fill in SUMSYM jump location. */
loopptr--;
command[loopstk[loopptr]] = comptr - loopstk[loopptr] - 1;
break;
case MYIF:
/* MYIF has a jump location to be filled in. */
loopstk[loopptr] = comptr;
comptr++;
loopptr++;
nif++;
break;
case MYTHEN:
/* Fill in the MYIF jump location. */
loopptr--;
command[loopstk[loopptr]] = comptr - loopstk[loopptr]; /* -1 is old */
/* MYTHEN has a jump location to be filled in. */
loopstk[loopptr] = comptr;
loopptr++;
comptr++;
nthen++;
break;
case MYELSE:
/* Fill in the MYTHEN jump location. */
loopptr--;
command[loopstk[loopptr]] = comptr - loopstk[loopptr] - 1;
nelse++;
break;
case ENDDELAY:
case ENDSHIFT:
case ENDISHIFT:
ncomma -= 1;
break;
case ENDDELSHFT:
ncomma -= 2;
break;
default:
if (my_com / MAXTYPE == FUN2TYPE && my_symb.elems[oldtok].arg == 2)
ncomma--;
/* CHECK FOR USER FUNCTION */
if (is_ufun(my_com)) {
int my_arg = my_symb.elems[oldtok].arg;
command[comptr] = my_arg;
comptr++;
ncomma += 1 - my_arg;
}
}
stakptr--;
goto next;
}
if (newtok == NUMTOK) {
/* NUMTOK stores the encoded value as two extra integers. */
tokstak[stakptr++] = toklist[lstptr++];
tokstak[stakptr++] = toklist[lstptr++];
}
tokstak[stakptr++] = newtok;
}
if (ncomma != 0) {
plintf("Illegal number of arguments\n");
return 1;
}
if (nif != nelse || nif != nthen) {
plintf("If statement missing ELSE or THEN \n");
return 1;
}
command[comptr] = my_symb.elems[ENDTOK].com;
return 0;
}
ParserDoubles variables = VECTOR_INIT;
ParserSymbols my_symb = VECTOR_INIT;
ParserUserFunctions ufuns = VECTOR_INIT;
static int SumIndex = 1;
static int shift_index = -1;
/* FIXXX */
static int stack_pointer, uptr;
static double stack[200], ustack[200];
static const ParserSymbol BUILTIN_SYMBOLS[] = {
{"(", 1, ENDEXP, 0, 1}, /* 0 */
{")", 1, ENDEXP, 0, 2},
{",", 1, ENDEXP, 0, 3},
{"+", 1, COM(FUN2TYPE, 0), 0, 4},
{"-", 1, COM(FUN2TYPE, 1), 0, 4},
{"*", 1, COM(FUN2TYPE, 2), 0, 6},
{"/", 1, COM(FUN2TYPE, 3), 0, 6},
{"^", 1, COM(FUN2TYPE, 5), 0, 7},
{"**", 2, COM(FUN2TYPE, 5), 0, 7},
{"~", 1, COM(FUN1TYPE, 14), 0, 6},
{"START", 5, -1, 0, 0}, /* 10 */
{"END", 3, ENDEXP, 0, -1},
{"ATAN2", 5, COM(FUN2TYPE, 4), 2, 10},
{"MAX", 3, COM(FUN2TYPE, 6), 2, 10},
{"MIN", 3, COM(FUN2TYPE, 7), 2, 10},
{"SIN", 3, COM(FUN1TYPE, 0), 0, 10},
{"COS", 3, COM(FUN1TYPE, 1), 0, 10},
{"TAN", 3, COM(FUN1TYPE, 2), 0, 10},
{"ASIN", 4, COM(FUN1TYPE, 3), 0, 10},
