Changeset 1153


Ignore:
Timestamp:
Aug 11, 2003, 2:04:21 PM (17 years ago)
Author:
luba
Message:
  • checking of argument of type_int is added
Location:
to-imperative/trunk/library
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/library/Convert/bytes_to_chars.cc

    r1132 r1153  
    2929    if (p->get_type() == type_int) {
    3030      Integer* P = static_cast<Integer*>(p);
    31       intptr_t l = P->to_int();
    32       if (P->cmp(0) < 0 || uintptr_t(l) > SIZE_MAX)
     31      if (P->cmp(0) < 0 || P->cmp(SIZE_MAX) > 0)
    3332        RF_LIB_ERROR("Invalid argument");
    3433    }
  • to-imperative/trunk/library/String/string_ref.cc

    r1133 r1153  
    2525      if (p_Index->get_type() == type_int) {
    2626        Integer* Ind = static_cast<Integer*>(p_Index);
    27         intptr_t i = Ind->to_int();
    28         if (Ind->cmp(0) < 0 || uintptr_t(i) > SIZE_MAX)
     27        if (Ind->cmp(0) < 0 || Ind->cmp(SIZE_MAX) > 0)
    2928          RF_LIB_ERROR("Invalid argument");
    3029        else
    31           ind = i;
     30          ind = Ind->to_int();
    3231      }
    3332      else
  • to-imperative/trunk/library/String/string_set.cc

    r1111 r1153  
    2525    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2626
    27     Term* p_Index = s_Index.get_first();
    28     rftype::Int32* Ind = p_Index->cast_to<rftype::Int32>(type_int32);
    29 
    3027    Term* p_Char = s_Char.get_first();
    3128    rftype::Char* ch = p_Char->cast_to<rftype::Char>(type_char);
    32  
    33     if (str && ch && Ind) {
    34       intptr_t ind = Ind->to_int();
    35       if (ind < 0)
    36         RF_LIB_ERROR("Invalid Argument");
    37       else {
    38         wchar_t c = ch->to_wchar_t();
    39         wchar_t const* content = str->get_data();
    40         rftype::String s = rftype::String(content);
    41         s[ind] = c;
     29
     30    Term* p_Index = s_Index.get_first();
     31    intptr_t ind;
     32    if (str && ch ) {
     33      if (p_Index->get_type() == type_int) {
     34        Integer* Ind = static_cast<Integer*>(p_Index);
     35        if (Ind->cmp(0) < 0 || Ind->cmp(SIZE_MAX) > 0)
     36          RF_LIB_ERROR("Invalid Argument");
     37        else
     38          ind = Ind->to_int();
    4239      }
     40      else
     41      if (p_Index->get_type() == type_int32) {
     42        Int32* Ind = static_cast<Int32*>(p_Index);
     43        ind = Ind->to_int();
     44        if (ind < 0)
     45          RF_LIB_ERROR("Invalid Argument");
    4346    }
    4447    else
    4548      RF_LIB_ERROR("Invalid Argument");
     49    }
     50    wchar_t c = ch->to_wchar_t();
     51    wchar_t const* content = str->get_data();
     52    rftype::String s = rftype::String(content);
     53    s[ind] = c;
    4654  }
    4755  else
  • to-imperative/trunk/library/String/substring.cc

    r1111 r1153  
    1919    Term* p_String = s_String.get_first();
    2020    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
     21    intptr_t ind, len;
     22    if (str) {
     23      Term* p_Ind = s_Index.get_first();
     24      if (p_Ind->get_type() == type_int) {
     25        Integer* Ind = static_cast<Integer*>(p_Ind);
     26        if (Ind->cmp(0) < 0 || Ind->cmp(SIZE_MAX) > 0)
     27          RF_LIB_ERROR ("Invalid argument");
     28        else
     29          ind = Ind->to_int();         
     30      }
     31      if (p_Ind->get_type() == type_int32) {
     32        Int32* Ind = static_cast<Int32*>(p_Ind);
     33        intptr_t i = Ind->to_int();
     34        if (i < 0)
     35          RF_LIB_ERROR ("Invalid argument");
     36        else
     37          ind = i;
     38      }
    2139
    22     Term* p_Index = s_Index.get_first();
    23     rftype::Int32* Ind = p_Index->cast_to<rftype::Int32>(type_int32);
    24    
    25     Term* p_Len = s_Len.get_first();
    26     rftype::Int32* Len = p_Len->cast_to<rftype::Int32>(type_int32);
    27    
    28     if (str && Ind && Len) {
    29       intptr_t ind = Ind->to_int();
    30       intptr_t len = Len->to_int();
    31       if (ind < 0 || len < 0)
    32         RF_LIB_ERROR ("Invalid argument");
     40      Term* p_Len = s_Len.get_first();
     41
     42      if (p_Len->get_type() == type_int) {
     43        Integer* Len = static_cast<Integer*>(p_Len);
     44        if (Len->cmp(0) < 0 || Len->cmp(SIZE_MAX) > 0)
     45          RF_LIB_ERROR ("Invalid argument");
     46        else
     47          len = Len->to_int();         
     48      }
     49      if (p_Len->get_type() == type_int32) {
     50        Int32* Len = static_cast<Int32*>(p_Len);
     51        intptr_t l = Len->to_int();
     52        if (l < 0)
     53          RF_LIB_ERROR ("Invalid argument");
     54        else
     55          len = l;
     56      }
     57      intptr_t str_len = str->get_length();
     58      if ((str_len <= ind) || ((ind + len) > str_len))
     59        RF_LIB_ERROR ("Index out of range");
    3360      else {
    34         intptr_t str_len = str->get_length();
    35         if ((str_len <= ind) || ((ind + len) > str_len))
    36           RF_LIB_ERROR ("Index out of range");
    37         else {
    38           rftype::String s = rftype::String (str->substring(ind, len));
    39           s_NewString = Expr(new rftype::String(s)); 
    40         }
     61        rftype::String s = rftype::String (str->substring(ind, len));
     62        s_NewString = Expr(new rftype::String(s)); 
    4163      }
    4264    }
  • to-imperative/trunk/library/String/substring_fill.cc

    r1111 r1153  
    2121    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2222
    23     Term* p_Index = s_Index.get_first();
    24     rftype::Int32* Ind = p_Index->cast_to<rftype::Int32>(type_int32);
    25    
    26     Term* p_Len = s_Len.get_first();
    27     rftype::Int32* Len = p_Len->cast_to<rftype::Int32>(type_int32);
    28 
    2923    Term* p_Fill = s_Fill.get_first();
    3024    rftype::Char* Fill = p_Fill->cast_to<rftype::Char>(type_char);
     25
     26    intptr_t ind, len;
    3127   
    3228    if (str && Fill) {
     29      Term* p_Index = s_Index.get_first();
     30      if (p_Index->get_type() == type_int) {
     31        Integer* Ind = static_cast<Integer*>(p_Index);
     32        if (Ind->cmp(0) < 0 || Ind->cmp(SIZE_MAX) > 0)
     33          RF_LIB_ERROR ("Invalid argument");
     34        else
     35          ind = Ind->to_int();         
     36      }
     37      if (p_Index->get_type() == type_int32) {
     38        Int32* Ind = static_cast<Int32*>(p_Index);
     39        intptr_t i = Ind->to_int();
     40        if (i < 0)
     41          RF_LIB_ERROR ("Invalid argument");
     42        else
     43          ind = i;
     44      }
     45
     46      Term* p_Len = s_Len.get_first();
     47
     48      if (p_Len->get_type() == type_int) {
     49        Integer* Len = static_cast<Integer*>(p_Len);
     50        if (Len->cmp(0) < 0 || Len->cmp(SIZE_MAX) > 0)
     51          RF_LIB_ERROR ("Invalid argument");
     52        else
     53          len = Len->to_int();         
     54      }
     55      if (p_Len->get_type() == type_int32) {
     56        Int32* Len = static_cast<Int32*>(p_Len);
     57        intptr_t l = Len->to_int();
     58        if (l < 0)
     59          RF_LIB_ERROR ("Invalid argument");
     60        else
     61          len = l;
     62      }
    3363      wchar_t fill = Fill->to_wchar_t();
    34       intptr_t len = Len->to_int();
    35       intptr_t ind = Ind->to_int();
    3664      intptr_t str_len = str->get_length();
     65
    3766      if (len <= ind || ind + len > str_len)
    3867        RF_LIB_ERROR ("Index out of range");
Note: See TracChangeset for help on using the changeset viewer.