const char *parsenameext (const char *p, firqb *out) /* parse the name.ext part of a spec */
{
int n;
for (n = 0; n < NAMELEN - 1; n++) out->name[n] = ' ';
p = parsename (p, out); /* parse the name part */
out->name[6] = '.';
out->name[NAMELEN - 1] = '\0'; /* put in terminator */
if (*p == '.') { /* extension present */
p++;
out->flags |= f_ext;
if (isr50(*p)) {
n = 0;
while (isr50(*p)) {
if (*p == ' ') { /* skip blanks */
p++;
continue;
}
if (*p == '*') {
if (n < 3) {
out->name[7 + n++] = '?';
out->flags |= f_extw;
} else p++;
} else {
if (n < 3) out->name[7 + n++] = tolower (*p);
if (*p++ == '?') out->flags |= f_extw;
}
}
}
}
return (p);
}
int
open_socket ( char *name, int default_port )
{
int fd ;
struct sockaddr_in serv_addr ;
char server[256] ;
char ipc[32] ;
int port ;
memset ( (char *) &serv_addr, 0, sizeof(serv_addr) ) ;
parsename ( name, default_port, server, &port ) ;
name2ip(server, (struct in_addr *)&serv_addr.sin_addr.s_addr, ipc ) ;
serv_addr.sin_family = AF_INET ;
serv_addr.sin_port = htons ( port ) ;
if ( (fd = socket(PF_INET, SOCK_STREAM, 0 )) < 0 ) {
register_error ( 1, "Can't open stream socket\n" ) ;
fd = -1 ;
} else if ( connect(fd,
(struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0 ) {
close ( fd ) ;
fd = -1 ;
} else {
ignoreSIGPIPE() ;
}
return fd ;
}
static void parseapplication(void)
{
if(tokentype == TYPEID)
{
int count = 1;
push(gettemplate(tokenval));
gettoken();
while(tokentype == NUMBER
|| tokentype == IDENTIFIER
|| tokentype == TYPEID
|| tokentype == CHARACTER
|| tokentype == STRING
|| tokentype == LPAR
|| tokentype == LBRACK
|| tokentype == LACC)
{
parseterm();
count++;
}
makecompound(STRUCT, count);
}
else if(tokentype == OPERATOR)
parsename();
else
parseterm();
while(tokentype == NUMBER
|| tokentype == IDENTIFIER
|| tokentype == TYPEID
|| tokentype == CHARACTER
|| tokentype == STRING
|| tokentype == LPAR
|| tokentype == LBRACK
|| tokentype == LACC)
{
parseterm();
makeinverse(APPLY);
}
if(tokentype == OPERATOR && strcmp(tokenval, ":") == 0)
{
gettoken();
if(tokentype == RPAR)
{
push(gettemplate(":"));
make(APPLY);
}
else
{
parseapplication();
makeinverse(LIST);
}
}
}
/*
* Return 1 when s is an exotic name, 0 otherwise. s remains unchanged,
* the exotic name, if exists, is saved in d_buf.
*/
static int
exotic(const char *in_str)
{
static char *buff = 0;
static size_t buf_size;
size_t sym_len = strlen(in_str) + 1;
int tag = 0;
char *s;
/*
* We will need to modify the symbol (in_str) as we are analyzing it,
* so copy it into a buffer so that we can play around with it.
*/
if (buff == NULL) {
buff = malloc(DEF_MAX_SYM_SIZE);
buf_size = DEF_MAX_SYM_SIZE;
}
if (sym_len > buf_size) {
if (buff)
free(buff);
buff = malloc(sym_len);
buf_size = sym_len;
}
if (buff == NULL) {
(void) fprintf(stderr, gettext(
"%s: cannot allocate memory\n"), prog_name);
exit(NOALLOC);
}
s = strcpy(buff, in_str);
if (strncmp(s, "__sti__", 7) == 0) {
s += 7; tag = 1;
parse_fn_and_print(ctor_str, s);
} else if (strncmp(s, "__std__", 7) == 0) {
s += 7; tag = 1;
parse_fn_and_print(dtor_str, s);
} else if (strncmp(s, "__vtbl__", 8) == 0) {
s += 8; tag = 1;
parsename(s);
(void) sprintf(d_buf, vtbl_str, p_buf);
} else if (strncmp(s, "__ptbl_vec__", 12) == 0) {
s += 12; tag = 1;
parse_fn_and_print(ptbl_str, s);
}
return (tag);
}
static void parselefthandside(void)
{
parseapplication();
for(;;)
if(tokentype == OPERATOR && strcmp(tokenval, "=") != 0)
{
parsename();
makeinverse(APPLY);
}
else if(tokentype == LPAR)
{
gettoken();
parseexpression(MAXPRIO);
makeinverse(APPLY);
if(tokentype != RPAR) parseerror(2);
gettoken();
}
else
break;
}
int
gst_gl_shadervariables_parse (GstGLShader * shader, char *variables,
int (*_setvariable) (GstGLShader * shader,
struct gst_gl_shadervariable_desc * v))
{
char *p = 0;
char *p0;
char *e;
char e1 = 0;
char *t = 0;
char *varname;
char *vartype;
char *varvalue;
int arraysize = 0;
char *saveptr = variables;
int line = 1;
char *lim;
int i;
int len;
struct gst_gl_shadervariable_desc ret;
if (!_setvariable) {
_setvariable = gst_gl_shadervariable_set;
}
if (!variables)
return 0;
p0 = variables;
trimright (p0, " \t\n");
lim = variables + strlen (variables);
e = strchr (p0, ';');
while (p0 < lim) {
if (!e) {
if (p0[0])
goto parse_error;
break;
}
e1 = e[1];
e[1] = 0;
p = g_strdup (p0);
e[1] = e1;
trimright (p, " \t");
trimleft (p, " \t\n");
t = strtok_r (p, " \t", &saveptr);
if (!t)
goto parse_error;
trimleft (t, " \t");
trimright (t, " \t\n");
if (t[0]) {
if (!strcmp (t, "const")) {
t = strtok_r (0, " \t", &saveptr);
if (!t)
goto parse_error;
trimleft (t, " \t");
if (!t[0])
goto parse_error;
}
// parse data type
for (i = 0; i < _datatypecount; ++i) {
if (!strcmp (t, gst_gl_shadervariable_datatype[i])) {
ret.type = (gst_gl_shadervariable_datatypeindex) i;
break;
}
}
if (i == _datatypecount)
goto parse_error;
vartype = g_strdup (t);
GST_INFO ("vartype : '%s'\n", vartype);
trimleft (saveptr, " \t");
t = saveptr;
if (*saveptr == '=')
goto parse_error;
// parse variable name and array size
t = parsename (&varname, &arraysize, &saveptr);
if (t)
goto parse_error;
trimright (varname, " \t");
GST_INFO ("varname : '%s'\n", varname);
GST_INFO ("arraysize : %d\n", arraysize);
// check type cast after assignement operator
t = strtok_r (0, "(", &saveptr);
if (!t)
goto parse_error;
trimleft (t, " \t");
trimright (t, " \t");
if (arraysize) {
char *s = g_malloc (strlen (vartype) + 32);
sprintf (s, "%s[%d]", vartype, arraysize);
if (strcmp (t, s)) {
g_free (s);
goto parse_error;
}
} else {
if (strcmp (t, vartype))
goto parse_error;
}
// extract variable value
t = strtok_r (0, ";", &saveptr);
if (!t)
goto parse_error;
trimleft (t, " \t");
trimright (t, " \t");
if (!t[0])
goto parse_error;
if (*(saveptr - 2) != ')')
goto parse_error;
*(saveptr - 2) = 0;
if (!t[0])
goto parse_error;
varvalue = g_strdup (t);
GST_INFO ("value: %s\n\n", varvalue);
t = saveptr;
if (t[0])
goto parse_error;
// parse variable value
len = strlen (varvalue);
ret.name = varname;
ret.arraysize = arraysize;
t = parsevalue (varvalue, saveptr, &ret);
if (t) {
t -= len;
goto parse_error;
}
// set variable value
_setvariable (shader, &ret);
fflush (0);
}
// Tell me why we cannot free(p) whithout segfault.
//g_free(p);
p0 = e + 1;
++line;
e = strchr (p0, ';');
}
return 0;
parse_error:
if (!t) {
t = saveptr;
}
if (!e) {
t = p = p0;
} else {
e[1] = 0;
trimleft (p0, " \t\n");
GST_ERROR ("\n%s", p0);
e[1] = e1;
}
GST_ERROR ("parse error on line %d, position %ld (%s)", line, (glong) (t - p),
t);
return -1;
}
static fz_error parsedict(fz_obj **obj, pdf_xref *xref, char **sp, struct vap *v)
{
fz_error error = fz_okay;
fz_obj *dict = nil;
fz_obj *key = nil;
fz_obj *val = nil;
char *s = *sp;
error = fz_newdict(&dict, 8);
if (error)
return fz_rethrow(error, "cannot create dict");
s += 2; /* skip "<<" */
while (*s)
{
skipwhite(&s);
/* end-of-dict marker >> */
if (*s == '>')
{
s ++;
if (*s == '>')
{
s ++;
break;
}
error = fz_throw("malformed >> marker");
goto cleanup;
}
/* non-name as key, bail */
if (*s != '/')
{
error = fz_throw("key is not a name");
goto cleanup;
}
error = parsename(&key, &s);
if (error)
{
error = fz_rethrow(error, "cannot parse key");
goto cleanup;
}
skipwhite(&s);
error = parseobj(&val, xref, &s, v);
if (error)
{
error = fz_rethrow(error, "cannot parse value");
goto cleanup;
}
error = fz_dictput(dict, key, val);
if (error)
{
error = fz_rethrow(error, "cannot insert dict entry");
goto cleanup;
}
fz_dropobj(val); val = nil;
fz_dropobj(key); key = nil;
}
*obj = dict;
*sp = s;
return fz_okay;
cleanup:
if (val) fz_dropobj(val);
if (key) fz_dropobj(key);
if (dict) fz_dropobj(dict);
*obj = nil;
*sp = s;
return error; /* already rethrown */
}
int
stabs2acid(Stab *stabs, Biobuf *b)
{
volatile int fno, i;
char c, *desc, *p;
char *volatile dir, *volatile fn, *volatile name;
Ftypes *f;
Type *t, *tt;
StabSym sym;
dir = nil;
fno = 0;
fn = nil;
for(i=0; stabsym(stabs, i, &sym)>=0; i++){
if(verbose)
print("%d %s\n", sym.type, sym.name);
switch(sym.type){
case N_SO:
if(sym.name){
if(sym.name[0] && sym.name[strlen(sym.name)-1] == '/')
dir = sym.name;
}
denumber();
fstack = nil;
fno = 0;
break;
case N_BINCL:
fno++;
f = mkftypes(dir, sym.name);
f->down = fstack;
fstack = f;
break;
case N_EINCL:
if(fstack)
fstack = fstack->down;
break;
case N_EXCL:
fno++;
if((f = findftypes(dir, sym.name)) == nil){
static int cannotprint;
if(cannotprint++ == 0)
fprint(2, "cannot find remembered %s\n", sym.name);
continue;
}
renumber(f->list, fno);
break;
case N_GSYM:
case N_FUN:
case N_PSYM:
case N_LSYM:
case N_LCSYM:
case N_STSYM:
case N_RSYM:
name = sym.name;
if(name == nil){
if(sym.type==N_FUN)
fn = nil;
continue;
}
if((p = findcolon(name)) == nil)
continue;
name = estrndup(name, p-name);
desc = ++p;
c = *desc;
if(c == 'c'){
fprint(2, "skip constant %s\n", name);
continue;
}
if(setjmp(kaboom)){
static int cannotparse;
if(cannotparse++ == 0)
fprint(2, "cannot parse %s\n", name);
continue;
}
t = parsename(desc, &p);
if(t == nil)
continue;
if(*p != 0){
static int extradesc;
if(extradesc++ == 0)
fprint(2, "extra desc '%s' in '%s'\n", p, desc);
}
/* void is defined as itself */
if(t->ty==Defer && t->sub==t && strcmp(name, "void")==0){
t->ty = Base;
t->xsizeof = 0;
t->printfmt = '0';
}
if(*name==' ' && *(name+1) == 0)
*name = 0;
/* attach names to structs, unions, enums */
if(c=='T' && *name && t->sue){
t->suename = name;
if(t->name == nil)
t->name = name;
tt = typebysue(t->sue, name);
tt->ty = Defer;
tt->sub = t;
}
if(c=='t'){
tt = newtype();
tt->ty = Typedef;
tt->name = name;
tt->sub = t;
}
/* define base c types */
if(t->ty==None || t->ty==Range){
if(strcmp(name, "char") == 0){
t->ty = Base;
t->xsizeof = 1;
t->printfmt = 'x';
}
if(strcmp(name, "int") == 0){
t->ty = Base;
t->xsizeof = 4;
t->printfmt = 'd';
}
}
/* record declaration in list for later. */
if(c != 't' && c != 'T')
switch(sym.type){
case N_GSYM:
addsymx(nil, name, t);
break;
case N_FUN:
fn = name;
break;
case N_PSYM:
case N_LSYM:
case N_LCSYM:
case N_STSYM:
case N_RSYM:
addsymx(fn, name, t);
break;
}
break;
}
if(1) print("");
}
printtypes(b);
dumpsyms(b);
freetypes();
return 0;
}
static void parseterm(void)
{
int count;
switch(tokentype)
{
case NUMBER:
if(strchr(tokenval, '.') == NULL)
makeINT(atol(tokenval));
else
makeREAL(atof(tokenval));
gettoken();
break;
case IDENTIFIER:
parsename();
break;
case TYPEID:
push(gettemplate(tokenval));
makecompound(STRUCT, 1);
gettoken();
break;
case CHARACTER:
makeconstant(CHAR, tokenval[0]);
gettoken();
break;
case STRING:
buildstring(tokenval);
gettoken();
break;
case LPAR:
gettoken();
if(tokentype == OPERATOR && strcmp(tokenval, "-") != 0)
{
parsename();
if(tokentype != RPAR)
{
parseexpression(MAXPRIO);
rotatestack();
push(gettemplate("_section"));
make(APPLY);
make(APPLY);
}
}
else if(tokentype == RPAR)
makeconstant(NULLTUPLE, 0);
else
{
parseexpression(MAXPRIO);
if(tokentype == COMMA)
{
count = 1;
while(tokentype == COMMA)
{
gettoken();
parseexpression(MAXPRIO);
count++;
}
makecompound(PAIR, count);
}
}
if(tokentype != RPAR) parseerror(2);
gettoken();
break;
case LBRACK:
parselist();
break;
case LACC:
count = 0;
do
{
gettoken();
if(tokentype != IDENTIFIER) parseerror(25);
push(gettemplate(tokenval));
gettoken();
if(strcmp(tokenval, "=") != 0) parseerror(5);
gettoken();
parseexpression(MAXPRIO);
makeinverse(ALIAS);
count++;
}
while(tokentype == COMMA);
makecompound(RECORD, count);
if(tokentype != RACC) parseerror(33);
gettoken();
break;
default:
parseerror(3);
}
}
