From 7e433007c5e8dda8a993c279d86402257595d8e3 Mon Sep 17 00:00:00 2001
From: arphaman <arphaman@gmail.com>
Date: Fri, 12 Jul 2013 18:02:33 +0100
Subject: added character functions

---
 include/Strings/Character.h |  31 ++++++++++++
 lib/Strings/CMakeLists.txt  |   2 +
 lib/Strings/Character.cpp   | 120 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 153 insertions(+)
 create mode 100644 include/Strings/Character.h
 create mode 100644 lib/Strings/Character.cpp

diff --git a/include/Strings/Character.h b/include/Strings/Character.h
new file mode 100644
index 0000000..7c67577
--- /dev/null
+++ b/include/Strings/Character.h
@@ -0,0 +1,31 @@
+//===--- Core.h - Core library  --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBFLANG_STRINGS_CHARACTER_H
+#define LLVM_LIBFLANG_STRINGS_CHARACTER_H
+
+#include <stdint.h>
+#include "Libflang.h"
+
+
+LIBFLANG_ABI void libflang_assignment_char1(char *LHS, size_t LHSLength,
+                                            char *RHS, size_t RHSLength);
+LIBFLANG_ABI void libflang_concat_char1(char *Dest, size_t DestLength,
+                                        char *LHS, size_t LHSLength,
+                                        char *RHS, size_t RHSLength);
+LIBFLANG_ABI int32_t libflang_compare_char1(const char *LHS, size_t LHSLength,
+                                            const char *RHS, size_t RHSLength);
+
+// intrinsics
+
+LIBFLANG_ABI int32_t libflang_lexcompare_char1(const char *LHS, size_t LHSLength,
+                                               const char *RHS, size_t RHSLength);
+LIBFLANG_ABI size_t libflang_lentrim_char1(const char *String, size_t Length);
+
+#endif
diff --git a/lib/Strings/CMakeLists.txt b/lib/Strings/CMakeLists.txt
index 8b13789..bc70b38 100644
--- a/lib/Strings/CMakeLists.txt
+++ b/lib/Strings/CMakeLists.txt
@@ -1 +1,3 @@
+add_libflang_library(libflangStrings
+  Character.cpp)
 
diff --git a/lib/Strings/Character.cpp b/lib/Strings/Character.cpp
new file mode 100644
index 0000000..e5274bf
--- /dev/null
+++ b/lib/Strings/Character.cpp
@@ -0,0 +1,120 @@
+#include <cstdlib>
+#include <cstring>
+#include "Strings/Character.h"
+
+template<typename T>
+struct CharacterValue {
+  T *Ptr;
+  size_t Length;
+
+  CharacterValue() {}
+  CharacterValue(T *P, size_t Len)
+    : Ptr(P), Length(Len) {}
+
+  CharacterValue<T> sliceFrom(size_t Start) const {
+    return CharacterValue<T>(Ptr + Start, Length - Start);
+  }
+};
+
+static inline
+CharacterValue<const char> generic(const char *Ptr, size_t Length) {
+  return CharacterValue<const char>(Ptr, Length);
+}
+
+static inline
+CharacterValue<char> generic(char *Ptr, size_t Length) {
+  return CharacterValue<char>(Ptr, Length);
+}
+
+
+/// Returns true if a character is a whitespace
+static bool isWhitespace(uint32_t C) {
+  return C == ' '; //FIXME
+}
+
+template<typename T>
+static void fill(const CharacterValue<T> String, const char C = ' ') {
+  for(size_t I = 0; I < String.Length; ++I)
+    String.Ptr[I] = T(C);
+}
+
+template<typename T>
+static void assign(const CharacterValue<T> LHS,
+                   const CharacterValue<T> RHS) {
+  if(LHS.Length <= RHS.Length) {
+    memmove(LHS.Ptr, RHS.Ptr, LHS.Length);
+    return;
+  }
+  memmove(LHS.Ptr, RHS.Ptr, RHS.Length);
+  fill(LHS.sliceFrom(RHS.Length));
+}
+
+template<typename T>
+static void concat(CharacterValue<T> Dest,
+                   const CharacterValue<T> LHS,
+                   const CharacterValue<T> RHS) {
+  if(Dest.Length <= LHS.Length) {
+    memmove(Dest.Ptr, LHS.Ptr, Dest.Length);
+    return;
+  }
+  memmove(Dest.Ptr, LHS.Ptr, LHS.Length);
+  Dest = Dest.sliceFrom(LHS.Length);
+  if(Dest.Length <= RHS.Length) {
+    memmove(Dest.Ptr, RHS.Ptr, Dest.Length);
+    return;
+  }
+  memmove(Dest.Ptr, RHS.Ptr, RHS.Length);
+  fill(Dest.sliceFrom(RHS.Length));
+}
+
+template<typename T>
+static int32_t compare(const CharacterValue<T> LHS,
+                       const CharacterValue<T> RHS) {
+  if(LHS.Length < RHS.Length) return -1;
+  else if(LHS.Length > RHS.Length) return 1;
+  return memcmp(LHS.Ptr, RHS.Ptr, LHS.Length);
+}
+
+template<typename T>
+static int32_t lexcompare(const CharacterValue<T> LHS,
+                          const CharacterValue<T> RHS) {
+  return 0;//FIXME
+}
+
+template<typename T>
+static size_t lentrim(const CharacterValue<T> String) {
+  for(size_t I = String.Length; I > 0; I--) {
+    if(isWhitespace(String.Ptr[I-1])) return I;
+  }
+  return String.Length;
+}
+
+// core
+
+LIBFLANG_ABI void libflang_assignment_char1(char *LHS, size_t LHSLength,
+                                            char *RHS, size_t RHSLength) {
+  assign(generic(LHS, LHSLength), generic(RHS, RHSLength));
+}
+
+LIBFLANG_ABI void libflang_concat_char1(char *Dest, size_t DestLength,
+                                        char *LHS, size_t LHSLength,
+                                        char *RHS, size_t RHSLength) {
+  concat(generic(Dest, DestLength),
+         generic(LHS, LHSLength), generic(RHS, RHSLength));
+}
+
+LIBFLANG_ABI int32_t libflang_compare_char1(const char *LHS, size_t LHSLength,
+                                            const char *RHS, size_t RHSLength) {
+  return compare(generic(LHS, LHSLength), generic(RHS, RHSLength));
+}
+
+// intrinsics
+
+LIBFLANG_ABI int32_t libflang_lexcompare_char1(const char *LHS, size_t LHSLength,
+                                               const char *RHS, size_t RHSLength) {
+  return lexcompare(generic(LHS, LHSLength), generic(RHS, RHSLength));
+}
+
+LIBFLANG_ABI size_t libflang_lentrim_char1(const char *String, size_t Length) {
+  return lentrim(generic(String, Length));
+}
-- 
cgit v1.2.1