pike.git / src / pike_types.cmod

version» Context lines:

pike.git/src/pike_types.cmod:722:    /* Special case... */    push_type(T_ZERO);    } else {    *(++Pike_compiler->type_stackp) = mk_type(T_INT,    (void *)(ptrdiff_t)min,    (void *)(ptrdiff_t)max, 0);    }    TYPE_STACK_DEBUG("push_int_type");   }    + /** +  * Used with arrays and strings. +  * +  * On entry the type stack contains the value type. +  * +  * Generates an array or string type with no length limits. +  */ + void debug_push_unlimited_array_type(enum PIKE_TYPE t) + { +  struct compilation * c = MAYBE_THIS_COMPILATION; + #ifdef PIKE_DEBUG +  if ((t != PIKE_T_ARRAY) && (t != PIKE_T_STRING)) { +  Pike_fatal("Invalid type for push_array_type(): %s (%d)\n", +  get_name_of_type(t), t); +  } + #endif +  /* FIXME: Set car to unlimited length. */ +  push_type(t); + } +    static int (*program_id_to_id)(int) = NULL;      PMOD_EXPORT void set_program_id_to_id( int (*to)(int) )   {    program_id_to_id = to;   }      void debug_push_object_type(int flag, INT32 id)   {    if( program_id_to_id )
pike.git/src/pike_types.cmod:1294:    } else if (field == (BIT_BASIC|BIT_COMPLEX)) {    /* All values. */    push_type(T_MIXED);    } else {    /* Check the bits... */    push_type(T_ZERO);       if (field & BIT_COMPLEX) {    if (field & BIT_ARRAY) {    push_type(T_MIXED); -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    push_type(T_OR);    }    if (field & BIT_MAPPING) {    push_type(T_MIXED);    push_type(T_MIXED);    push_type(T_MAPPING);    push_type(T_OR);    }    if (field & BIT_MULTISET) {    push_type(T_MIXED);
pike.git/src/pike_types.cmod:1329:    }    if (field & BIT_PROGRAM) {    push_object_type(0, 0);    push_type(T_PROGRAM);    push_type(T_OR);    }    }    if (field & BIT_BASIC) {    if (field & BIT_STRING) {    push_int_type(MIN_INT32, MAX_INT32); -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    push_type(T_OR);    }    if (field & BIT_TYPE) {    push_type(T_MIXED);    push_type(T_TYPE);    push_type(T_OR);    }    if (field & BIT_INT) {    push_int_type(MIN_INT32, MAX_INT32);    push_type(T_OR);
pike.git/src/pike_types.cmod:1631:    } else {    max = MAX_INT32;    }    if(**s != ')') yyerror("Missing ')' in string width.");    else    ++*s;    push_int_type(min, max);    } else {    push_finished_type(int_type_string);    } -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    break;    }    goto bad_type;       case 'v':    if(!strcmp(buf,"void")) { push_type(T_VOID); break; }    goto bad_type;       case 't':    if (!strcmp(buf,"tuple"))
pike.git/src/pike_types.cmod:1725:    if(**s == '(')    {    ++*s;    internal_parse_type(_s);    if(**s != ')') yyerror("Expected ')'.");    else    ++*s;    }else{    push_type(T_MIXED);    } -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    break;    }    goto bad_type;       case '_':    if (!strcmp(buf, "__attribute__")) {    while(isspace(**s)) ++*s;    if(**s == '(')    {    struct pike_string *attr;
pike.git/src/pike_types.cmod:1843:   static void internal_parse_typeCC(const char **s)   {    internal_parse_typeB(s);       while(isspace(EXTRACT_UCHAR(*s))) ++*s;       while(**s == '*')    {    ++*s;    while(isspace(EXTRACT_UCHAR(*s))) ++*s; -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    }   }      static void internal_parse_typeC(const char **s)   {    internal_parse_typeCC(s);       if(**s == '&')    {    ++*s;
pike.git/src/pike_types.cmod:2746:    t = t1;    ret = -1;    } else {    t = t2;    ret = 1;    }    break;    case T_STRING:    {    low_or_pike_types(t1->cdr, t2->cdr, 1); -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    return 0;    }    break;    case T_OBJECT:    if (!CDR_TO_INT(t1)) {    t = t1;    } else if (!CDR_TO_INT(t2)) {    t = t2;    } else if (CDR_TO_INT(t1) < CDR_TO_INT(t2)) {    t = t1;
pike.git/src/pike_types.cmod:2921:    max1 = MAXIMUM(max1, max2);       push_int_type(min1, max1);    }    }    break;    case T_STRING:    {    Pike_compiler->type_stackp--;    low_or_pike_types(t->cdr, top->cdr, 1); -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    free_type(top);    }    break;    case T_OBJECT:    if (CDR_TO_INT(top)) {    push_finished_type(t);    }    break;    case T_ARRAY:    Pike_compiler->type_stackp--;    low_or_pike_types(t->cdr, top->cdr, zero_implied); -  push_type(t->type); +  push_unlimited_array_type(t->type);    free_type(top);    break;    case T_MULTISET:    Pike_compiler->type_stackp--;    low_or_pike_types(t->car, top->car, zero_implied);    push_type(t->type);    free_type(top);    break;    case T_MAPPING:    if (t->car == top->car) {
pike.git/src/pike_types.cmod:3113:    i2 = CAR_TO_INT(t2);    lower_bound = MAXIMUM(i1,i2);       if (upper_bound >= lower_bound) {    push_int_type(lower_bound, upper_bound);    push_type(T_OR);    }    } else if (t1->type == T_STRING) {    push_type(T_ZERO);    even_lower_and_pike_types(t1->cdr, t2->cdr); -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    push_type(T_OR);    } else {    push_finished_type(t1);    push_type(T_OR);    }    }   }      static int lower_and_pike_types(struct pike_type *t1, struct pike_type *t2)   {
pike.git/src/pike_types.cmod:3242:    push_scope_type(CAR_TO_INT(t1));    }    }    else if (t2->type == T_SCOPE)    {    low_and_pike_types(t1, t2->cdr);    push_scope_type(CAR_TO_INT(t2));    }    else if ((t1->type == T_STRING) && (t2->type == T_STRING)) {    low_and_pike_types(t1->cdr, t2->cdr); -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    }    else if((t1->type == T_FLOAT) && (t2->type == T_FLOAT))    {    push_finished_type(t1);    }    else if(low_pike_types_le(t1, t2, 0, 0))    {    push_finished_type(t1);    }    else if(low_pike_types_le(t2, t1, 0, 0))
pike.git/src/pike_types.cmod:4103:    }       if(ret && (!aa_markers[m] || (b->type != T_VOID)))    {    struct pike_type *tmp;    int i;       type_stack_mark();    push_finished_type_with_markers(b, bb_markers, 0);    for(i=array_cnt; i > 0; i--) -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    tmp=pop_unfinished_type();       type_stack_mark();    low_or_pike_types(aa_markers[m], tmp, 0);    if(aa_markers[m]) free_type(aa_markers[m]);    free_type(tmp);    aa_markers[m] = pop_unfinished_type();   #ifdef PIKE_TYPE_DEBUG    if (l_flag>2) {    if (flags & LE_A_B_SWAPPED) {
pike.git/src/pike_types.cmod:4266:       if(ret && (!bb_markers[m] || a->type != T_VOID))    {    int m = CAR_TO_INT(b);    struct pike_type *tmp;    int i;       type_stack_mark();    push_finished_type_with_markers(a, aa_markers, 0);    for(i = array_cnt; i < 0; i++) -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    tmp=pop_unfinished_type();       type_stack_mark();    low_or_pike_types(bb_markers[m], tmp, 0);    if(bb_markers[m]) free_type(bb_markers[m]);    free_type(tmp);    bb_markers[m] = pop_unfinished_type();   #ifdef PIKE_TYPE_DEBUG    if (l_flag>2) {    if (flags & LE_A_B_SWAPPED) {
pike.git/src/pike_types.cmod:4778:    case PIKE_T_ATTRIBUTE:    if (low_get_return_type(a->cdr, b)) {    push_type_attribute((struct pike_string *)a->car);    return 1;    }    return 0;       case T_ARRAY:    tmp = low_get_return_type(a->cdr, b);    if(!tmp) return 0; -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    return 1;    }       a = low_match_types(a, b, NO_SHORTCUTS);    if(a)    {   #if 0    if ((c->lex.pragmas & ID_STRICT_TYPES) &&    !low_pike_types_le(a, b, 0, 0)) {    yyreport_type(REPORT_WARNING, NULL, 0, b, NULL, 0, a, 0, "Type mismatch");
pike.git/src/pike_types.cmod:5006:    case T_ARRAY:    {    struct pike_type *a;       if(low_pike_types_le(string0_type_string, index_type, 0, 0) &&    (a = low_index_type(t->cdr, string0_type_string, n))) {    /* Possible to index the array with a string. */    type_stack_mark();    push_finished_type(a);    free_type(a); -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);       if (low_match_types(int_type_string, index_type, 0)) {    /* Also possible to index the array with an int. */    push_finished_type(t->cdr);    push_type(T_OR);    }    return pop_unfinished_type();    }    if (low_match_types(int_type_string, index_type, 0)) {    /* Possible to index the array with an int. */
pike.git/src/pike_types.cmod:5708:    return fun->car;       case T_MIXED:    add_ref(fun);    return fun;       case T_ARRAY:    if (arg_no < 0) {    type_stack_mark();    push_finished_type(fun = get_argument_type(fun->cdr, arg_no)); -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    free_type(fun);    return pop_unfinished_type();    }    return get_argument_type(fun->car, arg_no);       case PIKE_T_ATTRIBUTE:    type_stack_mark();    push_finished_type(tmp = get_argument_type(fun->cdr, arg_no));    push_type_attribute((struct pike_string *)(fun->car));    free_type(tmp);
pike.git/src/pike_types.cmod:6023:    soft_type = tmp3;    } else {    soft_type = soft_type->cdr;    }    if (!(tmp2 = soft_cast(soft_type, orig_type, flags))) {    goto function_cast_fail;    }    push_finished_type(tmp2);    free_type(tmp2);    tmp2 = NULL; -  while(array_cnt--) push_type(T_ARRAY); +  while(array_cnt--) push_unlimited_array_type(T_ARRAY);    push_reverse_type(T_MANY);    while(loop_cnt--) push_reverse_type(T_FUNCTION);    res = pop_unfinished_type();    break;    }    function_cast_fail:    type_stack_pop_to_mark();    break;    case T_NOT: /* FIXME. */    default:
pike.git/src/pike_types.cmod:6077:    break;    case T_ARRAY:    type_stack_mark();    if ((tmp = soft_cast(soft_type->cdr, orig_type->cdr, flags))) {    push_finished_type(tmp);    } else if (flags & SOFT_WEAKER) {    push_finished_type(mixed_type_string);    } else {    push_finished_type(zero_type_string);    } -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    res = pop_unfinished_type();    break;    case T_STRING:    res = soft_cast(soft_type->cdr, orig_type->cdr, flags);    if (!res) return NULL;    type_stack_mark();    push_finished_type(res);    free_type(res); -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    res = pop_unfinished_type();    break;    case T_INT:    {    INT32 min, max;    if (flags & SOFT_WEAKER) {    if ((min = CAR_TO_INT(soft_type)) > CAR_TO_INT(orig_type)) {    min = CAR_TO_INT(orig_type);    }    if ((max = CDR_TO_INT(soft_type)) < CDR_TO_INT(orig_type)) {
pike.git/src/pike_types.cmod:6537:    fprintf(stderr, "\n");    }   #endif /* PIKE_DEBUG */    return res;    }       type_stack_mark();    push_finished_type(res);    free_type(res);    while(array_cnt--) { -  push_type(PIKE_T_ARRAY); +  push_unlimited_array_type(PIKE_T_ARRAY);    }    res = pop_type();      #ifdef PIKE_DEBUG    if (Pike_interpreter.trace_level > 2) {    fprintf(stderr, " ==> ");    simple_describe_type(res);    fprintf(stderr, "\n");    }   #endif /* PIKE_DEBUG */
pike.git/src/pike_types.cmod:6911:    fprintf(stderr, "\n");    }   #endif /* PIKE_DEBUG */    return res;    }       type_stack_mark();    push_finished_type(res);    free_type(res);    while(array_cnt--) { -  push_type(PIKE_T_ARRAY); +  push_unlimited_array_type(PIKE_T_ARRAY);    }    res = pop_unfinished_type();      #ifdef PIKE_DEBUG    if (l_flag>2) {    fprintf(stderr, "%*s==> ", indent*2, "");    simple_describe_type(res);    fprintf(stderr, "\n");    }   #endif /* PIKE_DEBUG */
pike.git/src/pike_types.cmod:7280:       type_stack_mark();       /* Get rid of any remaining markers. */    clear_markers();    push_finished_type_with_markers(res, a_markers, 0);       free_type(res);       while(array_cnt--) { -  push_type(PIKE_T_ARRAY); +  push_unlimited_array_type(PIKE_T_ARRAY);    }      #ifdef PIKE_DEBUG    if (l_flag>2) {    fprintf(stderr, "Done.\n");    }   #endif /* PIKE_DEBUG */       return pop_unfinished_type();   }
pike.git/src/pike_types.cmod:7370:    free_type(tmp);    push_type(arg_type->type);    return pop_unfinished_type();       case T_ARRAY:    /* Keep void! */    tmp = low_get_first_arg_type(arg_type->cdr, flags|FILTER_KEEP_VOID);    type_stack_mark();    push_finished_type(tmp);    free_type(tmp); -  push_type(arg_type->type); +  push_unlimited_array_type(arg_type->type);    return pop_unfinished_type();       case T_MAPPING:    case T_TUPLE:    /* Keep void! */    type_stack_mark();    tmp = low_get_first_arg_type(arg_type->cdr, flags|FILTER_KEEP_VOID);    push_finished_type(tmp);    free_type(tmp);    tmp = low_get_first_arg_type(arg_type->car, flags|FILTER_KEEP_VOID);
pike.git/src/pike_types.cmod:8014:    }    push_finished_type(arg_type);    free_type(arg_type);    }   #else /* !0 */    if (a->size) {    push_type_field(a->type_field);    }else    push_finished_type(zero_type_string);   #endif /* 0 */ -  push_type(T_ARRAY); +  push_unlimited_array_type(T_ARRAY);    return pop_unfinished_type();    }       case T_MULTISET:    type_stack_mark();    if (multiset_sizeof(s->u.multiset)) {    push_type(T_MIXED);    }    else {    push_type(T_ZERO);
pike.git/src/pike_types.cmod:8141:       case T_STRING:    type_stack_mark();    if (s->u.string->len) {    INT32 min, max;    check_string_range( s->u.string, 0, &min, &max );    push_int_type(min, max);    } else {    push_type(T_ZERO);    } -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    return pop_unfinished_type();       default:    type_stack_mark();    push_type(TYPEOF(*s));    return pop_unfinished_type();    }   }      
pike.git/src/pike_types.cmod:8404:    case T_MAPPING:    case PIKE_T_RING:    /* Order dependant */    low_make_pike_type(type_string+1, cont);    low_make_pike_type(*cont, cont);    push_reverse_type(type);    break;    case T_FUNCTION:    low_make_function_type(type_string+1, cont);    break; -  case T_ARRAY: +     case T_MULTISET:    case T_TYPE:    case T_NOT:    case T_PROGRAM:    low_make_pike_type(type_string+1, cont);    push_reverse_type(type);    break;    case '0':    case '1':    case '2':
pike.git/src/pike_types.cmod:8437:    case T_ZERO:    case PIKE_T_UNKNOWN:    /* Leaf type */    *cont = type_string+1;    push_type(type);    break;       case T_STRING:    *cont = type_string + 1;    push_finished_type(int_type_string); -  push_type(T_STRING); +  push_unlimited_array_type(T_STRING);    break;       case PIKE_T_NSTRING: -  +  type = T_STRING; +  /* FALLTHRU */ +  case T_ARRAY:    low_make_pike_type(type_string + 1, cont); -  /* FIXME: Add check for valid subtype. */ -  push_type(T_STRING); +  /* FIXME: Add check for valid subtype in the string case. */ +  push_unlimited_array_type(type);    break;       case T_INT:    {    INT32 min = extract_type_int((char *)type_string+1);    INT32 max = extract_type_int((char *)type_string+5);       *cont = type_string + 9; /* 2*sizeof(INT32) + 1 */    push_int_type(min, max);    break;