/**
* 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 */
