/** * Prosesses NMEA GPGSA sentences * \param[in] Buffer for parsed nmea GPGSA sentence */ void NMEAParser::nmeaProcessGPGSA(char* packet) { // start parsing just after "GPGSA," // attempt to reject empty packets right away if(packet[6]==',' && packet[7]==',') return; if(!nmeaChecksum(packet)) { // checksum not valid return; } nmeaTerminateAtChecksum(packet); QString nmeaString( packet ); QStringList tokenslist = nmeaString.split(","); // M=Manual, forced to operate in 2D or 3D // A=Automatic, 3D/2D QString fixmodeValue = tokenslist.at(1); if (fixmodeValue == "A") { emit fixmode(QString("Auto")); } else if (fixmodeValue == "B") { emit fixmode(QString("Manual")); } // Mode: 1=Fix not available, 2=2D, 3=3D int fixtypeValue = tokenslist.at(2).toInt(); if (fixtypeValue == 1) { emit fixtype(QString("NoFix")); } else if (fixtypeValue == 2) { emit fixtype(QString("Fix2D")); } else if (fixtypeValue == 3) { emit fixtype(QString("Fix3D")); } // 3-14 = IDs of SVs used in position fix (null for unused fields) QList<int> svList; for(int pos = 0; pos < 12;pos ++) { QString sv = tokenslist.at(3+pos); if(!sv.isEmpty()) { svList.append(sv.toInt()); } } emit fixSVs(svList); // 15 = PDOP // 16 = HDOP // 17 = VDOP GpsData.PDOP = tokenslist.at(15).toDouble(); GpsData.HDOP = tokenslist.at(16).toDouble(); GpsData.VDOP = tokenslist.at(17).toDouble(); emit dop(GpsData.HDOP, GpsData.VDOP, GpsData.PDOP); }
void ptype (const char *prefix, const char *type, int follow) { if (prefix != NULL) { if (streq (prefix, "enum")) { f_print (fout, "enum "); } else { f_print (fout, "struct "); } } if (streq (type, "bool")) { f_print (fout, "bool_t "); } else if (streq (type, "string")) { f_print (fout, "char *"); } else { f_print (fout, "%s ", follow ? fixtype (type) : type); } }
retval(register int t) #endif { register Addrp p; switch(t) { case TYCHAR: case TYCOMPLEX: case TYDCOMPLEX: break; case TYLOGICAL: t = tylogical; case TYINT1: case TYADDR: case TYSHORT: case TYLONG: #ifdef TYQUAD case TYQUAD: #endif case TYREAL: case TYDREAL: case TYLOGICAL1: case TYLOGICAL2: p = (Addrp) cpexpr((expptr)retslot); p->vtype = t; p1_subr_ret (mkconv (t, fixtype((expptr)p))); break; default: badtype("retval", t); } }
putexpr(expptr p) #endif { /* Write the expression to the p1 file */ p = (expptr) putx (fixtype (p)); p1_expr (p); }
/* * Put return values into correct register. */ void putforce(int t, bigptr p) { NODE *p1; p = mkconv(t, fixtype(p)); p1 = putx(p); p1 = mkunode(FORCE, p1, 0, (t==TYSHORT ? SHORT : (t==TYLONG ? LONG : LDOUBLE))); sendp2(p1); }
dim_finish(Namep v) #endif { register struct Dimblock *p; register expptr q; register int i, nd; p = v->vdim; v->vdimfinish = 0; nd = p->ndim; doin_setbound = 1; for(i = 0; i < nd; i++) if (q = p->dims[i].dimexpr) { q = p->dims[i].dimexpr = make_int_expr(putx(fixtype(q))); if (!ONEOF(q->headblock.vtype, MSKINT|MSKREAL)) bad_dimtype(v); } if (q = p->basexpr) p->basexpr = make_int_expr(putx(fixtype(q))); doin_setbound = 0; }
make_param(register struct Paramblock *p, expptr e) #endif { register expptr q; struct Constblock qc; p->vclass = CLPARAM; impldcl((Namep)p); if (e->headblock.vtype != TYCHAR) e = putx(fixtype(e)); p->paramval = q = mkconv(p->vtype, e); if (p->vtype == TYCHAR) { if (q->tag == TEXPR) p->paramval = q = fixexpr((Exprp)q); if (q->tag == TADDR && q->addrblock.uname_tag == UNAM_CONST) { qc.Const = q->addrblock.user.Const; qc.tag = TCONST; qc.vtype = q->addrblock.vtype; qc.vleng = q->addrblock.vleng; q = (expptr)&qc; } if (!ISCONST(q) || q->constblock.vtype != TYCHAR) { errstr("invalid value for character parameter %s", p->fvarname); return; } if (!(e = p->vleng)) p->vleng = ICON(q->constblock.vleng->constblock.Const.ci + q->constblock.Const.ccp1.blanks); else if (q->constblock.vleng->constblock.Const.ci > e->constblock.Const.ci) { q->constblock.vleng->constblock.Const.ci = e->constblock.Const.ci; q->constblock.Const.ccp1.blanks = 0; } else q->constblock.Const.ccp1.blanks = e->constblock.Const.ci - q->constblock.vleng->constblock.Const.ci; } }
void pprocdef(proc_list * proc, version_list * vp) { f_print(fout, "extern "); if (proc->res_prefix) { if (streq(proc->res_prefix, "enum")) { f_print(fout, "enum "); } else { f_print(fout, "struct "); } } if (streq(proc->res_type, "bool")) { f_print(fout, "bool_t *"); } else if (streq(proc->res_type, "string")) { f_print(fout, "char **"); } else { f_print(fout, "%s *", fixtype(proc->res_type)); } pvname(proc->proc_name, vp->vers_num); f_print(fout, "();\n"); }
/* put out code for if( ! p) goto l */ void putif(bigptr p, int l) { NODE *p1; int k; if( ( k = (p = fixtype(p))->vtype) != TYLOGICAL) { if(k != TYERROR) err("non-logical expression in IF statement"); frexpr(p); } else { p1 = putex1(p); if (p1->n_op == EQ && p1->n_right->n_op == ICON && p1->n_right->n_lval == 0 && logop(p1->n_left->n_op)) { /* created by OPOR */ NODE *q = p1->n_left; q->n_op = negrel[q->n_op - EQ]; nfree(p1->n_right); nfree(p1); p1 = q; } if (logop(p1->n_op) == 0) p1 = mkbinode(NE, p1, mklnode(ICON, 0, 0, INT), INT); if (p1->n_left->n_op == ICON) { /* change constants to right */ NODE *p2 = p1->n_left; p1->n_left = p1->n_right; p1->n_right = p2; if (p1->n_op != EQ && p1->n_op != NE) p1->n_op = negrel[p1->n_op - EQ]; } p1->n_op = negrel[p1->n_op - EQ]; p1 = mkbinode(CBRANCH, p1, mklnode(ICON, l, 0, INT), INT); sendp2(p1); } }
nextdata(ftnint *elenp) #endif { register struct Impldoblock *ip; struct Primblock *pp; register Namep np; register struct Rplblock *rp; tagptr p; expptr neltp; register expptr q; int skip; ftnint off, vlen; while(curdtp) { p = (tagptr)curdtp->datap; if(p->tag == TIMPLDO) { ip = &(p->impldoblock); if(ip->implb==NULL || ip->impub==NULL || ip->varnp==NULL) fatali("bad impldoblock 0%o", (int) ip); if(ip->isactive) ip->varvp->Const.ci += ip->impdiff; else { q = fixtype(cpexpr(ip->implb)); if( ! ISICON(q) ) goto doerr; ip->varvp = (Constp) q; if(ip->impstep) { q = fixtype(cpexpr(ip->impstep)); if( ! ISICON(q) ) goto doerr; ip->impdiff = q->constblock.Const.ci; frexpr(q); } else ip->impdiff = 1; q = fixtype(cpexpr(ip->impub)); if(! ISICON(q)) goto doerr; ip->implim = q->constblock.Const.ci; frexpr(q); ip->isactive = YES; rp = ALLOC(Rplblock); rp->rplnextp = rpllist; rpllist = rp; rp->rplnp = ip->varnp; rp->rplvp = (expptr) (ip->varvp); rp->rpltag = TCONST; } if( (ip->impdiff>0 && (ip->varvp->Const.ci <= ip->implim)) || (ip->impdiff<0 && (ip->varvp->Const.ci >= ip->implim)) ) { /* start new loop */ curdtp = ip->datalist; goto next; } /* clean up loop */ if(rpllist) { rp = rpllist; rpllist = rpllist->rplnextp; free( (charptr) rp); } else Fatal("rpllist empty"); frexpr((expptr)ip->varvp); ip->isactive = NO; curdtp = curdtp->nextp; goto next; } pp = (struct Primblock *) p; np = pp->namep; cur_varname = np->fvarname; skip = YES; if(p->primblock.argsp==NULL && np->vdim!=NULL) { /* array initialization */ q = (expptr) mkaddr(np); off = typesize[np->vtype] * curdtelt; if(np->vtype == TYCHAR) off *= np->vleng->constblock.Const.ci; q->addrblock.memoffset = mkexpr(OPPLUS, q->addrblock.memoffset, mkintcon(off) ); if( (neltp = np->vdim->nelt) && ISCONST(neltp)) { if(++curdtelt < neltp->constblock.Const.ci) skip = NO; } else err("attempt to initialize adjustable array"); } else q = mklhs((struct Primblock *)cpexpr((expptr)pp), 0); if(skip) { curdtp = curdtp->nextp; curdtelt = 0; } if(q->headblock.vtype == TYCHAR) if(ISICON(q->headblock.vleng)) *elenp = q->headblock.vleng->constblock.Const.ci; else { err("initialization of string of nonconstant length"); continue; } else *elenp = typesize[q->headblock.vtype]; if (np->vstg == STGBSS) { vlen = np->vtype==TYCHAR ? np->vleng->constblock.Const.ci : typesize[np->vtype]; if(vlen > 0) np->vstg = STGINIT; } return( (Addrp) q ); doerr: err("nonconstant implied DO parameter"); frexpr(q); curdtp = curdtp->nextp; next: curdtelt = 0; } return(NULL); }
prolog(FILE *outfile, register chainp p) #endif { int addif, addif0, i, nd; ftnint size; int *ac; register Namep q; register struct Dimblock *dp; chainp p0, p1; if(procclass == CLBLOCK) return; p0 = p; p1 = p = argsort(p); wrote_comment = 0; comment_file = outfile; ac = 0; /* Compute the base addresses and offsets for the array parameters, and assign these values to local variables */ addif = addif0 = nentry > 1; for(; p ; p = p->nextp) { q = (Namep) p->datap; if(dp = q->vdim) /* if this param is an array ... */ { expptr Q, expr; /* See whether to protect the following with an if. */ /* This only happens when there are multiple entries. */ nd = dp->ndim - 1; if (addif0) { if (!ac) ac = count_args(); if (ac[q->argno] == nentry) addif = 0; else if (dp->basexpr || dp->baseoffset->constblock.Const.ci) addif = 1; else for(addif = i = 0; i <= nd; i++) if (dp->dims[i].dimexpr && (i < nd || !q->vlastdim)) { addif = 1; break; } if (addif) { write_comment(); nice_printf(outfile, "if (%s) {\n", /*}*/ q->cvarname); next_tab(outfile); } } for(i = 0 ; i <= nd; ++i) /* Store the variable length of each dimension (which is fixed upon runtime procedure entry) into a local variable */ if ((Q = dp->dims[i].dimexpr) && (i < nd || !q->vlastdim)) { expr = (expptr)cpexpr(Q); write_comment(); out_and_free_statement (outfile, mkexpr (OPASSIGN, fixtype(cpexpr(dp->dims[i].dimsize)), expr)); } /* if dp -> dims[i].dimexpr */ /* size will equal the size of a single element, or -1 if the type is variable length character type */ size = typesize[ q->vtype ]; if(q->vtype == TYCHAR) if( ISICON(q->vleng) ) size *= q->vleng->constblock.Const.ci; else size = -1; /* Fudge the argument pointers for arrays so subscripts * are 0-based. Not done if array bounds are being checked. */ if(dp->basexpr) { /* Compute the base offset for this procedure */ write_comment(); out_and_free_statement (outfile, mkexpr (OPASSIGN, cpexpr(fixtype(dp->baseoffset)), cpexpr(fixtype(dp->basexpr)))); } /* if dp -> basexpr */ if(! checksubs) { if(dp->basexpr) { expptr tp; /* If the base of this array has a variable adjustment ... */ tp = (expptr) cpexpr (dp -> baseoffset); if(size < 0 || q -> vtype == TYCHAR) tp = mkexpr (OPSTAR, tp, cpexpr (q -> vleng)); write_comment(); tp = mkexpr (OPMINUSEQ, mkconv (TYADDR, (expptr)p->datap), mkconv(TYINT, fixtype (fixtype (tp)))); /* Avoid type clash by removing the type conversion */ tp = prune_left_conv (tp); out_and_free_statement (outfile, tp); } else if(dp->baseoffset->constblock.Const.ci != 0) { /* if the base of this array has a nonzero constant adjustment ... */ expptr tp; write_comment(); if(size > 0 && q -> vtype != TYCHAR) { tp = prune_left_conv (mkexpr (OPMINUSEQ, mkconv (TYADDR, (expptr)p->datap), mkconv (TYINT, fixtype (cpexpr (dp->baseoffset))))); out_and_free_statement (outfile, tp); } else { tp = prune_left_conv (mkexpr (OPMINUSEQ, mkconv (TYADDR, (expptr)p->datap), mkconv (TYINT, fixtype (mkexpr (OPSTAR, cpexpr (dp -> baseoffset), cpexpr (q -> vleng)))))); out_and_free_statement (outfile, tp); } /* else */ } /* if dp -> baseoffset -> const */ } /* if !checksubs */ if (addif) { nice_printf(outfile, /*{*/ "}\n"); prev_tab(outfile); } } } if (wrote_comment) nice_printf (outfile, "\n/* Function Body */\n"); if (ac) free((char *)ac); if (p0 != p1) frchain(&p1); } /* prolog */