pike.git / src / pike_types.c

version» Context lines:

pike.git/src/pike_types.c:1:   /*   || This file is part of Pike. For copyright information see COPYRIGHT.   || Pike is distributed under GPL, LGPL and MPL. See the file COPYING   || for more information. - || $Id: pike_types.c,v 1.214 2003/04/02 19:22:43 mast Exp $ + || $Id: pike_types.c,v 1.215 2003/06/06 14:32:03 grubba Exp $   */      #include "global.h" - RCSID("$Id: pike_types.c,v 1.214 2003/04/02 19:22:43 mast Exp $"); + RCSID("$Id: pike_types.c,v 1.215 2003/06/06 14:32:03 grubba Exp $");   #include <ctype.h>   #include "svalue.h"   #include "pike_types.h"   #include "stralloc.h"   #include "stuff.h"   #include "array.h"   #include "program.h"   #include "constants.h"   #include "object.h"   #include "multiset.h"
pike.git/src/pike_types.c:934:   {    char buf[80];    unsigned int len;    const unsigned char **s = (const unsigned char **)_s;       while(ISSPACE(**s)) ++*s;       len=0;    for(len=0;isidchar(EXTRACT_UCHAR(s[0]+len));len++)    { -  if(len>=sizeof(buf)) Pike_error("Buffer overflow in parse_type\n"); +  if(len>=sizeof(buf)) { +  my_yyerror("Buffer overflow in parse_type(\"%s\") (limit %d).", +  *s, sizeof(buf)); +  push_type(T_MIXED); +  return; +  }    buf[len] = s[0][len];    }    buf[len]=0;    *s += len;       switch(buf[0])    {    case 'z':    if(!strcmp(buf,"zero")) { push_type(T_ZERO); break; }    goto bad_type;
pike.git/src/pike_types.c:959:    while(ISSPACE(**s)) ++*s;    if(**s=='(')    {    INT32 min,max;    ++*s;    while(ISSPACE(**s)) ++*s;    min=STRTOL((const char *)*s,(char **)s,0);    while(ISSPACE(**s)) ++*s;    if(s[0][0]=='.' && s[0][1]=='.')    s[0]+=2; -  else -  Pike_error("Missing .. in integer type.\n"); +  else { +  yyerror("Missing .. in integer type."); +  }       while(ISSPACE(**s)) ++*s;    max=STRTOL((const char *)*s,(char **)s,0);    while(ISSPACE(**s)) ++*s;    -  if(**s != ')') Pike_error("Missing ')' in integer range.\n"); +  if(**s != ')') yyerror("Missing ')' in integer range."); +  else    ++*s;    push_int_type(min, max);    }else{    push_int_type(MIN_INT32, MAX_INT32);    }    break;    }    goto bad_type;       case 'f':
pike.git/src/pike_types.c:1003:    if(**s==',')    {    nargs++;    ++*s;    while(ISSPACE(**s)) ++*s;    }    else if(s[0][0]=='.' && s[0][1]=='.' && s[0][2]=='.')    {    *s+=3;    while(ISSPACE(**s)) ++*s; -  if(**s != ':') -  Pike_error("Missing ':' after ... in function type.\n"); +  if(**s != ':') { +  yyerror("Missing ':' after ... in function type."); +  *s--; +  }    break;    } else {    nargs++;    }    } -  +  /* Skip the colon. */    ++*s;    internal_parse_type(_s); /* return type */    push_reverse_type(T_MANY);       while (nargs-- > 0) {    push_reverse_type(T_FUNCTION);    }    -  if(**s != ')') Pike_error("Missing ')' in function type.\n"); +  if(**s != ')') yyerror("Missing ')' in function type."); +  else    ++*s;    }else{    push_type(T_VOID);    push_type(T_MIXED);    push_type(T_OR);    push_type(T_VOID);    push_type(T_ZERO);    push_type(T_OR);    push_type(T_MANY);    }
pike.git/src/pike_types.c:1109:    goto bad_type;       case 't':    if (!strcmp(buf,"tuple"))    {    while(ISSPACE(**s)) ++*s;    if(**s == '(')    {    ++*s;    internal_parse_type(_s); -  if(**s != ',') Pike_error("Expecting ','.\n"); +  if(**s != ',') yyerror("Expected ','."); +  else    ++*s;    internal_parse_type(_s); -  if(**s != ')') Pike_error("Expecting ')'.\n"); +  if(**s != ')') yyerror("Expected ')'."); +  else    ++*s;    }else{    push_type(T_MIXED);    push_type(T_MIXED);    }    push_reverse_type(T_TUPLE);    break;    }    /* FIXME: Handle type(T) */    if(!strcmp(buf,"type")) { push_type(T_MIXED); push_type(T_TYPE); break; }
pike.git/src/pike_types.c:1134:       case 'm':    if(!strcmp(buf,"mixed")) { push_type(T_MIXED); break; }    if(!strcmp(buf,"mapping"))    {    while(ISSPACE(**s)) ++*s;    if(**s == '(')    {    ++*s;    internal_parse_type(_s); -  if(**s != ':') Pike_error("Expecting ':'.\n"); +  if(**s != ':') yyerror("Expected ':'."); +  else    ++*s;    internal_parse_type(_s); -  if(**s != ')') Pike_error("Expecting ')'.\n"); +  if(**s != ')') yyerror("Expected ')'."); +  else    ++*s;    }else{    push_type(T_MIXED);    push_type(T_MIXED);    }    push_reverse_type(T_MAPPING);    break;    }    if(!strcmp(buf,"multiset"))    {    while(ISSPACE(**s)) ++*s;    if(**s == '(')    {    ++*s;    internal_parse_type(_s); -  if(**s != ')') Pike_error("Expecting ')'.\n"); +  if(**s != ')') yyerror("Expected ')'."); +  else    ++*s;    }else{    push_type(T_MIXED);    }    push_type(T_MULTISET);    break;    }    goto bad_type;       case 'u':
pike.git/src/pike_types.c:1175:    goto bad_type;       case 'a':    if(!strcmp(buf,"array"))    {    while(ISSPACE(**s)) ++*s;    if(**s == '(')    {    ++*s;    internal_parse_type(_s); -  if(**s != ')') Pike_error("Expecting ')'.\n"); +  if(**s != ')') yyerror("Expected ')'."); +  else    ++*s;    }else{    push_type(T_MIXED);    }    push_type(T_ARRAY);    break;    }    goto bad_type;       case '0':
pike.git/src/pike_types.c:1211:    internal_parse_type(_s);    push_assign_type(buf[0]);    }else{    push_type(buf[0]);    }    break;    }       default:    bad_type: -  Pike_error("Couldn't parse type. (%s)\n",buf); +  push_type(T_MIXED); +  my_yyerror("Couldn't parse type. (%s).", buf);    }       while(ISSPACE(**s)) ++*s;   }         static void internal_parse_typeB(const char **s)   {    while(ISSPACE(EXTRACT_UCHAR(*s))) ++*s;    switch(**s)
pike.git/src/pike_types.c:1233:    case '!':    ++*s;    internal_parse_typeB(s);    push_type(T_NOT);    break;       case '(':    ++*s;    internal_parse_type(s);    while(ISSPACE(EXTRACT_UCHAR(*s))) ++*s; -  if(**s != ')') Pike_error("Expecting ')'.\n"); +  if(**s != ')') { +  yyerror("Expected ')' in type."); +  }    ++*s;    break;       default:       internal_parse_typeA(s);    }   }      static void internal_parse_typeCC(const char **s)
pike.git/src/pike_types.c:1299: Inside #if defined(PIKE_DEBUG)
  #ifdef PIKE_DEBUG    struct pike_type **ts=Pike_compiler->type_stackp;    struct pike_type ***ptms=Pike_compiler->pike_type_mark_stackp;   #endif       /* fprintf(stderr, "parse_type(\"%s\")...\n", s); */       TYPE_STACK_DEBUG("parse_type");       type_stack_mark(); +     internal_parse_type(&s);       if( *s ) -  Pike_fatal("Extra junk at end of type definition.\n"); +  yyerror("Extra junk at end of type definition.");       ret=pop_unfinished_type();      #ifdef PIKE_DEBUG    if(ts!=Pike_compiler->type_stackp || ptms!=Pike_compiler->pike_type_mark_stackp)    Pike_fatal("Type stack whacked in parse_type.\n");   #endif       return ret;   }