/*
name ::= symbol_opt info
*/
static Type*
parsename(char *desc, char **pp)
{
if(*desc == 'c')
return nil;
if(isdigit((uchar)*desc) || *desc=='-' || *desc=='(')
return parseinfo(desc, pp);
if(*desc == 0)
oops();
return parseinfo(desc+1, pp);
}
static int snachandler(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
{
if (snac->subtype == 0x0009)
return parseinfo(sess, mod, rx, snac, bs);
return 0;
}
static int
snachandler(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
if (snac->subtype == 0x0009)
return parseinfo(od, conn, mod, frame, snac, bs);
return 0;
}
static Type*
parsedefn(char *p, Type *t, char **pp)
{
char c, *name;
int ischar, namelen, n, wid, offset, bits, sign;
long val;
Type *tt;
if(*p == '(' || isdigit((uchar)*p)){
t->ty = Defer;
t->sub = parseinfo(p, pp);
return t;
}
switch(c = *p){
case '-': /* builtin */
n = strtol(p+1, &p, 10);
if(n >= nelem(baseints) || n < 0)
n = 0;
t->ty = Base;
t->xsizeof = baseints[n].size;
t->printfmt = baseints[n].fmt;
break;
case 'b': /* builtin */
p++;
if(*p != 'u' && *p != 's')
oops();
sign = (*p == 's');
p++;
ischar = 0;
if(*p == 'c'){
ischar = 1;
p++;
}
wid = parseint(&p);
semi(&p);
offset = parseint(&p);
semi(&p);
bits = parseint(&p);
semi(&p);
t->ty = Base;
t->xsizeof = wid;
if(sign == 1)
t->printfmt = 'd';
else
t->printfmt = 'x';
USED(bits);
USED(ischar);
break;
case 'R': /* fp type */
n = parseint(&p);
semi(&p);
wid = parseint(&p);
semi(&p);
t->ty = Base;
t->xsizeof = wid;
if(n < 0 || n >= nelem(basefloats))
n = 0;
t->xsizeof = basefloats[n].size;
t->printfmt = basefloats[n].fmt;
break;
case 'r': /* subrange */
t->ty = Range;
t->sub = parseinfo(p+1, &p);
if(*(p-1) == ';' && *p != ';')
p--;
semi(&p);
t->lo = parsebound(&p);
semi(&p);
t->hi = parsebound(&p);
semi(&p);
break;
case 'B': /* volatile */
case 'k': /* const */
t->ty = Defer;
t->sub = parseinfo(p+1, &p);
break;
case '*': /* pointer */
case 'A': /* open array */
case '&': /* reference */ /* guess - C++? (rob) */
t->ty = Pointer;
t->sub = parseinfo(p+1, &p);
break;
case 'a': /* array */
case 'P': /* packed array */
t->ty = Pointer;
tt = newtype();
parsedefn(p+1, tt, &p); /* index type */
if(*p == ';')
p++;
tt = newtype();
t->sub = tt;
parsedefn(p, tt, &p); /* element type */
break;
case 'e': /* enum listing */
p++;
t->sue = 'e';
t->ty = Enum;
while(*p != ';'){
name = p;
p = findcolon(p)+1;
namelen = (p-name)-1;
val = parsebigint(&p);
comma(&p);
if(t->n%32 == 0){
t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
}
t->tname[t->n] = estrndup(name, namelen);
t->val[t->n] = val;
t->n++;
}
semi(&p);
break;
case 's': /* struct */
case 'u': /* union */
p++;
t->sue = c;
t->ty = Aggr;
n = parseint(&p);
while(*p != ';'){
name = p;
p = findcolon(p)+1;
namelen = (p-name)-1;
tt = parseinfo(p, &p);
comma(&p);
offset = parseint(&p);
comma(&p);
bits = parseint(&p);
semi(&p);
if(t->n%32 == 0){
t->tname = erealloc(t->tname, (t->n+32)*sizeof(t->tname[0]));
t->val = erealloc(t->val, (t->n+32)*sizeof(t->val[0]));
t->t = erealloc(t->t, (t->n+32)*sizeof(t->t[0]));
}
t->tname[t->n] = estrndup(name, namelen);
t->val[t->n] = offset;
t->t[t->n] = tt;
t->n++;
}
semi(&p);
break;
case 'x': /* struct, union, enum reference */
p++;
t->ty = Defer;
if(*p != 's' && *p != 'u' && *p != 'e')
oops();
c = *p;
name = p+1;
p = findcolon(p+1);
name = estrndup(name, p-name);
t->sub = typebysue(c, name);
p++;
break;
#if 0 /* AIX */
case 'f': /* function */
case 'p': /* procedure */
case 'F': /* Pascal function */
/* case 'R': /* Pascal procedure */
/*
* Even though we don't use the info, we have
* to parse it in case it is embedded in other descriptions.
*/
t->ty = Function;
p++;
if(c == 'f' || c == 'F'){
t->sub = parseinfo(p, &p);
if(*p != ','){
if(*p == ';')
p++;
break;
}
comma(&p);
}
n = parseint(&p); /* number of params */
semi(&p);
while(*p != ';'){
if(c == 'F' || c == 'R'){
name = p; /* parameter name */
p = findcolon(p)+1;
}
parseinfo(p, &p); /* param type */
comma(&p);
parseint(&p); /* bool: passed by value? */
semi(&p);
}
semi(&p);
break;
#endif
case 'f': /* static function */
case 'F': /* global function */
t->ty = Function;
p++;
t->sub = parseinfo(p, &p);
break;
/*
* We'll never see any of this stuff.
* When we do, we can worry about it.
*/
case 'D': /* n-dimensional array */
case 'E': /* subarray of n-dimensional array */
case 'M': /* fortran multiple instance type */
case 'N': /* pascal string ptr */
case 'S': /* set */
case 'c': /* aix complex */
case 'd': /* file of */
case 'g': /* aix float */
case 'n': /* max length string */
case 'w': /* aix wide char */
case 'z': /* another max length string */
default:
fprint(2, "unsupported type char %c (%d)\n", *p, *p);
oops();
}
*pp = p;
return t;
}
