class Lisp::PrimString

Public Class Methods

capitalize_string(str) click to toggle source
# File lib/rubylisp/prim_string.rb, line 453
def self.capitalize_string(str)
  saw_first = false
  str.chars.map do |c|
    if c =~ /[[:alpha:]]/
      if saw_first
        c.downcase
      else
        saw_first = true
        c.upcase
      end
    else
      c
    end
  end
end
capitalized?(str) click to toggle source
# File lib/rubylisp/prim_string.rb, line 398
def self.capitalized?(str)
  first = str[0]
  rest = str[1..-1]
  return false unless first =~ /[[:upper:]]/
  lowercase?(rest)
end
extract_strings(func, args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 211
def self.extract_strings(func, args, env)
  str1 = get_string(func, args.nth(0).evaluate(env), env)
  str2 = get_string(func, args.nth(1).evaluate(env), env)
  return [str1, str2]
end
extract_substrings(func, args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 198
def self.extract_substrings(func, args, env)
  substr1 = get_substring(func, args.nth(0), args.nth(1), args.nth(2), env)
  substr2 = get_substring(func, args.nth(3), args.nth(4), args.nth(5), env)
  return [substr1, substr2]
end
get_string(func, str, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 205
def self.get_string(func, str, env)
  return Lisp::Debug.process_error("#{func} requires a string, but received #{str}", env) unless str.string?
  str.value
end
get_substring(func, str, start_index, end_index, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 185
def self.get_substring(func, str, start_index, end_index, env)
  return Lisp::Debug.process_error("#{func} requires a string, but received #{str}", env) unless str.string?
  s = str.value
  return Lisp::Debug.process_error("#{func} requires an integer start index, but received #{start_index}", env) unless start_index.integer?
  si = start_index.value
  return Lisp::Debug.process_error("#{func} received an invalid substring start index: #{si}", env) if si < 0 || si > s.length
  return Lisp::Debug.process_error("#{func} requires an integer end index, but received #{end_index}", env) unless end_index.integer?
  ei = end_index.value
  return Lisp::Debug.process_error("#{func} received an invalid substring end index: #{ei}", env) if ei < 0 || ei > s.length
  s[si...ei]
end
list_string_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 116
def self.list_string_impl(args, env)
  list_of_chars = args.car
  return Lisp::Debug.process_error("list->string requires a list argument, but received #{list_of_chars}", env) unless list_of_chars.list?      
  chars = list_of_chars.to_a.map do |a|
    ea = a.evaluate(env)
    return Lisp::Debug.process_error("string requires a list of characters, but it contained #{ea}.", env) unless ea.character?
    ea.value
  end
  Lisp::String.with_value(chars.join)
end
lowercase?(str) click to toggle source
# File lib/rubylisp/prim_string.rb, line 393
def self.lowercase?(str)
  (str =~ /^[[:lower:]]*$/) == 0
end
make_string_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 92
def self.make_string_impl(args, env)
  k_arg = args.car
  return Lisp::Debug.process_error("make-string requires an integer as it's first argument.", env) unless k_arg.integer?
  k = k_arg.value
  c = if args.length == 2
        c_arg = args.cadr
        return Lisp::Debug.process_error("make-string requires a character as it's second argument, but received #{c_arg}.", env) unless c_arg.character?
        c_arg.value
      else
        " "
      end
  Lisp::String.with_value(c * k)
end
register() click to toggle source
# File lib/rubylisp/prim_string.rb, line 5
    def self.register
      Primitive.register("str", ">=1")   {|args, env| Lisp::PrimString::str_impl(args, env) }
      Primitive.register("string?", "1")   {|args, env| Lisp::PrimString::stringp_impl(args, env) }
      Primitive.register("make-string", "1|2") {|args, env| Lisp::PrimString::make_string_impl(args, env) }      
      Primitive.register("string", "*") {|args, env| Lisp::PrimString::string_impl(args, env) }      
      Primitive.register("list->string", "1") {|args, env| Lisp::PrimString::list_string_impl(args, env) }      
      Primitive.register("string->list", "1") {|args, env| Lisp::PrimString::string_list_impl(args, env) }      
      Primitive.register("string-copy", "1") {|args, env| Lisp::PrimString::string_copy_impl(args, env) }      
      Primitive.register("string-length", "1") {|args, env| Lisp::PrimString::string_length_impl(args, env) }      
      Primitive.register("string-null?", "1") {|args, env| Lisp::PrimString::string_nullp_impl(args, env) }      
      Primitive.register("string-ref", "2") {|args, env| Lisp::PrimString::string_ref_impl(args, env) }      
      Primitive.register("string-set!", "3") {|args, env| Lisp::PrimString::string_set_impl(args, env) }      

      Primitive.register("string=?", "2") {|args, env| Lisp::PrimString::string_eq_impl(args, env) }      
      Primitive.register("substring=?", "6") {|args, env| Lisp::PrimString::substring_eq_impl(args, env) }      
      Primitive.register("string-ci=?", "2") {|args, env| Lisp::PrimString::string_ci_eq_impl(args, env) }      
      Primitive.register("substring-ci=?", "6") {|args, env| Lisp::PrimString::substring_ci_eq_impl(args, env) }      

      Primitive.register("string<?", "2") {|args, env| Lisp::PrimString::string_lt_impl(args, env) }      
      Primitive.register("substring<?", "6") {|args, env| Lisp::PrimString::substring_lt_impl(args, env) }      
      Primitive.register("string-ci<?", "2") {|args, env| Lisp::PrimString::string_ci_lt_impl(args, env) }      
      Primitive.register("substring-ci<?", "6") {|args, env| Lisp::PrimString::substring_ci_lt_impl(args, env) }      

      Primitive.register("string>?", "2") {|args, env| Lisp::PrimString::string_gt_impl(args, env) }      
      Primitive.register("substring>?", "6") {|args, env| Lisp::PrimString::substring_gt_impl(args, env) }      
      Primitive.register("string-ci>?", "2") {|args, env| Lisp::PrimString::string_ci_gt_impl(args, env) }      
      Primitive.register("substring-ci>?", "6") {|args, env| Lisp::PrimString::substring_ci_gt_impl(args, env) }      

      Primitive.register("string<=?", "2") {|args, env| Lisp::PrimString::string_lte_impl(args, env) }      
      Primitive.register("substring<=?", "6") {|args, env| Lisp::PrimString::substring_lte_impl(args, env) }      
      Primitive.register("string-ci<=?", "2") {|args, env| Lisp::PrimString::string_ci_lte_impl(args, env) }      
      Primitive.register("substring-ci<=?", "6") {|args, env| Lisp::PrimString::substring_ci_lte_impl(args, env) }      

      Primitive.register("string>=?", "2") {|args, env| Lisp::PrimString::string_gte_impl(args, env) }      
      Primitive.register("substring>=?", "6") {|args, env| Lisp::PrimString::substring_gte_impl(args, env) }      
      Primitive.register("string-ci>=?", "2") {|args, env| Lisp::PrimString::string_ci_gte_impl(args, env) }      
      Primitive.register("substring-ci>=?", "6") {|args, env| Lisp::PrimString::substring_ci_gte_impl(args, env) }      

      Primitive.register("string-compare", "5") {|args, env| Lisp::PrimString::string_compare_impl(args, env) }      
      Primitive.register("string-compare-ci", "5") {|args, env| Lisp::PrimString::string_compare_ci_impl(args, env) }      

      Primitive.register("string-hash", "1") {|args, env| Lisp::PrimString::string_hash_impl(args, env) }      
      Primitive.register("string-hash-mod", "2") {|args, env| Lisp::PrimString::string_hash_mod_impl(args, env) }      

      Primitive.register("string-capitalized?", "1") {|args, env| Lisp::PrimString::string_capitalizedp_impl(args, env) }      
      Primitive.register("substring-capitalized?", "3") {|args, env| Lisp::PrimString::substring_capitalizedp_impl(args, env) }      
      Primitive.register("string-upper-case?", "1") {|args, env| Lisp::PrimString::string_upperp_impl(args, env) }      
      Primitive.register("substring-upper-case?", "3") {|args, env| Lisp::PrimString::substring_upperp_impl(args, env) }      
      Primitive.register("string-lower-case?", "1") {|args, env| Lisp::PrimString::string_lowerp_impl(args, env) }      
      Primitive.register("substring-lower-case?", "3") {|args, env| Lisp::PrimString::substring_lowerp_impl(args, env) }      

      Primitive.register("string-capitalize", "1") {|args, env| Lisp::PrimString::string_capitalize_impl(args, env) }      
      Primitive.register("string-capitalize!", "1") {|args, env| Lisp::PrimString::string_capitalize_bang_impl(args, env) }      
      Primitive.register("substring-capitalize!", "3") {|args, env| Lisp::PrimString::substring_capitalize_bang_impl(args, env) }      
      Primitive.register("string-downcase", "1") {|args, env| Lisp::PrimString::string_downcase_impl(args, env) }      
      Primitive.register("string-downcase!", "1") {|args, env| Lisp::PrimString::string_downcase_bang_impl(args, env) }      
      Primitive.register("substring-downcase!", "3") {|args, env| Lisp::PrimString::substring_downcase_bang_impl(args, env) }      
      Primitive.register("string-upcase", "1") {|args, env| Lisp::PrimString::string_upcase_impl(args, env) }      
      Primitive.register("string-upcase!", "1") {|args, env| Lisp::PrimString::string_upcase_bang_impl(args, env) }      
      Primitive.register("substring-upcase!", "3") {|args, env| Lisp::PrimString::substring_upcase_bang_impl(args, env) }

      Primitive.register("string-append", "*") {|args, env| Lisp::PrimString::string_append_impl(args, env) }      
      Primitive.register("substring", "3") {|args, env| Lisp::PrimString::substring_impl(args, env) }      
      Primitive.register("string-head", "2") {|args, env| Lisp::PrimString::string_head_impl(args, env) }      
      Primitive.register("string-tail", "2") {|args, env| Lisp::PrimString::string_tail_impl(args, env) }      

      Primitive.register("string-pad-left", "2|3") {|args, env| Lisp::PrimString::string_pad_left_impl(args, env) }      
      Primitive.register("string-pad-right", "2|3") {|args, env| Lisp::PrimString::string_pad_right_impl(args, env) }      

      Primitive.register("string-trim", "1|2") {|args, env| Lisp::PrimString::string_trim_impl(args, env) }      
      Primitive.register("string-trim-right", "1|2") {|args, env| Lisp::PrimString::string_trim_right_impl(args, env) }      
      Primitive.register("string-trim-left", "1|2") {|args, env| Lisp::PrimString::string_trim_left_impl(args, env) }      

      Primitive.register("string-split", "2") {|args, env| Lisp::PrimString::string_split_impl(args, env) }      
end
split_into_words(str) click to toggle source
# File lib/rubylisp/prim_string.rb, line 406
def self.split_into_words(str)
  str.split(/[^[[:alpha:]]]+/)
end
str_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 81
def self.str_impl(args, env)
  strings = args.to_a.map {|e| e.to_s}
  String.with_value(strings.join)
end
string_append_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 598
def self.string_append_impl(args, env)
  strings = args.to_a.map do |a|
    return Lisp::Debug.process_error("string-append requires strings, but received #{a}", env) unless a.string?
    a.value
  end

  Lisp::String.with_value(strings.join)
end
string_capitalize_bang_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 478
def self.string_capitalize_bang_impl(args, env)
  str = args.nth(0)
  return Lisp::Debug.process_error("string-capitalize! requires a string, but received #{str}", env) unless str.string?
  new_chars = capitalize_string(str.value)
  new_str = ""
  new_chars.each {|c| new_str << c}
  str.set!(new_str)
  str
end
string_capitalize_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 469
def self.string_capitalize_impl(args, env)
  str = get_string("string-capitalize", args.nth(0), env)
  new_chars = capitalize_string(str)
  new_str = ""
  new_chars.each {|c| new_str << c}
  Lisp::String.with_value(new_str)
end
string_capitalizedp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 411
def self.string_capitalizedp_impl(args, env)
  str = get_string("string-capitalized?", args.nth(0), env)
  words = split_into_words(str)
  Lisp::Boolean.with_value(capitalized?(words[0])&& words[1..-1].all? {|w| capitalized?(w) || lowercase?(w)})
end
string_ci_eq_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 230
def self.string_ci_eq_impl(args, env)
  str1, str2 = extract_strings("string-ci=?", args, env)
  Lisp::Boolean.with_value(str1.downcase == str2.downcase)
end
string_ci_gt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 278
def self.string_ci_gt_impl(args, env)
  str1, str2 = extract_strings("string-ci>?", args, env)
  Lisp::Boolean.with_value(str1.downcase > str2.downcase)
end
string_ci_gte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 326
def self.string_ci_gte_impl(args, env)
  str1, str2 = extract_strings("string-ci>=?", args, env)
  Lisp::Boolean.with_value(str1.downcase >= str2.downcase)
end
string_ci_lt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 254
def self.string_ci_lt_impl(args, env)
  str1, str2 = extract_strings("string-ci<?", args, env)
  Lisp::Boolean.with_value(str1.downcase < str2.downcase)
end
string_ci_lte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 302
def self.string_ci_lte_impl(args, env)
  str1, str2 = extract_strings("string-ci<=?", args, env)
  Lisp::Boolean.with_value(str1.downcase <= str2.downcase)
end
string_compare_ci_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 355
def self.string_compare_ci_impl(args, env)
  str1 = get_string("string-compare-ci", args.nth(0), env)
  str2 = get_string("string-compare-ci", args.nth(1), env)
  f_number = case str1.downcase <=> str2.downcase
             when -1
               3
             when 0
               2
             when 1
               4
             end
  f = args.nth(f_number)
  return Lisp::Debug.process_error("string-compare-ci requires functions for argument #{f_number}, but received #{f}", env) unless f.function?
  f.apply_to(Lisp::ConsCell.cons, env)
end
string_compare_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 338
def self.string_compare_impl(args, env)
  str1 = get_string("string-compare", args.nth(0), env)
  str2 = get_string("string-compare", args.nth(1), env)
  f_number = case str1 <=> str2
             when -1
               3
             when 0
               2
             when 1
               4
             end
  f = args.nth(f_number)
  return Lisp::Debug.process_error("string-compare requires functions for argument #{f_number}, but received #{f}", env) unless f.function?
  f.apply_to(Lisp::ConsCell.cons, env)
end
string_copy_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 136
def self.string_copy_impl(args, env)
  str_arg = args.car
  return Lisp::Debug.process_error("string-copy requires a string argument, but received #{str_arg}", env) unless str_arg.string?
  Lisp::String.with_value(str_arg.value)
end
string_downcase_bang_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 522
def self.string_downcase_bang_impl(args, env)
  str = args.nth(0)
  return Lisp::Debug.process_error("string-downcase! requires a string, but received #{str}", env) unless str.string?
  str.set!(str.value.downcase)
  str
end
string_downcase_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 516
def self.string_downcase_impl(args, env)
  str = get_string("string-downcase?", args.nth(0), env)
  Lisp::String.with_value(str.downcase)
end
string_eq_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 218
def self.string_eq_impl(args, env)
  str1, str2 = extract_strings("string=?", args, env)
  Lisp::Boolean.with_value(str1 == str2)
end
string_gt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 266
def self.string_gt_impl(args, env)
  str1, str2 = extract_strings("string>?", args, env)
  Lisp::Boolean.with_value(str1 > str2)
end
string_gte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 314
def self.string_gte_impl(args, env)
  str1, str2 = extract_strings("string>=?", args, env)
  Lisp::Boolean.with_value(str1 >= str2)
end
string_hash_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 372
def self.string_hash_impl(args, env)
  str = get_string("string-hash", args.nth(0), env)
  Lisp::Number.with_value(str.hash)
end
string_hash_mod_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 378
def self.string_hash_mod_impl(args, env)
  str = get_string("string-hash-mod", args.nth(0), env)
  k_arg = args.cadr
  return Lisp::Debug.process_error("string-hash-mod requires it's second argument to be an integer, but received #{k_arg}", env) unless k_arg.integer?
  k = k_arg.value
  Lisp::Number.with_value(str.hash % k)
end
string_head_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 614
def self.string_head_impl(args, env)
  s = args.nth(0)
  return Lisp::Debug.process_error("string-head requires a string as it's first argument, but received #{s}", env) unless s.string?
  str = s.value
  
  end_index = args.nth(1)
  return Lisp::Debug.process_error("string-head requires an integer end index, but received #{end_index}", env) unless end_index.integer?
  ei = end_index.value
  return Lisp::Debug.process_error("string-head received an invalid end index: #{ei}", env) if ei < 0 || ei > str.length

  Lisp::String.with_value(str[0...ei])
end
string_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 107
def self.string_impl(args, env)
  chars = args.to_a.map do |a|
    return Lisp::Debug.process_error("string requires character args, but was passed #{a}.", env) unless a.character?
    a.value
  end
  Lisp::String.with_value(chars.join)
end
string_length_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 143
def self.string_length_impl(args, env)
  str_arg = args.car
  return Lisp::Debug.process_error("string-length requires a string argument, but received #{str_arg}", env) unless str_arg.string?
  Lisp::Number.with_value(str_arg.value.length)
end
string_list_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 128
def self.string_list_impl(args, env)
  str_arg = args.car
  return Lisp::Debug.process_error("string->list requires a string argument, but received #{str_arg}", env) unless str_arg.string?
  chars = str_arg.value.each_char.map {|c| Lisp::PrimCharacter.find_character_for_chr(c) }
  Lisp::ConsCell.array_to_list(chars)
end
string_lowerp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 439
def self.string_lowerp_impl(args, env)
  str = get_string("string-lower-case?", args.nth(0), env)
  words = split_into_words(str)
  Lisp::Boolean.with_value(words.all? {|w| lowercase?(w)})
end
string_lt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 242
def self.string_lt_impl(args, env)
  str1, str2 = extract_strings("string<?", args, env)
  Lisp::Boolean.with_value(str1 < str2)
end
string_lte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 290
def self.string_lte_impl(args, env)
  str1, str2 = extract_strings("string<=?", args, env)
  Lisp::Boolean.with_value(str1 <= str2)
end
string_nullp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 150
def self.string_nullp_impl(args, env)
  str_arg = args.car
  return Lisp::Debug.process_error("string-length requires a string argument, but received #{str_arg}", env) unless str_arg.string?
  Lisp::Boolean.with_value(str_arg.value.length == 0)
end
string_pad_left_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 643
def self.string_pad_left_impl(args, env)
  s = args.nth(0)
  return Lisp::Debug.process_error("string-pad-left requires a string as it's first argument, but received #{s}", env) unless s.string?
  str = s.value
  
  size_arg = args.nth(1)
  return Lisp::Debug.process_error("string-pad-left requires an integer size, but received #{size_arg}", env) unless size_arg.integer?
  size = size_arg.value
  return Lisp::Debug.process_error("string-pad-left received an invalid size: #{size}", env) if size < 0

  padding_char = if args.length == 3
                   ch_arg = args.nth(2)
                   return Lisp::Debug.process_error("string-pad-left requires a character pad, but received #{ch_arg}", env) unless ch_arg.character?
                   ch_arg.value
                 else
                   " "
                 end
    
  
  new_str = if size > str.length
              padding = size - str.length
              pad = ""
              padding.times {|i| pad << padding_char}
              pad + str
            else
              start = str.length - size
              str[start..-1]
            end
  Lisp::String.with_value(new_str)
end
string_pad_right_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 675
def self.string_pad_right_impl(args, env)
  s = args.nth(0)
  raise "string-pad-right requires a string as it's first argument, but received #{s}" unless s.string?
  str = s.value
  
  size_arg = args.nth(1)
  raise "string-pad-right requires an integer size, but received #{size_arg}" unless size_arg.integer?
  size = size_arg.value
  raise "string-pad-right received an invalid size: #{size}" if size < 0

  padding_char = if args.length == 3
                   ch_arg = args.nth(2)
                   raise "string-pad-right requires a character pad, but received #{ch_arg}" unless ch_arg.character?
                   ch_arg.value
                 else
                   " "
                 end
    
  
  new_str = if size > str.length
              padding = size - str.length
              pad = ""
              padding.times {|i| pad << padding_char}
              str + pad
            else
              last = str.length - size
              str[0...4]
            end
  Lisp::String.with_value(new_str)
end
string_ref_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 157
def self.string_ref_impl(args, env)
  str_arg = args.car
  return Lisp::Debug.process_error("string-ref requires a string as it's first argument, but received #{arg.car}", env) unless str_arg.string?
  str = str_arg.value
  k_arg = args.cadr
  return Lisp::Debug.process_error("string-ref requires it's second argument to be an integer, but received #{k_arg}", env) unless k_arg.integer?
  k = k_arg.value
  return Lisp::FALSE if k < 0 || k >= str.length
  Lisp::PrimCharacter.find_character_for_chr(str[k])
end
string_set_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 169
def self.string_set_impl(args, env)
  str_arg = args.car
  return Lisp::Debug.process_error("string-set! needs a string as it's first argument, but received #{str_arg}", env) unless str_arg.string?
  str = str_arg.value
  k_arg = args.cadr
  return Lisp::Debug.process_error("string-set! requires an integer as it's second argument, but received #{k_arg}", env) unless k_arg.integer?
  k = k_arg.value
  return Lisp::FALSE if k < 0 || k >= str.length
  replacement_arg = args.caddr
  return Lisp::Debug.process_error("string-set! requires a character as it's third argument, but received #{replacement_arg}", env) unless replacement_arg.character?
  replacement = replacement_arg.value
  str[k] = replacement
  Lisp::String.with_value(str)
end
string_split_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 780
def self.string_split_impl(args, env)
  the_string = args.car
  raise "string-split requires a string as it's first argument, but received #{the_string}" unless the_string.string?
  
  separator = args.cadr
  raise "string-split requires a string as it's second argument, but received #{separator}" unless separator.string?

  Lisp::ConsCell.array_to_list(the_string.value.split(separator.value).map {|s| Lisp::String.with_value(s)})
end
string_tail_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 628
def self.string_tail_impl(args, env)
  return Lisp::Debug.process_error("string-tail requires 2 arguments, but received #{args.length}", env) unless args.length == 2
  s = args.nth(0).evaluate(env)
  return Lisp::Debug.process_error("string-tail requires a string as it's first argument, but received #{s}", env) unless s.string?
  str = s.value
  
  start_index = args.nth(1).evaluate(env)
  return Lisp::Debug.process_error("string-tail requires an integer start index, but received #{start_index}", env) unless start_index.integer?
  si = start_index.value
  return Lisp::Debug.process_error("string-tail received an invalid end index: #{si}", env) if si < 0 || si > str.length

  Lisp::String.with_value(str[si..-1])
end
string_trim_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 707
def self.string_trim_impl(args, env)
  s1 = args.nth(0)
  raise "string-trim requires a string as it's first argument, but received #{s1}" unless s1.string?
  str = s1.value

  pattern = Regexp.new(if args.length == 2
                         s2 = args.nth(1)
                         raise "string-trim requires a string as it's second argument, but received #{s2}" unless s2.string?
                         s2.value
                       else
                         "[[:graph:]]"
                       end)

  
  left_i = 0
  while pattern.match(str[left_i]).nil? && left_i < str.length
    left_i += 1
  end
  
  right_i = str.length - 1
  while pattern.match(str[right_i]).nil? && right_i >= 0
    right_i -= 1
  end
  
  Lisp::String.with_value(str[left_i..right_i])
end
string_trim_left_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 735
def self.string_trim_left_impl(args, env)
  s1 = args.nth(0)
  raise "string-trim-left requires a string as it's first argument, but received #{s1}" unless s1.string?
  str = s1.value

  pattern = Regexp.new(if args.length == 2
                         s2 = args.nth(1)
                         raise "string-trim-left requires a string as it's second argument, but received #{s2}" unless s2.string?
                         s2.value
                       else
                         "[[:graph:]]"
                       end)

  
  left_i = 0
  while pattern.match(str[left_i]).nil? && left_i < str.length
    left_i += 1
  end
  
  Lisp::String.with_value(str[left_i..-1])
end
string_trim_right_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 758
def self.string_trim_right_impl(args, env)
  s1 = args.nth(0)
  raise "string-trim-right requires a string as it's first argument, but received #{s1}" unless s1.string?
  str = s1.value

  pattern = Regexp.new(if args.length == 2
                         s2 = args.nth(1)
                         raise "string-trim-right requires a string as it's second argument, but received #{s2}" unless s2.string?
                         s2.value
                       else
                         "[[:graph:]]"
                       end)

  right_i = str.length - 1
  while pattern.match(str[right_i]).nil? && right_i >= 0
    right_i -= 1
  end
  
  Lisp::String.with_value(str[0..right_i])
end
string_upcase_bang_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 563
def self.string_upcase_bang_impl(args, env)
  str = args.nth(0)
  return Lisp::Debug.process_error("string-upcase! requires a string, but received #{str}", env) unless str.string?
  str.set!(str.value.upcase)
  str
end
string_upcase_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 557
def self.string_upcase_impl(args, env)
  str = get_string("string-upcase?", args.nth(0), env)
  Lisp::String.with_value(str.upcase)
end
string_upperp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 425
def self.string_upperp_impl(args, env)
  str = get_string("string-upper-case?", args.nth(0), env)
  words = split_into_words(str)
  Lisp::Boolean.with_value(words.all? {|w| uppercase?(w)})
end
stringp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 87
def self.stringp_impl(args, env)
  return Lisp::Boolean.with_value(args.car.string?)
end
substring_capitalize_bang_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 489
def self.substring_capitalize_bang_impl(args, env)
  s = args.nth(0)
  return Lisp::Debug.process_error("substring-capitalize! requires a string as it's first argument, but received #{s}", env) unless s.string?
  str = s.value
  
  start_index = args.nth(1)
  return Lisp::Debug.process_error("substring-capitalize! requires an integer start index, but received #{start_index}", env) unless start_index.integer?
  si = start_index.value
  return Lisp::Debug.process_error("substring-capitalize! received an invalid substring start index: #{si}", env) if si < 0 || si > str.length

  end_index = args.nth(2)
  return Lisp::Debug.process_error("substring-capitalize! requires an integer end index, but received #{end_index}", env) unless end_index.integer?
  ei = end_index.value
  return Lisp::Debug.process_error("substring-capitalize! received an invalid substring end index: #{ei}", env) if ei < 0 || ei > str.length

  prefix = str[0...si]
  substr = str[si...ei]
  suffix = str[ei..-1]
  
  new_chars = capitalize_string(substr)
  new_substr = ""   
  new_chars.each {|c| new_substr << c}
  s.set!(prefix + new_substr + suffix)
  s
end
substring_capitalizedp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 418
def self.substring_capitalizedp_impl(args, env)
  str = get_substring("substring-capitalized?", args.nth(0), args.nth(1), args.nth(2), env)
  words = split_into_words(str)
  Lisp::Boolean.with_value(capitalized?(words[0]) && words[1..-1].all? {|w| capitalized?(w) || lowercase?(w)})
end
substring_ci_eq_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 236
def self.substring_ci_eq_impl(args, env)
  substr1, substr2 = extract_substrings("substring-ci=?", args, env)
  Lisp::Boolean.with_value(substr1.downcase == substr2.downcase)
end
substring_ci_gt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 284
def self.substring_ci_gt_impl(args, env)
  substr1, substr2 = extract_substrings("substring-ci>?", args, env)
  Lisp::Boolean.with_value(substr1.downcase > substr2.downcase)
end
substring_ci_gte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 332
def self.substring_ci_gte_impl(args, env)
  substr1, substr2 = extract_substrings("substring-ci>=?", args, env)
  Lisp::Boolean.with_value(substr1.downcase >= substr2.downcase)
end
substring_ci_lt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 260
def self.substring_ci_lt_impl(args, env)
  substr1, substr2 = extract_substrings("substring-ci<?", args, env)
  Lisp::Boolean.with_value(substr1.downcase < substr2.downcase)
end
substring_ci_lte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 308
def self.substring_ci_lte_impl(args, env)
  substr1, substr2 = extract_substrings("substring-ci<=?", args, env)
  Lisp::Boolean.with_value(substr1.downcase <= substr2.downcase)
end
substring_downcase_bang_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 530
def self.substring_downcase_bang_impl(args, env)
  s = args.nth(0)
  return Lisp::Debug.process_error("substring-downcase! requires a string as it's first argument, but received #{s}", env) unless s.string?
  str = s.value
  
  start_index = args.nth(1)
  return Lisp::Debug.process_error("substring-downcase! requires an integer start index, but received #{start_index}", env) unless start_index.integer?
  si = start_index.value
  return Lisp::Debug.process_error("substring-downcase! received an invalid substring start index: #{si}", env) if si < 0 || si > str.length

  end_index = args.nth(2)
  return Lisp::Debug.process_error("substring-downcase! requires an integer end index, but received #{end_index}", env) unless end_index.integer?
  ei = end_index.value
  return Lisp::Debug.process_error("substring-downcase! received an invalid substring end index: #{ei}", env) if ei < 0 || ei > str.length

  prefix = str[0...si]
  substr = str[si...ei]
  suffix = str[ei..-1]
  
  new_chars = capitalize_string(substr)
  new_substr = ""   
  new_chars.each {|c| new_substr << c}
  s.set!(prefix + substr.downcase + suffix)
  s
end
substring_eq_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 224
def self.substring_eq_impl(args, env)
  substr1, substr2 = extract_substrings("substring=?", args, env)
  Lisp::Boolean.with_value(substr1 == substr2)
end
substring_gt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 272
def self.substring_gt_impl(args, env)
  substr1, substr2 = extract_substrings("substring>?", args, env)
  Lisp::Boolean.with_value(substr1 > substr2)
end
substring_gte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 320
def self.substring_gte_impl(args, env)
  substr1, substr2 = extract_substrings("substring>=?", args, env)
  Lisp::Boolean.with_value(substr1 >= substr2)
end
substring_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 608
def self.substring_impl(args, env)
  str = get_substring("substring", args.nth(0), args.nth(1), args.nth(2), env)
  Lisp::String.with_value(str)
end
substring_lowerp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 446
def self.substring_lowerp_impl(args, env)
  str = get_substring("substring-lower-case?", args.nth(0), args.nth(1), args.nth(2), env)
  words = split_into_words(str)
  Lisp::Boolean.with_value(words.all? {|w| lowercase?(w)})
end
substring_lt_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 248
def self.substring_lt_impl(args, env)
  substr1, substr2 = extract_substrings("substring<?", args, env)
  Lisp::Boolean.with_value(substr1 < substr2)
end
substring_lte_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 296
def self.substring_lte_impl(args, env)
  substr1, substr2 = extract_substrings("substring<=?", args, env)
  Lisp::Boolean.with_value(substr1 <= substr2)
end
substring_upcase_bang_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 571
def self.substring_upcase_bang_impl(args, env)
  s = args.nth(0)
  return Lisp::Debug.process_error("substring-upcase! requires a string as it's first argument, but received #{s}", env) unless s.string?
  str = s.value
  
  start_index = args.nth(1)
  return Lisp::Debug.process_error("substring-upcase! requires an integer start index, but received #{start_index}", env) unless start_index.integer?
  si = start_index.value
  return Lisp::Debug.process_error("substring-upcase! received an invalid substring start index: #{si}", env) if si < 0 || si > str.length

  end_index = args.nth(2)
  return Lisp::Debug.process_error("substring-upcase! requires an integer end index, but received #{end_index}", env) unless end_index.integer?
  ei = end_index.value
  return Lisp::Debug.process_error("substring-upcase! received an invalid substring end index: #{ei}", env) if ei < 0 || ei > str.length

  prefix = str[0...si]
  substr = str[si...ei]
  suffix = str[ei..-1]
  
  new_chars = capitalize_string(substr)
  new_substr = ""   
  new_chars.each {|c| new_substr << c}
  s.set!(prefix + substr.upcase + suffix)
  s
end
substring_upperp_impl(args, env) click to toggle source
# File lib/rubylisp/prim_string.rb, line 432
def self.substring_upperp_impl(args, env)
  str = get_substring("substring-upper-case?", args.nth(0), args.nth(1), args.nth(2), env)
  words = split_into_words(str)
  Lisp::Boolean.with_value(words.all? {|w| uppercase?(w)})
end
uppercase?(str) click to toggle source

str is assumed to be a single word

# File lib/rubylisp/prim_string.rb, line 388
def self.uppercase?(str)
  (str =~ /^[[:upper:]]*$/) == 0
end