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