pike.git / src / pike_types.cmod

version» Context lines:

pike.git/src/pike_types.cmod:829:   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_unlimited_array_type(): %s (%d)\n",    get_name_of_type(t), t);    }   #endif    if (!peek_type_stack() || (peek_type_stack()->type == PIKE_T_ZERO)) { -  push_type(PIKE_T_ZERO); +  push_type(t == PIKE_T_STRING ? PIKE_T_UNKNOWN : PIKE_T_ZERO);    } else {    push_int_type(0, MAX_INT32);    }    push_type(t);       TYPE_STACK_DEBUG("push_array_type");   }      static int (*program_id_to_id)(int) = NULL;   
pike.git/src/pike_types.cmod:2785:       case T_STRING:    {    string_builder_strcat(s, "string");    if ((t->cdr == int_type_string) && (t->car == int_pos_type_string)) {    break;    }    string_builder_putchar(s, '(');    if (t->car == zero_type_string) {    /* Zero-length string. */ -  string_builder_strcat(s, "zero"); +  string_builder_strcat(s, "zero:");    } else {    if (t->car != int_pos_type_string) {    low_describe_int_range(s, t->car);    string_builder_strcat(s, ": ");    }    low_describe_int_range(s, t->cdr);    }    string_builder_putchar(s, ')');    break;    }
pike.git/src/pike_types.cmod:3647:       i1 = CAR_TO_INT(t1);    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); +  push_type(PIKE_T_UNKNOWN);    even_lower_and_pike_types(t1->cdr, t2->cdr);    push_unlimited_array_type(T_STRING);    push_type(T_OR);    } else {    push_finished_type(t1);    push_type(T_OR);    }    }   }   
pike.git/src/pike_types.cmod:5681:    0, 0, remap_flags);    } else {    /* Mappings may always result in UNDEFINED on indexing.    * Arrays are typically initialized to all zeroes.    */    tmp2 = low_type_binop(op, a->cdr, b->cdr, remap,    PT_FLAG_CMP_NULLABLE,    PT_FLAG_CMP_NULLABLE,    remap_flags);    } -  if (!tmp2) { +  if (!tmp2 && +  (a->type != PIKE_T_STRING +  || op == PT_BINOP_MINUS || (a->cdr && b->cdr))) {    if (op == PT_BINOP_AND) {    free_type(tmp);    return NULL;    } else if (!tmp) {    return NULL;    }    }    type_stack_mark();    if (op == PT_BINOP_MINUS) {    if (tmp) {
pike.git/src/pike_types.cmod:8024:    INT32 amin = CAR_TO_INT(a);    INT32 amax = CDR_TO_INT(a);       INT32 bmin = CAR_TO_INT(b);    INT32 bmax = CDR_TO_INT(b);       if(amin > bmax || bmin > amax) return 0;    break;    }    -  case T_ARRAY: +     case T_STRING: -  +  if (!a->cdr || !b->cdr) +  break; +  /* FALLTHRU */ +  case T_ARRAY: +     if(!(tmp = low_match_types(a->cdr, b->cdr,    flags & ~(A_EXACT|B_EXACT)))) {    return 0;    }    free_type(tmp);    /* FALLTHRU */       case T_PROGRAM:    case T_TYPE:    case T_MULTISET:
pike.git/src/pike_types.cmod:8915:       case T_TYPE:    case T_PROGRAM:    case T_MULTISET:    if (flags & LE_TYPE_SVALUE) return 1;    a = a->car;    b = b->car;    array_cnt = 0;    goto recurse;    -  case T_ARRAY: +     case T_STRING: -  +  if (!a->car) return 1; +  /* FALLTHRU */ +  case T_ARRAY:    if (flags & LE_TYPE_SVALUE) return 1;    if (!low_pike_types_le(a->car, b->car, 0, flags)) return 0;    a = a->cdr;    b = b->cdr;    array_cnt = 0;    goto recurse;       case T_FLOAT:    case T_ZERO:    case T_VOID:
pike.git/src/pike_types.cmod:12804:    push_type(T_TYPE);    return pop_unfinished_type();       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(PIKE_T_UNKNOWN);    }    push_int_type(s->u.string->len, s->u.string->len);    push_type(T_STRING);    return pop_unfinished_type();       default:    type_stack_mark();    push_type(TYPEOF(*s));    return pop_unfinished_type();    }