Use Data.Maybe Maybe for compatibility

[CleanReadLine.git] / ReadLine.icl

diff --git a/ReadLine.icl b/ReadLine.icl
index 6320117..4d15493 100644 (file)
--- a/ReadLine.icl
+++ b/ReadLine.icl
@@ -1,6 +1,7 @@
 implementation module ReadLine
 
 import StdEnv
+import Data.Maybe
 
 import code from "readLine.o"
 
@@ -26,13 +27,13 @@ readLine s h e
                                ccall cleanReadLine "SI:VSI:A"
                        }
 
-setReadLineName :: !String !*env -> !*env
+setReadLineName :: !String !*env -> *env
 setReadLineName s e = code {
                ccall cleanSetReadLineName "S:V:A"
        }
 
 //Initializing History and State Management
-usingHistory :: !*env -> !*env
+usingHistory :: !*env -> *env
 usingHistory e = code {
                ccall cleanUsingHistory ":V:A"
        }
@@ -60,39 +61,39 @@ historyGetHistoryState e
                        }
                
 
-historySetHistoryState :: !HistoryState !*env -> !*env
+historySetHistoryState :: !HistoryState !*env -> *env
 historySetHistoryState {entries,offset,flags} e
 # e = initNewHistoryState offset flags (length entries) e
 # e = setItems entries 0 e
 = commit e
        where
-               initNewHistoryState :: !Int !Int !Int !*env -> !*env
+               initNewHistoryState :: !Int !Int !Int !*env -> *env
                initNewHistoryState o f l e = code {
                                ccall cleanInitNewHistoryState "III:V:A"
                        }
-               setItems :: ![HistoryItem] !Int !*env -> !*env
+               setItems :: ![HistoryItem] !Int !*env -> *env
                setItems [] _ e = e
                setItems [x:xs] i e
                # e = setItem i x.line x.timestamp e
                = setItems xs (i+1) e
 
-               setItem :: !Int !String !String !*env -> !*env
+               setItem :: !Int !String !String !*env -> *env
                setItem i l t e = code {
                                ccall cleanSetNewHistoryEntry "ISS:V:A"
                        }
                
-               commit :: !*env -> !*env
+               commit :: !*env -> *env
                commit e = code {
                                ccall cleanCommitSetHistory ":V:A"
                        }
 
 //History List Management
-addHistory :: !String !*env -> !*env
+addHistory :: !String !*env -> *env
 addHistory s e = code {
                ccall cleanAddHistory "S:V:A"
        }
 
-addHistoryTime :: !String !*env -> !*env
+addHistoryTime :: !String !*env -> *env
 addHistoryTime s e = code {
                ccall cleanAddHistoryTime "S:V:A"
        }
@@ -117,17 +118,17 @@ replaceHistoryEntry i s e
                                ccall cleanReplaceHistoryEntry "IS:VSS:A"
                        }
 
-clearHistory :: !*env -> !*env
+clearHistory :: !*env -> *env
 clearHistory e = code {
                ccall cleanClearHistory ":V:A"
        }
 
-stifleHistory :: !Int !*env -> !*env
+stifleHistory :: !Int !*env -> *env
 stifleHistory i e = code {
                ccall cleanStifleHistory "I:V:A"
        }
 
-unstifleHistory :: !*env -> !*env
+unstifleHistory :: !*env -> *env
 unstifleHistory e = code {
                ccall cleanUnstifleHistory ":V:A"
        }
@@ -167,6 +168,30 @@ historyTotalBytes e = code {
        }
 
 //Moving Around the History List
+historySetPos :: !Int !*env -> (!Int, !*env)
+historySetPos i e = code {
+               ccall cleanHistorySetPos "I:I:A"
+       }
+
+previousHistory :: !*env -> (!Maybe HistoryItem, !*env)
+previousHistory e
+# (line, timestamp, null, e) = previousHistoryItem e
+= (if null Nothing (Just {HistoryItem | line=line, timestamp=timestamp}), e)
+       where
+               previousHistoryItem :: !*env -> (!String, !String, !Bool, !*env)
+               previousHistoryItem e = code {
+                               ccall cleanPreviousHistory ":VSSI:A"
+                       }
+
+nextHistory :: !*env -> (!Maybe HistoryItem, !*env)
+nextHistory e
+# (line, timestamp, null, e) = nextHistoryItem e
+= (if null Nothing (Just {HistoryItem | line=line, timestamp=timestamp}), e)
+       where
+               nextHistoryItem :: !*env -> (!String, !String, !Bool, !*env)
+               nextHistoryItem e = code {
+                               ccall cleanNextHistory ":VSSI:A"
+                       }
 
 //Searching the History List
 historySearch :: !String !Int !*env-> (!Int, !*env)
@@ -210,3 +235,51 @@ historyTruncateFile :: !String !Int !*env -> (!Bool, !*env)
 historyTruncateFile i s e = code {
                ccall cleanWriteHistory "SI:I:A"
        }
+
+historyExpand :: !String !*env -> (!String, !Int, !*env)
+historyExpand s e = code {
+               ccall cleanHistoryExpand "S:VSI:A"      
+       }
+
+getHistoryEvent :: !String !Int !Int !*env -> (!Maybe String, !Int, !*env)
+getHistoryEvent s i1 i2 e
+# (string, cindex, null, e) = getHistoryEventItem s i1 i2 e
+= (if null Nothing (Just string), cindex, e)
+       where
+               getHistoryEventItem :: !String !Int !Int !*env -> (!String, !Int, !Bool, !*env)
+               getHistoryEventItem s i1 i2 e = code {
+                               ccall cleanGetHistoryEvent "SII:VSII:A"
+                       }
+
+historyTokenize :: !String !*env -> ([String], !*env)
+historyTokenize s e
+# (i, e) = historyTokenizeInit s e
+= historyTokenizeItems i e
+//= ([], e)
+       where
+               historyTokenizeInit :: !String !*env -> (!Int, !*env)
+               historyTokenizeInit s e = code {
+                               ccall cleanHistoryTokenizeInit "S:I:A"
+                       }
+
+               historyTokenizeItems :: !Int !*env -> (![String], !*env)
+               historyTokenizeItems 0 e = ([], e)
+               historyTokenizeItems i e
+               # (token, e) = historyTokenizeItem (i-1) e
+               # (rest, e) = historyTokenizeItems (i-1) e
+               = ([token:rest], e)
+
+               historyTokenizeItem :: !Int !*env -> (!String, !*env)
+               historyTokenizeItem i e = code {
+                               ccall cleanHistoryTokenizeItem "I:S:A"
+                       }
+
+historyArgExtract :: !Int !Int !String !*env -> (!Maybe String, !*env)
+historyArgExtract i1 i2 s e
+# (string, null, e) = historyArgExtractItem i1 i2 s e
+= (if null Nothing (Just string), e)
+       where
+               historyArgExtractItem :: !Int !Int !String !*env -> (!String, !Bool, !*env)
+               historyArgExtractItem i1 i2 s e = code {
+                               ccall cleanHistoryArgExtract "IIS:VSI:A"
+                       }