Changeset 1021


Ignore:
Timestamp:
Jul 17, 2003, 10:12:38 AM (17 years ago)
Author:
luba
Message:
  • String functions
Location:
to-imperative/trunk/library/String
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/library/String/Makefile

    r890 r1021  
    66
    77MODULES = \
    8   string
    9 
    10 
     8  string  \
     9  string_length \
     10  string_fill \
     11  string_init \
     12  string_ref \
     13  string_set \
     14  string_replace \
     15  substring \
     16  substring_fill
    1117
    1218SOURCES = $(addsuffix .cc, $(MODULES))
  • to-imperative/trunk/library/String/string.cc

    r888 r1021  
    44// $Author$
    55
    6 #include <rf_core.hh>
    7 
    8 #include "create_string.hh"
     6#include <rf_core.hh>
    97
    108namespace refal
     
    1816
    1917RF_FUNC (String, (RF_ARG e_Sourse), (RF_RES s_String))
    20  
    21   WString string = create_string(e_Sourse);//, __func__);
    22   //for (size_t i = 0; i < string.get_length(); i++)
    23   //  printf ("string[i] = %c\n", string[i]);
    2418
    25   rftype::String& _str = static_cast<rftype::String&>(string);
    26   rftype::String* str_ptr = &_str;
    27   s_String = rftype::String::create_expr(str_ptr);
    28   // printf ("string end\n");   
     19  Term* p = e_Sourse.get_first();
     20  WString s;
     21 
     22  for (p = e_Sourse.get_first(); p < e_Sourse.get_last(); p++) {
     23     s = s + WString(*p);
     24  }
     25
     26  s_String = Expr(new rftype::String(s)); 
     27   
    2928RF_END
     29
    3030
    3131}
  • to-imperative/trunk/library/String/string_fill.cc

    r369 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_string.hh>
    8 #include <rf_char.hh>
    97
    108namespace refal
     
    1816
    1917RF_FUNC (String_m_Fill, (RF_ARG s_String, s_Fill), ())
     18  if (s_String.get_len() == 1) {
    2019
    21   Term *p_String = s_String.get_first();
    22   Term *p_Fill   = s_String.get_first();
     20    Term* p_String = s_String.get_first();
     21    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2322
    24   if (  p_String->get_type() != RF_TYPE(WString) ||
    25           p_Fill->get_type() != RF_TYPE(Char)
    26      )
    27   {
    28     RF_LIB_ERROR("Invalid argument");
     23    Term* p_Fill = s_Fill.get_first();
     24    rftype::Char* Fill = p_Fill->cast_to<rftype::Char>(type_char);
     25
     26    if (str && Fill) {
     27      wchar_t fill = Fill->to_wchar_t();
     28      wchar_t const* content = str->get_data();
     29      rftype::String s = rftype::String(content);
     30      rftype::String::fill(s, 0, str->get_length(), fill);
     31    }
     32    else
     33      RF_LIB_ERROR("Invalid Argument");
    2934  }
    30 
    31   WString str  = *p_String;
    32   Char fill    = *p_Fill;
    33  
    34   str.fill(0, str.get_len(), fill);
     35  else
     36    RF_LIB_ERROR("Invalid Argument");
    3537
    3638RF_END
  • to-imperative/trunk/library/String/string_init.cc

    r369 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_string.hh>
    8 #include <rf_char.hh>
    9 #include <rf_int.hh>
    10 #include <rf_short_int.hh>
    11 
    127
    138namespace refal
     
    2116
    2217RF_FUNC (String_m_Init, (RF_ARG s_String, s_Len, s_Fill), ())
     18  if (s_String.get_len() == 1) {
    2319
    24   Term *p_String = s_String.get_first();
    25   Term *p_Len    = s_Len.get_first();
    26   Term *p_Fill   = s_Fill.get_first();
     20    Term* p_String = s_String.get_first();
     21    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2722 
    28   if ( p_String->get_type() != RF_TYPE(WString) ||
    29          p_Fill->get_type() != RF_TYPE(Char)
    30      )
    31   {
    32     RF_LIB_ERROR("Invalid argument");
     23    Term* p_Len = s_Len.get_first();
     24    rftype::ShortInt* Len = p_Len->cast_to<rftype::ShortInt>(type_short_int);
     25 
     26    Term* p_Fill = s_Fill.get_first();
     27    rftype::Char* Fill = p_Fill->cast_to<rftype::Char>(type_char);
     28
     29    if (str && Len && Fill) {
     30      intptr_t len = Len->to_int();
     31      if (len < 0)
     32        RF_LIB_ERROR("Invalid Argument");
     33      else {   
     34        wchar_t fill = Fill->to_wchar_t();
     35        rftype::String s = rftype::String(len);
     36        rftype::String::fill(s, 0, len, fill);
     37        str = &s;
     38      }
     39    }
     40    else
     41      RF_LIB_ERROR("Invalid Argument");
    3342  }
     43  else
     44    RF_LIB_ERROR("Invalid Argument");
    3445
    35   uintptr_t length;
    36 
    37   if (p_Len->get_type() == RF_TYPE(Int))
    38   {
    39     Int len = *p_Len;
    40     if (len < 0)
    41       RF_LIB_ERROR("Invalid argument");
    42     length = len.to_uint();
    43   }
    44   else
    45   if (p_Len->get_type() == RF_TYPE(ShortInt))
    46   {
    47     ShortInt len = *p_Len;
    48     if (len < 0)
    49       RF_LIB_ERROR("Invalid argument");
    50     length = len;
    51   }
    52   else
    53   {
    54     RF_LIB_ERROR("Invalid argument");
    55   }
    56 
    57     WString str  = *p_String;
    58     Char fill    = *p_Fill;
    59  
    60   try
    61   {
    62     WString string(length);
    63    
    64     string.fill(0, length, fill);
    65 
    66     str = string;
    67   }
    68   catch (const pxx::SysError &err)
    69   {
    70     if (err.get_code() == ENOMEM)
    71       RF_LIB_ERROR("Size limit excedeed");
    72     throw;
    73   }
    7446
    7547RF_END
  • to-imperative/trunk/library/String/string_length.cc

    r364 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_string.hh>
    8 #include <rf_short_int.hh>
    9 
    107namespace refal
    118{
     
    1815
    1916RF_FUNC (String_m_Length, (RF_ARG s_String), (RF_RES s_Len))
     17  if (s_String.get_len() == 1) {
    2018
    21   Term *p_String = s_String.get_first();
    22 
    23   if (p_String->get_type() != RF_TYPE(WString))
    24   {
    25     RF_LIB_ERROR("Invalid argument");
     19    Term* p_String = s_String.get_first();
     20    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
     21    if (str) {
     22      s_Len = ShortInt::create_expr(str->get_length());
     23    }
     24    else
     25      RF_LIB_ERROR("Invalid Argument");
    2626  }
    27 
    28   s_Len = ShortInt(WString(*p_String).get_len()).to_symbol();
    29 
     27  else
     28    RF_LIB_ERROR("Invalid Argument");
     29   
    3030RF_END
    3131
     
    3333
    3434}
     35 
     36 
  • to-imperative/trunk/library/String/string_ref.cc

    r366 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_string.hh>
    8 #include <rf_char.hh>
    9 #include <rf_int.hh>
    10 #include <rf_short_int.hh>
    117
    128namespace refal
     
    2016
    2117RF_FUNC (String_m_Ref, (RF_ARG s_String, s_Index), (RF_RES s_Char))
     18  if (s_String.get_len() == 1) {
    2219
    23   Term *p_String = s_String.get_first();
    24   Term *p_Index  = s_Index.get_first();
     20    Term* p_String = s_String.get_first();
     21    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2522
    26   if (p_String->get_type() != RF_TYPE(WString))
    27   {
    28     RF_LIB_ERROR("Invalid argument");
     23    Term* p_Index = s_Index.get_first();
     24    rftype::ShortInt* Ind = p_Index->cast_to<rftype::ShortInt>(type_short_int);
     25
     26    if (str && Ind) {
     27      intptr_t ind = Ind->to_int();
     28      if (ind < 0)
     29        RF_LIB_ERROR("Invalid Argument");
     30      else {
     31        wchar_t const* content = str->get_data();
     32        rftype::String s = rftype::String(content);
     33        s_Char  = Char::create_expr(s[ind]);
     34      }
     35    }
     36    else
     37      RF_LIB_ERROR("Invalid Argument");
    2938  }
    30 
    31   uintptr_t index;
    32 
    33   if (p_Index->get_type() == RF_TYPE(Int))
    34   {
    35     Int ind = *p_Index;
    36     if (ind < 0)
    37       RF_LIB_ERROR("Invalid argument");
    38     index = ind.to_uint();
    39   }
    40   else
    41   if (p_Index->get_type() == RF_TYPE(ShortInt))
    42   {
    43     ShortInt ind = *p_Index;
    44     if (ind < 0)
    45       RF_LIB_ERROR("Invalid argument");
    46     index = ind;
    47   }
    48   else
    49   {
    50     RF_LIB_ERROR("Invalid argument");
    51   }
    52    
    53   WString str = *p_String;
    54 
    55   if (index >= str.get_len())
    56   {
    57     RF_LIB_ERROR("Index out of range");
    58   }
    59 
    60   s_Char = Char(str[index]).to_symbol();
     39  else
     40    RF_LIB_ERROR("Invalid Argument");
    6141
    6242RF_END
    6343
    6444}
     45 
     46}
    6547
    66 }
     48
  • to-imperative/trunk/library/String/string_replace.cc

    r364 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_string.hh>
    8 
    9 #include "create_string.hh"
     7#include "String.hh"
    108
    119namespace refal
     
    1917
    2018RF_FUNC (String_m_Replace, (RF_ARG s_String, e_Sourse), ())
     19  if (s_String.get_len() == 1) {
    2120
    22   Term *p_String = s_String.get_first();
    23 
    24   if (p_String->get_type() != RF_TYPE(WString))
    25   {
    26     RF_LIB_ERROR("Invalid argument");
     21    Term* p_String = s_String.get_first();
     22    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
     23    if (str) {
     24      Expr e;
     25      RF_CALL (String, (e_Sourse), (e));
     26      Term* t = e.get_first();
     27      rftype::String* s = t->cast_to<rftype::String>(type_string);
     28      str = s;
     29    }
     30    else
     31      RF_LIB_ERROR("Invalid Argument");
    2732  }
    28 
    29   WString(*p_String) = create_string(e_Sourse, __func__);
    30 
     33  else
     34    RF_LIB_ERROR("Invalid Argument");
     35   
    3136RF_END
    3237
  • to-imperative/trunk/library/String/string_set.cc

    r369 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_char.hh>
    8 #include <rf_string.hh>
    9 #include <rf_int.hh>
    10 #include <rf_short_int.hh>
     7//#include <rf_char.hh>
     8//#include <rf_string.hh>
     9//#include <rf_int.hh>
     10//#include <rf_short_int.hh>
    1111
    1212namespace refal
     
    2020
    2121RF_FUNC (String_m_Set, (RF_ARG s_String, s_Index, s_Char), ())
     22  if (s_String.get_len() == 1) {
    2223
    23   Term *p_String = s_String.get_first();
    24   Term *p_Index  = s_Index.get_first();
    25   Term *p_Char   = s_Char.get_first();
     24    Term* p_String = s_String.get_first();
     25    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2626
    27   if ( p_String->get_type() != RF_TYPE(WString) ||
    28          p_Char->get_type() != RF_TYPE(Char)
    29      )
    30   {
    31     RF_LIB_ERROR("Invalid argument");
     27    Term* p_Index = s_Index.get_first();
     28    rftype::ShortInt* Ind = p_Index->cast_to<rftype::ShortInt>(type_short_int);
     29
     30    Term* p_Char = s_Char.get_first();
     31    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;
     42      }
     43    }
     44    else
     45      RF_LIB_ERROR("Invalid Argument");
    3246  }
    33 
    34   uintptr_t index;
    35 
    36   if (p_Index->get_type() == RF_TYPE(Int))
    37   {
    38     Int ind = *p_Index;
    39     if (ind < 0)
    40       RF_LIB_ERROR("Invalid argument");
    41     index = ind.to_uint();
    42   }
    43   else
    44   if (p_Index->get_type() == RF_TYPE(ShortInt))
    45   {
    46     ShortInt ind = *p_Index;
    47     if (ind < 0)
    48       RF_LIB_ERROR("Invalid argument");
    49     index = ind;
    50   }
    51   else
    52   {
    53     RF_LIB_ERROR("Invalid argument");
    54   }
    55 
    56   WString str = *p_String;
    57   Char ch     = *p_Char;
    58 
    59   if (index >= str.get_len())
    60   {
    61     RF_LIB_ERROR("Index out of range");
    62   }
    63 
    64   str[index] = ch;
    65 
     47  else
     48    RF_LIB_ERROR("Invalid Argument");
     49 
    6650RF_END
    6751
  • to-imperative/trunk/library/String/substring.cc

    r360 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_string.hh>
    8 #include <rf_int.hh>
    9 #include <rf_short_int.hh>
    107
    118namespace refal
     
    1815{
    1916
    20 RF_FUNC (Substring, (RF_ARG s_String, s_Index, s_Len), (s_NewString))
     17RF_FUNC (Substring, (RF_ARG s_String, s_Index, s_Len), (RF_RES s_NewString))
     18  if (s_String.get_len() == 1) {
     19    Term* p_String = s_String.get_first();
     20    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2121
    22   Term *p_String = s_String.get_first();
    23   Term *p_Len    = s_Len.get_first();
    24   Term *p_Index  = s_Index.get_first();
    25 
    26   if (p_String->get_type() != RF_TYPE(WString))
    27     RF_LIB_ERROR("Invalid argument");
    28 
    29   uintptr_t length, index;
    30  
    31   //
    32   // Find out the type of s_Len and extract the value of length from it.
    33   if (p_Len->get_type() == RF_TYPE(Int))
    34   {
    35     Int len = *p_Len;
    36     if (len < 0)
    37       RF_LIB_ERROR("Invalid argument");
    38     length = len.to_uint();
     22    Term* p_Index = s_Index.get_first();
     23    rftype::ShortInt* Ind = p_Index->cast_to<rftype::ShortInt>(type_short_int);
     24   
     25    Term* p_Len = s_Len.get_first();
     26    rftype::ShortInt* Len = p_Len->cast_to<rftype::ShortInt>(type_short_int);
     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");
     33      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        }
     41      }
     42    }
     43    else
     44      RF_LIB_ERROR ("Invalid argument");
    3945  }
    4046  else
    41   if (p_Len->get_type() == RF_TYPE(ShortInt))
    42   {
    43     ShortInt len = *p_Len;
    44     if (len < 0)
    45       RF_LIB_ERROR("Invalid argument");
    46     length = len;
    47   }
    48   else
    49   {
    50     RF_LIB_ERROR("Invalid argument");
    51   }
    52 
    53   //
    54   // Find out the type of s_Index and extract the value of index from it.
    55   if (p_Index->get_type() == RF_TYPE(Int))
    56   {
    57     Int ind = *p_Index;
    58     if (ind < 0)
    59       RF_LIB_ERROR("Invalid argument");
    60     index = ind.to_uint();
    61   }
    62   else
    63   if (p_Index->get_type() == RF_TYPE(ShortInt))
    64   {
    65     ShortInt ind = *p_Index;
    66     if (ind < 0)
    67       RF_LIB_ERROR("Invalid argument");
    68     index = ind;
    69   }
    70   else
    71   {
    72     RF_LIB_ERROR("Invalid argument");
    73   }
    74    
    75   WString str = *p_String;
    76 
    77   if (str.get_len() <= index || str.get_len() - index < length)
    78     RF_LIB_ERROR("Index out of range");
    79 
    80   try
    81   {
    82     s_NewString = str.substring(index, length).to_symbol();
    83   }
    84   catch (const pxx::SysError &err)
    85   {
    86     if (err.get_code() == ENOMEM)
    87       RF_LIB_ERROR("Size limit excedeed");
    88     throw;
    89   }
     47  RF_LIB_ERROR ("Invalid argument");
    9048
    9149RF_END
  • to-imperative/trunk/library/String/substring_fill.cc

    r369 r1021  
    55
    66#include <rf_core.hh>
    7 #include <rf_string.hh>
    8 #include <rf_int.hh>
    9 #include <rf_short_int.hh>
    10 #include <rf_char.hh>
    117
    128namespace refal
     
    2117RF_FUNC (Substring_m_Fill, (RF_ARG s_String, s_Index, s_Len, s_Fill), ())
    2218
    23   Term *p_String = s_String.get_first();
    24   Term *p_Len    = s_Len.get_first();
    25   Term *p_Index  = s_Index.get_first();
    26   Term *p_Fill   = s_Fill.get_first();
     19  if (s_String.get_len() == 1) {
     20    Term* p_String = s_String.get_first();
     21    rftype::String* str = p_String->cast_to<rftype::String>(type_string);
    2722
    28   if ( p_String->get_type() != RF_TYPE(WString) ||
    29          p_Fill->get_type() != RF_TYPE(Char)
    30      )
    31   {
    32     RF_LIB_ERROR("Invalid argument");
    33   }
     23    Term* p_Index = s_Index.get_first();
     24    rftype::ShortInt* Ind = p_Index->cast_to<rftype::ShortInt>(type_short_int);
     25   
     26    Term* p_Len = s_Len.get_first();
     27    rftype::ShortInt* Len = p_Len->cast_to<rftype::ShortInt>(type_short_int);
    3428
    35   Char fill   = *p_Fill;
    36 
    37   uintptr_t index, length;
    38 
    39   if (p_Len->get_type() == RF_TYPE(Int))
    40   {
    41     Int len = *p_Len;
    42     if (len < 0)
    43       RF_LIB_ERROR("Invalid argument");
    44     length = len.to_uint();
     29    Term* p_Fill = s_Fill.get_first();
     30    rftype::Char* Fill = p_Fill->cast_to<rftype::Char>(type_char);
     31   
     32    if (str && Fill) {
     33      wchar_t fill = Fill->to_wchar_t();
     34      intptr_t len = Len->to_int();
     35      intptr_t ind = Ind->to_int();
     36      intptr_t str_len = str->get_length();
     37      if (len <= ind || ind + len > str_len)
     38        RF_LIB_ERROR ("Index out of range");
     39      else {
     40        wchar_t const* content = str->get_data();
     41        rftype::String s = rftype::String(content);
     42        rftype::String::fill(s, ind, str_len, fill);
     43      }
     44    }
     45    else
     46      RF_LIB_ERROR("Invalid Argument");
    4547  }
    4648  else
    47   if (p_Len->get_type() == RF_TYPE(ShortInt))
    48   {
    49     ShortInt len = *p_Len;
    50     if (len < 0)
    51       RF_LIB_ERROR("Invalid argument");
    52     length = len;
    53   }
    54   else
    55   {
    56     RF_LIB_ERROR("Invalid argument");
    57   }
    58   if (p_Index->get_type() == RF_TYPE(Int))
    59   {
    60     Int ind = *p_Index;
    61     if (ind < 0)
    62       RF_LIB_ERROR("Invalid argument");
    63     index = ind.to_uint();
    64   }
    65   else
    66   if (p_Index->get_type() == RF_TYPE(ShortInt))
    67   {
    68     ShortInt ind = *p_Index;
    69     if (ind < 0)
    70       RF_LIB_ERROR("Invalid argument");
    71     index = ind;
    72   }
    73   else
    74   {
    75     RF_LIB_ERROR("Invalid argument");
    76   }
    77    
    78   if (str.get_len() <= index || str.get_len() - index < length)
    79   {
    80     RF_LIB_ERROR("Index out of range");
    81   }
    82 
    83   WString str = *p_String;
    84 
    85   str.fill(index, length, fill);
     49    RF_LIB_ERROR ("Invalid argument");
    8650
    8751RF_END
Note: See TracChangeset for help on using the changeset viewer.