git.iko.soy/Idris-dev
on master help sign in
Merge branch 'master' of github.com:edwinb/Idris-dev
1453429Edwin Brady
contribs/lib/._simpleparser.idrnew file
compare with master
unifiedsplit

Binary file not shown.

contribs/lib/SQLite3/._sqlite3.cnew file

Binary file not shown.

contribs/lib/SQLite3/._sqlite3.idrnew file

Binary file not shown.

contribs/lib/SQLite3/._sqlite3api.cnew file

Binary file not shown.

contribs/lib/SQLite3/._sqlite3api.hnew file

Binary file not shown.

contribs/lib/SQLite3/newdb.dbnew file

Binary file not shown.

contribs/lib/SQLite3/somedb.dbnew file

Binary file not shown.

contribs/lib/SQLite3/sqlite3.cnew file+97
@@ -0,0 +1,97 @@
1+#include <stdio.h>
2+#include <string.h>
3+#include <sqlite3.h>
4+
5+sqlite3* db; // pointer to the database
6+
7+int first_row;
8+
9+int select_callback(void *p_data, int num_fields, char **p_fields, char **p_col_names) {
10+
11+ int i; // counter
12+ int *p_rn =(int*)p_data; // pointer counter
13+
14+ if(first_row) {
15+ first_row=0;
16+ // Go through the columns
17+ for(int i=0; i<num_fields; i++){
18+ printf("%20s", p_col_names[i]);
19+ }
20+ printf("\n");
21+ for(i=0; i<num_fields; i++){
22+ printf("=");
23+ }
24+ printf("\n");
25+ }
26+ (*p_rn)++; // increment the pointer counter for column
27+
28+
29+ for(i=0; i< num_fields; i++){
30+ printf("%20s", p_fields[i]);
31+ }
32+ printf("\n");
33+ return 0;
34+}
35+void select_stmt(const char* stmt){
36+ char *errmsg; // erro
37+ int ret; // return code
38+ int nrecs =0; // return code 0 for successful
39+
40+ first_row =1;
41+
42+ // open database, SQL to be evaluated, call back function, 1st argument to call back ,err
43+ ret = sqlite3_exec(db, stmt, select_callback, &nrecs, &errmsg);
44+ if(ret !=SQLITE_OK){
45+ printf("Error in select statement %s [%s].\n", stmt, errmsg);
46+ }
47+ else{
48+ printf("\n %d records returned.\n", nrecs);
49+ }
50+}
51+
52+void sql_stmt(const char* stmt){
53+
54+ char *errmsg;
55+ int ret;
56+ ret = sqlite3_exec(db, stmt, 0, 0, &errmsg);
57+
58+ if(ret !=SQLITE_OK){
59+ printf("Error in select statement %s [%s].\n", stmt, errmsg);
60+ }
61+}
62+
63+
64+void insert(){
65+ sql_stmt("begin");
66+ sql_stmt("insert into Student values ('Alice','Peterson',1234551,'Medicine',12)");
67+ //sql_stmt("insert into mytable values ('mytable2' , 251826, 22660136)");
68+ //sql_stmt("insert into mytable values ('mytable3' , 271826, 22684136)");
69+ sql_stmt("commit");
70+}
71+
72+int main(){
73+ sqlite3_open("./students.db", &db);
74+
75+ if(db ==0 ){
76+ printf("Could not open the database");
77+ return 1;
78+ }
79+
80+ //sql_stmt("Create table Student (Name, Surname, Passport ,School, School Student)");
81+ //insert();
82+// select_stmt("Select *from Student;");
83+// select_stmt("Select *from Module;");
84+// select_stmt("Select *from Enrollment;");
85+ select_stmt("SELECT student.name FROM student, module, enrollment WHERE module.credits = 30 AND student.school_student = enrollment.school_student AND student.school = enrollment.school AND enrollment.code = module.code");
86+
87+
88+ sqlite3_close(db);
89+ return 0;
90+}
91+
92+
93+
94+
95+
96+
97+
contribs/lib/SQLite3/sqlite3.idrnew file+284
@@ -0,0 +1,284 @@
1+module main
2+%lib "sqlite3"
3+%link "sqlite3api.o"
4+%include "sqlite3api.h"
5+
6+data DBVal = DBInt Int
7+ | DBText String
8+ | DBFloat Float
9+ | DBNull
10+
11+
12+data DBPointer = MkDBPointer Ptr
13+
14+data TBPointer = MkTBPointer Ptr
15+
16+data StmtPtr = MkStmtPtr Ptr
17+
18+Table : Set
19+Table = List (List DBVal)
20+
21+
22+forM : Monad m => List a -> (a -> m b) -> m (List b)
23+forM f xs = mapM xs f
24+
25+
26+data DB a = MkDB (IO (Either String a))
27+
28+instance Monad DB where
29+ (MkDB l) >>= k = MkDB (do c <- l
30+ case c of
31+ Left err => return (Left err)
32+ Right v => case k v of
33+ MkDB k' => k')
34+ return x = MkDB (return (Right x))
35+
36+fail : String -> DB a
37+fail err = MkDB (return (Left err))
38+
39+liftIO : IO a -> DB a
40+liftIO f = MkDB (do f' <- f
41+ return (Right f'))
42+
43+ioError : String -> IO a
44+ioError err = do putStrLn err
45+ return (believe_me ())
46+
47+runDB : DB a -> IO a
48+runDB (MkDB f) = do f' <- f
49+ case f' of
50+ Right v => return v
51+ Left str => ioError str
52+
53+
54+
55+open_db : String -> IO DBPointer
56+open_db name = do x <- mkForeign (FFun "sqlite3_open_idr" [FString] FPtr)name
57+ return (MkDBPointer x)
58+
59+close_db : DBPointer -> IO Int
60+close_db (MkDBPointer pointer) =mkForeign (FFun "sqlite3_close_idr" [FPtr] FInt)pointer
61+
62+
63+exec_db : DBPointer -> String -> DB Int
64+exec_db (MkDBPointer pointer) stmt = do
65+ x <- liftIO(mkForeign (FFun "sqlite3_exec_idr" [FPtr, FString] FInt)pointer stmt)
66+ if (x /= 0)
67+ then fail "Could not execute."
68+ else return x
69+
70+get_error : DBPointer -> IO String
71+get_error (MkDBPointer pointer) =mkForeign (FFun "sqlite3_get_error" [FPtr] FString)pointer
72+
73+
74+prepare_db : DBPointer -> String -> DB StmtPtr
75+prepare_db (MkDBPointer pointer) cmd = do
76+
77+ result <- liftIO (mkForeign (FFun "sqlite3_prepare_idr" [FPtr, FString] FPtr)pointer cmd)
78+ flag <- liftIO(nullPtr result)
79+ if flag
80+ then fail "Error occured"
81+ else return (MkStmtPtr result)
82+
83+
84+step_db : StmtPtr -> DB Int
85+step_db (MkStmtPtr pointer) = do
86+ x <- liftIO (mkForeign (FFun "sqlite3_step_idr" [FPtr] FInt)pointer)
87+ if ( x == 101)
88+ then fail "SQLITE_DONE"
89+ else return x
90+
91+
92+finalize_db : StmtPtr -> DB Int
93+finalize_db (MkStmtPtr pointer) = do
94+ x <- liftIO (mkForeign (FFun "sqlite3_finalize_idr" [FPtr] FInt)pointer)
95+ if (x /= 0)
96+ then fail "Could not finalize"
97+ else return x
98+
99+reset_db : StmtPtr -> DB Int
100+reset_db (MkStmtPtr pointer) = do
101+ x <- liftIO(mkForeign (FFun "sqlite3_reset_idr" [FPtr] FInt)pointer)
102+ if (x /=0)
103+ then fail "Could not reset"
104+ else return x
105+
106+column_count : DBPointer -> IO (Either String Int)
107+column_count (MkDBPointer pointer) = do
108+ x <- mkForeign (FFun "sqlite3_column_count_idr" [FPtr] FInt)pointer
109+ if (x == 0 )
110+ then return (Left "No Data")
111+ else return (Right x)
112+
113+column_name : DBPointer -> Int -> IO String
114+column_name (MkDBPointer pointer) iCol =mkForeign (FFun "sqlite3_column_name_idr" [FPtr, FInt] FString)pointer iCol
115+
116+column_decltype : DBPointer -> Int -> IO String
117+column_decltype (MkDBPointer pointer) iCol =mkForeign (FFun "sqlite3_column_decltype_idr" [FPtr, FInt] FString)pointer iCol
118+
119+
120+column_bytes : DBPointer -> Int -> IO Int
121+column_bytes (MkDBPointer pointer) iCol =mkForeign (FFun "sqlite3_column_bytes_idr" [FPtr, FInt] FInt)pointer iCol
122+
123+
124+column_blob : DBPointer -> Int -> IO String
125+column_blob (MkDBPointer pointer) iCol =mkForeign (FFun "sqlite3_column_bytes_idr" [FPtr, FInt] FString)pointer iCol
126+
127+
128+column_text : DBPointer -> Int -> IO String
129+column_text (MkDBPointer pointer) iCol =mkForeign (FFun "sqlite3_column_text_idr" [FPtr, FInt] FString)pointer iCol
130+
131+
132+column_Int : DBPointer -> Int -> IO Int
133+column_Int (MkDBPointer pointer) iCol =mkForeign (FFun "sqlite3_column_int_idr" [FPtr, FInt] FInt)pointer iCol
134+
135+
136+backup_init : DBPointer -> String -> DBPointer -> String -> IO DBPointer
137+backup_init (MkDBPointer des_pointer) destName (MkDBPointer src_pointer) srcName = do x <- mkForeign (FFun "sqlite3_backup_init_idr" [FPtr,FString, FPtr, FString] FPtr)des_pointer destName src_pointer srcName
138+ return (MkDBPointer x)
139+
140+backup_step : DBPointer -> Int -> IO Int
141+backup_step (MkDBPointer pointer) nPage =mkForeign (FFun "sqlite3_backup_step_idr" [FPtr, FInt] FInt)pointer nPage
142+
143+backup_finish : DBPointer -> IO Int
144+backup_finish (MkDBPointer pointer) =mkForeign (FFun "sqlite3_backup_finish_idr" [FPtr] FInt)pointer
145+
146+backup_remaining : DBPointer -> IO Int
147+backup_remaining (MkDBPointer pointer) =mkForeign (FFun "sqlite3_backup_remaining_idr" [FPtr] FInt)pointer
148+
149+
150+
151+get_table : DBPointer -> String -> DB TBPointer
152+get_table (MkDBPointer pointer) name = do
153+ x <- liftIO(mkForeign (FFun "sqlite3_get_table_idr" [FPtr, FString] FPtr)pointer name)
154+ flag <- liftIO(nullPtr x)
155+ if flag
156+ then do x <- liftIO(get_error_table pointer) ; fail x
157+ else return (MkTBPointer x)
158+ where
159+ get_error_table : Ptr-> IO String
160+ get_error_table pointer = do x <- mkForeign (FFun "sqlite3_get_error" [FPtr] FString)pointer
161+ return x
162+
163+
164+num_row : TBPointer -> IO Int
165+num_row (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_row" [FPtr] FInt)pointer
166+ return (x)
167+
168+num_col : TBPointer -> IO Int
169+num_col (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_get_num_col" [FPtr] FInt)pointer
170+ return (x)
171+
172+
173+get_data : DBPointer -> String -> Int -> Int -> IO DBVal
174+get_data (MkDBPointer pointer) tbl_name row col = do
175+ ty <- get_data_type pointer tbl_name row col
176+ helper ty
177+ where
178+ get_data_type : Ptr -> String -> Int -> Int -> IO Int
179+ get_data_type pointer tbl_name row col =mkForeign (FFun "sqlite3_get_data_type" [FPtr, FString, FInt, FInt] FInt)pointer tbl_name row col
180+
181+ get_data_val_int : Ptr -> String -> Int -> Int -> IO Int
182+ get_data_val_int pointer tbl_name row col =mkForeign (FFun "sqlite3_get_val_int" [FPtr, FString, FInt, FInt] FInt)pointer tbl_name row col
183+
184+ get_data_val_text : Ptr -> String -> Int -> Int -> IO String
185+ get_data_val_text pointer tbl_name row col =mkForeign (FFun "sqlite3_get_val_text" [FPtr, FString, FInt, FInt] FString)pointer tbl_name row col
186+
187+ get_data_val_float : Ptr -> String -> Int -> Int -> IO Float
188+ get_data_val_float pointer tbl_name row col =mkForeign (FFun "sqlite3_get_float" [FPtr, FString, FInt, FInt] FFloat)pointer tbl_name row col
189+
190+
191+ helper : Int -> IO DBVal
192+ helper 1 = do i <- get_data_val_int pointer tbl_name row col; return (DBInt i)
193+ helper 2 = do i <- get_data_val_float pointer tbl_name row col; return (DBFloat i)
194+ helper 3 = do i <- get_data_val_text pointer tbl_name row col; return (DBText i)
195+ helper _ = return (DBNull)
196+
197+
198+strcat : String -> String-> String
199+strcat str1 str2 = (str1 ++ str2)
200+
201+free_table : TBPointer -> IO ()
202+free_table (MkTBPointer pointer) = do x <- mkForeign (FFun "sqlite3_free_table_idr" [FPtr] FUnit)pointer
203+ return ()
204+
205+
206+toList : String -> String -> DBPointer -> DB Table
207+toList name stmt x = do
208+ ptr <- (get_table x (stmt))
209+ nbR <- liftIO (num_row ptr)
210+ nmC <- liftIO (num_col ptr)
211+ res <- forM [0..(nbR-1)] (\ i =>
212+ forM [0..(nmC-1)] (\ j =>
213+ liftIO(get_data x name i j)
214+ )
215+ )
216+ liftIO (free_table ptr)
217+ return res
218+
219+
220+bind_int : StmtPtr -> Int -> Int -> DB Int
221+bind_int (MkStmtPtr pointer) indexval val = do
222+ x <- liftIO(mkForeign (FFun "sqlite3_bind_int_idr" [FPtr, FInt, FInt] FInt)pointer indexval val)
223+ if (x /= 0 )
224+ then fail "Could not bind int."
225+ else return x
226+
227+
228+bind_float : StmtPtr -> Int -> Int -> DB Int
229+bind_float (MkStmtPtr pointer) indexval val = do
230+ x <- liftIO(mkForeign (FFun "sqlite3_bind_float_idr" [FPtr, FInt, FInt] FInt)pointer indexval val)
231+ if (x /= 0)
232+ then fail "Could not bind float."
233+ else return x
234+
235+bind_text : StmtPtr -> String -> Int -> Int -> DB Int
236+bind_text (MkStmtPtr pointer) text indexval lengthval = do
237+ x <- liftIO(mkForeign (FFun "sqlite3_bind_text_idr" [FPtr, FString, FInt, FInt] FInt)pointer text indexval lengthval)
238+ if (x /= 0)
239+ then fail "Could not bind text."
240+ else return x
241+
242+bind_null : StmtPtr -> Int -> DB Int
243+bind_null (MkStmtPtr pointer) indexval =do
244+ x <- liftIO(mkForeign (FFun "sqlite3_bind_null_idr" [FPtr, FInt] FInt)pointer indexval)
245+ if (x /= 0)
246+ then fail "Could not bind null."
247+ else return x
248+
249+
250+instance Show DBVal where
251+ show (DBInt i) = "Int val: " ++ show i
252+ show (DBText i) = "Text val: " ++ show i
253+ show (DBFloat i) = "Float val: " ++ show i
254+ show (DBNull ) = "NULL"
255+
256+print_data_v2 : DBVal -> String
257+print_data_v2 = show
258+
259+test : DB()
260+test = do db <- liftIO (open_db "somedb.db")
261+ stmt <- (prepare_db db "insert into tbl1 values (?,?);")
262+ bind_int stmt 1 456
263+ bind_text stmt "testing" 2 4
264+ step_db stmt
265+ reset_db stmt
266+ finalize_db stmt
267+ c <- liftIO (close_db db)
268+ return ()
269+
270+test2 : DB ()
271+test2 = do db <- liftIO (open_db "students.db")
272+ -- tbl <- (get_table db "SELECT Student.Name FROM Student, Module, Enrollment WHERE Module.Credits = 30 AND Student.School_student = Enrollment.School_Student AND Student.School = Enrollment.School AND Enrollment.Code = Module.Code")
273+ --res <- (toList "Student" "select *from Student;" db)
274+ mydata <- liftIO ( get_data db "Student" 1 1)
275+ liftIO(print mydata)
276+ c <- liftIO (close_db db)
277+ return ()
278+
279+main : IO ()
280+main = do x <- runDB (test2)
281+ --y <- runDB (test)
282+ return ()
283+
284+
contribs/lib/SQLite3/sqlite3api.cnew file+553
@@ -0,0 +1,553 @@
1+/*
2+ * sqlite3api.c
3+ *
4+ *
5+ * Created by Melissa Farinaz MOZIFIAN on 22/06/2012.
6+ * Copyright 2012. All rights reserved.
7+ *
8+ */
9+
10+
11+#include "sqlite3api.h"
12+
13+
14+
15+static char sql_query_buffer[2000];
16+unsigned char* array;
17+
18+void* sqlite3_open_idr(const char *filename){
19+
20+ sqlite3 *db;
21+ int res =sqlite3_open(filename,&db);
22+
23+ if(res != SQLITE_OK){
24+ printf("Error occured while opening the databse.");
25+ return NULL;
26+ }
27+ DBinfo *dbi = malloc(sizeof(DBinfo));
28+ dbi->db_ptr = db;
29+ return dbi;
30+
31+}
32+
33+int sqlite3_close_idr(void* db){
34+
35+ DBinfo* dbi =(DBinfo*) db;
36+ int res =sqlite3_close(dbi->db_ptr);
37+ if (res == SQLITE_OK){
38+ free(dbi);
39+ printf("Successfuly closed the databse\n");
40+ return 0;
41+ }
42+
43+ if(res == SQLITE_BUSY){
44+ printf("SQL Busy");
45+ return 5;
46+ }
47+
48+ else {
49+ return 1;
50+ }
51+}
52+
53+int sqlite3_exec_idr(void* db, const char *sql)
54+{
55+
56+ DBinfo* dbi =(DBinfo*) db;
57+ char* err;
58+ int rc;
59+
60+ rc = sqlite3_exec(dbi->db_ptr,sql,NULL, NULL, &err);
61+ printf("%d\n", rc);
62+ if (rc != SQLITE_OK && err != NULL) {
63+ strncpy(dbi->buffer, err, sizeof(dbi->buffer));
64+ sqlite3_free(err);
65+ }
66+ return rc;
67+}
68+
69+
70+char* sqlite3_get_error(void* db) {
71+ DBinfo* dbi =(DBinfo*) db;
72+ return dbi->buffer;
73+}
74+
75+void* sqlite3_prepare_idr(void *db,const char *zSql){
76+
77+ sqlite3_stmt* stmt;
78+ const char *tail;
79+
80+ DBinfo* dbi =(DBinfo*) db;
81+
82+ int rec = sqlite3_prepare_v2(dbi->db_ptr,zSql,-1,&stmt,&tail);
83+ dbi ->ppStmt =stmt;
84+ dbi ->Ptr_tail = tail;
85+
86+ if(rec != SQLITE_OK){
87+ return NULL;
88+ }
89+
90+ return dbi;
91+}
92+
93+void* sqlite3_get_table_idr(void* db,
94+ const char *sql){
95+
96+ DBinfo* dbi =(DBinfo*) db;
97+ char* err;
98+
99+ Table* tbl = malloc(sizeof(Table));
100+ tbl->database = dbi;
101+
102+ int res = sqlite3_get_table(dbi->db_ptr,sql,&tbl->table_data,&tbl->num_row,&tbl->num_col,&err);
103+
104+ int array_size = sizeof(&tbl->table_data);
105+
106+ if( res != SQLITE_OK && err != NULL){
107+ strncpy(dbi->buffer, err, sizeof(dbi->buffer));
108+ sqlite3_free(err);
109+ return NULL;
110+ }
111+
112+ tbl -> data_size = array_size;
113+
114+ int i, j, row, col;
115+
116+ row = tbl->num_row;
117+ col = tbl->num_col;
118+
119+ for( i=0; i< row; i++){
120+ for(j=0;j<col; j++){
121+ printf("%s\n", tbl->table_data[(i+1)*col +j]);
122+
123+ }
124+
125+ }
126+ return tbl;
127+
128+}
129+
130+int sqlite3_get_num_row(void* p){
131+
132+ Table* tbl =(Table*) p;
133+ int row_number =tbl->num_row;
134+ return row_number;
135+
136+
137+}
138+
139+int sqlite3_get_num_col(void* p){
140+
141+ Table* tbl =(Table*) p;
142+ int col_number =tbl-> num_col;
143+ return col_number;
144+
145+}
146+
147+int sqlite3_get_data_type(void* p,const char* tbl_name, int nRow, int nCol){
148+
149+ DBinfo* dbi =(DBinfo*) p;
150+ sqlite3_stmt* stmt;
151+ const char *tail;
152+ int rc,i, val, counter;
153+ const char* char_int;
154+
155+ counter =0;
156+ strcpy(sql_query_buffer, "select * from ");
157+ strcat(sql_query_buffer, tbl_name);
158+
159+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
160+ if(rc != SQLITE_OK){
161+ fprintf(stderr, "SQL Prepare error\n");
162+ return rc;
163+ }
164+ rc = sqlite3_step(stmt);
165+
166+ while (rc == SQLITE_ROW && counter < nRow){
167+
168+ rc = sqlite3_step(stmt);
169+ counter++;
170+
171+ }
172+
173+ val =sqlite3_column_type(stmt, nCol);
174+ printf("Type : %d\n", val );
175+
176+ rc =sqlite3_finalize(stmt);
177+ if( rc != SQLITE_OK){
178+ printf("Couldnt finalize:\n");
179+ }
180+ return val;
181+
182+}
183+
184+
185+int sqlite3_get_val_int(void* p,const char* tbl_name, int nRow, int nCol){
186+
187+
188+ DBinfo* dbi =(DBinfo*) p;
189+ sqlite3_stmt* stmt;
190+ const char *tail;
191+ int rc,i, val, counter;
192+ const char* char_int;
193+
194+ counter =0;
195+ strcpy(sql_query_buffer, "select * from ");
196+ strcat(sql_query_buffer, tbl_name);
197+
198+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
199+ if(rc != SQLITE_OK){
200+ fprintf(stderr, "SQL Prepare error\n");
201+ return rc;
202+ }
203+ rc = sqlite3_step(stmt);
204+
205+ while (rc == SQLITE_ROW && counter < nRow){
206+
207+ rc = sqlite3_step(stmt);
208+ counter++;
209+
210+ }
211+
212+ val =sqlite3_column_int(stmt, nCol);
213+ printf("int_val : %d\n", val );
214+ rc =sqlite3_finalize(stmt);
215+ if( rc != SQLITE_OK){
216+ printf("Couldnt finalize:\n");
217+ }
218+ return val;
219+
220+
221+}
222+
223+
224+const unsigned char* sqlite3_get_val_text(void* p,const char* tbl_name,int nRow, int nCol){
225+
226+
227+ DBinfo* dbi =(DBinfo*) p;
228+ sqlite3_stmt* stmt;
229+ const char *tail;
230+ int rc,i, val, counter;
231+ const unsigned char* text_val;
232+
233+ counter =0;
234+ strcpy(sql_query_buffer, "select * from ");
235+ strcat(sql_query_buffer, tbl_name);
236+
237+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
238+ if(rc != SQLITE_OK){
239+ fprintf(stderr, "SQL Prepare error\n");
240+ return NULL;
241+ }
242+ rc = sqlite3_step(stmt);
243+
244+ while (rc == SQLITE_ROW && counter < nRow){
245+
246+ rc = sqlite3_step(stmt);
247+ counter++;
248+
249+ }
250+
251+ array =(unsigned char *) malloc(1000*sizeof(char));
252+ text_val =sqlite3_column_text(stmt, nCol);
253+ memcpy(array, text_val, sizeof(text_val));
254+ printf("text_val : %s\n", text_val );
255+ rc =sqlite3_finalize(stmt);
256+ if( rc != SQLITE_OK){
257+ printf("Couldn't finalize.\n");
258+ }
259+
260+ return array;
261+
262+}
263+
264+float sqlite3_get_float(void* p,const char* tbl_name, int nRow, int nCol){
265+
266+ DBinfo* dbi =(DBinfo*) p;
267+ sqlite3_stmt* stmt;
268+ const char *tail;
269+ int rc,i, val, counter;
270+ double double_val;
271+
272+
273+ counter =0;
274+ strcpy(sql_query_buffer, "select * from ");
275+ strcat(sql_query_buffer, tbl_name);
276+
277+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
278+ if(rc != SQLITE_OK){
279+ fprintf(stderr, "SQL Prepare error\n");
280+
281+ }
282+ rc = sqlite3_step(stmt);
283+
284+ while (rc == SQLITE_ROW && counter < nRow){
285+
286+
287+ rc = sqlite3_step(stmt);
288+ counter++;
289+
290+ }
291+ double_val =sqlite3_column_double(stmt, nCol);
292+ float float_val =(float)double_val;
293+ printf("float_val %f\n", float_val);
294+ rc =sqlite3_finalize(stmt);
295+ if( rc != SQLITE_OK){
296+ printf("Couldn't finalize.\n");
297+ }
298+ return float_val;
299+
300+}
301+
302+
303+void sqlite3_free_table_idr(void* db){
304+ Table* tbl =(Table*) db;
305+ sqlite3_free_table(tbl->table_data);
306+ free(tbl);
307+}
308+
309+
310+int sqlite3_step_idr(void* db){
311+
312+ DBinfo* dbi =(DBinfo*) db;
313+ int rc =sqlite3_step(dbi->ppStmt);
314+ return rc;
315+}
316+
317+int sqlite3_bind_int_idr(void* p,int index, int val){
318+
319+ DBinfo* dbi =(DBinfo*) p;
320+ int rc;
321+
322+ printf("\nThe statement has %d wildcards\n", sqlite3_bind_parameter_count(dbi->ppStmt));
323+ rc =sqlite3_bind_int(dbi->ppStmt,index,val);
324+ if(rc != SQLITE_OK){
325+ return 1;
326+ }
327+
328+ return rc;
329+}
330+
331+int sqlite3_bind_float_idr(void* p,int index, float val){
332+
333+ DBinfo* dbi =(DBinfo*) p;
334+ int rc;
335+ double res =(float)val;
336+
337+ rc =sqlite3_bind_double(dbi->ppStmt,index,res);
338+
339+ if(rc != SQLITE_OK){
340+ return 1;
341+ }
342+
343+ return rc;
344+}
345+
346+int sqlite3_bind_null_idr(void* p,int index){
347+
348+ DBinfo* dbi =(DBinfo*) p;
349+ int rc;
350+ rc =sqlite3_bind_null(dbi->ppStmt,index);
351+ if(rc != SQLITE_OK){
352+ return 1;
353+ }
354+
355+ return rc;
356+}
357+
358+int sqlite3_bind_text_idr(void* p,const char* text, int index,int length){
359+
360+ DBinfo* dbi =(DBinfo*) p;
361+ int rc;
362+ rc =sqlite3_bind_text(dbi->ppStmt,index,text,length,SQLITE_STATIC);
363+ if(rc != SQLITE_OK){
364+ return 1;
365+ }
366+
367+ return rc;
368+
369+}
370+int sqlite3_column_count_idr(void* db, const char* tbl_name){
371+ DBinfo* dbi =(DBinfo*) db;
372+ sqlite3_stmt* stmt;
373+ const char *tail;
374+ int rc;
375+
376+ strcpy(sql_query_buffer, "select * from ");
377+ strcat(sql_query_buffer, tbl_name);
378+
379+ rc = sqlite3_prepare_v2(dbi->db_ptr, sql_query_buffer, -1, &stmt, &tail);
380+ if(rc != SQLITE_OK){
381+ fprintf(stderr, "SQL Prepare error");
382+ return rc;
383+ }
384+ printf("Prepare successful %d\n", rc);
385+
386+ rc =sqlite3_column_count(stmt);
387+ if(rc == 0){
388+ fprintf(stderr, "SQL column count error\n");
389+ return rc;
390+ }
391+ sqlite3_finalize(stmt);
392+
393+ // rc = actual column count
394+ return rc;
395+}
396+
397+
398+int sqlite3_data_count_idr(void* db){
399+
400+ DBinfo* dbi =(DBinfo*) db;
401+ int rc = sqlite3_data_count(dbi->ppStmt);
402+
403+ return rc;
404+
405+}
406+
407+int sqlite3_finalize_idr(void* db){
408+
409+ DBinfo* dbi=(DBinfo*) db;
410+ int rc =sqlite3_finalize(dbi->ppStmt);
411+ return rc;
412+}
413+
414+int sqlite3_complete_idr(const char *sql){
415+
416+ int rc = sqlite3_complete(sql);
417+ return rc;
418+
419+
420+}
421+int sqlite3_reset_idr(void* db){
422+
423+ DBinfo* dbi=(DBinfo*) db;
424+ int rc = sqlite3_reset(dbi-> ppStmt);
425+ return rc;
426+
427+}
428+
429+const char *sqlite3_column_name_idr(void* db, int N){
430+
431+ DBinfo* dbi=(DBinfo*) db;
432+ const char *name = sqlite3_column_name(dbi->ppStmt, N);
433+
434+ return name;
435+}
436+
437+const char *sqlite3_column_decltype_idr(void* db,int n){
438+ DBinfo* dbi=(DBinfo*) db;
439+ const char *dectype = sqlite3_column_decltype(dbi->ppStmt, n);
440+
441+ return dectype;
442+
443+}
444+
445+
446+int sqlite3_column_bytes_idr(void* db, int n){
447+
448+ DBinfo* dbi=(DBinfo*) db;
449+ int res = sqlite3_column_bytes(dbi->ppStmt, n);
450+ return res;
451+
452+
453+}
454+
455+const void *sqlite3_column_blob_idr(void* db, int iCol){
456+ DBinfo* dbi=(DBinfo*) db;
457+ const void* data =sqlite3_column_blob(dbi-> ppStmt, iCol);
458+ return data;
459+}
460+
461+const unsigned char *sqlite3_column_text_idr(void* db, int iCol){
462+ DBinfo* dbi=(DBinfo*) db;
463+ const unsigned char* col_text =sqlite3_column_text(dbi->ppStmt, iCol);
464+ return col_text;
465+
466+}
467+
468+int sqlite3_column_int_idr(void* db, int iCol){
469+ DBinfo* dbi=(DBinfo*) db;
470+ int res =sqlite3_column_int(dbi-> ppStmt, iCol);
471+ return res;
472+
473+}
474+
475+
476+void* sqlite3_backup_init_idr(void* pDest,
477+ const char *zDestName,
478+ void* pSource,
479+ const char *zSourceName
480+ ){
481+
482+ DBinfo* dbi=(DBinfo*) pDest;
483+ DBbackup* dbi2=(DBbackup*) pSource;
484+
485+ void* res = sqlite3_backup_init(dbi->db_ptr,zDestName,
486+ dbi2->source_ptr,zSourceName);
487+
488+ if(res == NULL){
489+ printf("Error number in initializing backup : %d\n", sqlite3_errcode(dbi->db_ptr));
490+ }
491+
492+ dbi2->backup = res;
493+ return dbi2;
494+
495+
496+}
497+
498+int sqlite3_backup_step_idr(void *backup, int nPage){
499+
500+ DBbackup* dbi=(DBbackup*) backup;
501+ int res = sqlite3_backup_step(dbi->backup, nPage);
502+
503+ if( res == SQLITE_OK){
504+ printf("Backup Success\n");
505+ }
506+ return res;
507+
508+
509+}
510+int sqlite3_backup_finish_idr(void *backup){
511+
512+ DBbackup* dbi=(DBbackup*) backup;
513+ int res = sqlite3_backup_finish(dbi->backup);
514+ return res;
515+
516+
517+}
518+
519+int sqlite3_backup_remaining_idr(void *backup){
520+
521+ DBbackup* dbi=(DBbackup*) backup;
522+ int res = sqlite3_backup_remaining(dbi->backup);
523+
524+ return res;
525+}
526+
527+int sqlite3_backup_pagecount_idr(void *backup){
528+
529+ DBbackup* dbi=(DBbackup*) backup;
530+ int res =sqlite3_backup_pagecount(dbi-> backup);
531+ return res;
532+
533+}
534+
535+int sqlite3_value_bytes_idr(void* value){
536+
537+ DBinfo* dbi=(DBinfo*) value;
538+ int res = sqlite3_value_bytes(dbi->value);
539+ return res;
540+
541+}
542+
543+int sqlite3_value_bytes16_idr(void* value){
544+
545+ DBinfo* dbi=(DBinfo*) value;
546+ int res =sqlite3_value_bytes16(dbi->value);
547+ return res;
548+
549+}
550+
551+
552+
553+
contribs/lib/SQLite3/sqlite3api.hnew file+127
@@ -0,0 +1,127 @@
1+/*
2+ * sqlite3api.h
3+ *
4+ *
5+ * Created by Melissa Farinaz MOZIFIAN on 22/06/2012.
6+ * Copyright 2012. All rights reserved.
7+ *
8+ */
9+#include <stdio.h>
10+#include <stdlib.h>
11+#include <string.h>
12+#include <sqlite3.h>
13+#include <ctype.h>
14+
15+typedef struct {
16+ sqlite3 *db_ptr;
17+ sqlite3_stmt *ppStmt;
18+ char buffer[1000];
19+ const char *Ptr_tail;
20+ sqlite3_blob *blob_ptr;
21+ sqlite3_value *value;
22+
23+} DBinfo;
24+
25+typedef struct {
26+ sqlite3 *source_ptr;
27+ sqlite3_backup *backup;
28+}DBbackup ;
29+
30+typedef struct {
31+ int num_row;
32+ int num_col;
33+ char** table_data;
34+ int data_size;
35+ int* data_type;
36+ DBinfo* database;
37+}Table;
38+
39+void* sqlite3_open_idr(const char *filename);
40+
41+int sqlite3_close_idr(void* db);
42+
43+int sqlite3_exec_idr(void*, const char *sql);
44+
45+char* sqlite3_get_error(void* db);
46+
47+
48+const unsigned char* sqlite3_get_val_text(void* p,const char* tbl_name,int nRow, int nCol);
49+
50+void* sqlite3_get_table_idr(void* db, const char *sql);
51+
52+int sqlite3_get_num_col(void* p);
53+
54+int sqlite3_get_num_row(void* p);
55+
56+void* sqlite3_get_data(void* p, int nRow, int nCol);
57+
58+int sqlite3_get_data_type(void* p,const char* tbl_name,int nRow, int nCol);
59+
60+int sqlite3_get_val_int(void* p,const char* tbl_name, int nRow, int nCol);
61+
62+float sqlite3_get_float(void* p,const char* tbl_name, int nRow, int nCol);
63+
64+void sqlite3_free_table_idr(void* db);
65+
66+void* sqlite3_prepare_idr(
67+ void *db, /* Database handle */
68+ const char *zSql /* SQL statement, UTF-8 encoded */
69+);
70+
71+int sqlite3_step_idr(void* stmt);
72+
73+int sqlite3_bind_float_idr(void* p,int index, float val);
74+
75+int sqlite3_bind_int_idr(void* p,int index , int val);
76+
77+int sqlite3_bind_int_idr_v2(void* p,int index , int val);
78+
79+int sqlite3_bind_null_idr(void* p,int index);
80+
81+int sqlite3_bind_text_idr(void* p,const char* text, int index,int length);
82+
83+int sqlite3_column_count_idr(void* stmt, const char* tbl_name);
84+
85+int sqlite3_data_count_idr(void* stmt);
86+
87+int sqlite3_reset_idr(void* stmt);
88+
89+int sqlite3_finalize_idr(void* stmt);
90+
91+int sqlite3_complete_idr(const char *sql);
92+
93+const char *sqlite3_column_decltype_idr(void* stmt,int n);
94+
95+const char *sqlite3_column_name_idr(void* stmt, int N);
96+
97+int sqlite3_column_bytes_idr(void* stmt, int n);
98+
99+int sqlite3_column_bytes_idr(void* stmt, int n);
100+
101+const void *sqlite3_column_blob_idr(void* stmt, int iCol);
102+
103+const unsigned char *sqlite3_column_text_idr(void* stmt, int iCol);
104+
105+int sqlite3_column_int_idr(void* stmt, int iCol);
106+
107+
108+void* sqlite3_backup_init_idr(void* pDestm,
109+ const char *zDestName,
110+ void* pSource,
111+ const char *zSourceName
112+ );
113+
114+int sqlite3_backup_finish_idr(void *backup);
115+
116+int sqlite3_backup_step_idr(void *backup, int nPage);
117+
118+int sqlite3_backup_remaining_idr(void *backup);
119+
120+int sqlite3_backup_pagecount_idr(void *backup);
121+
122+int sqlite3_value_bytes_idr(void* value);
123+
124+int sqlite3_value_bytes16_idr(void* value);
125+
126+int sqlite3_errcode(sqlite3 *db);
127+
contribs/lib/SQLite3/students.dbnew file

Binary file not shown.

contribs/lib/simpleparser.idrnew file+183
@@ -0,0 +1,183 @@
1+module Parsing
2+
3+import prelude
4+import builtins
5+
6+infixr 5 |||
7+
8+{-
9+The monad of parsers
10+--------------------
11+-}
12+
13+data Parser a = P (String -> Either String (a,String))
14+
15+parse : Parser a -> String ->Either String (a,String)
16+parse (P p) inp = p inp
17+
18+instance Monad Parser where
19+ return v = P (\inp => Right (v,inp))
20+ p >>= f = P (\inp => case parse p inp of
21+ Left err => Left err
22+ Right (v,rest) => parse (f v) rest)
23+
24+
25+instance MonadPlus Parser where
26+ mzero = P (\inp => Left "Parse Error")
27+ mplus p q = P (\inp => case parse p inp of
28+ Left msg => parse q inp
29+ Right (v,out) => Right(v,out))
30+
31+
32+{-
33+Basic parsers
34+-------------
35+-}
36+
37+failure : String -> Parser a
38+failure msg = P (\inp => Left msg)
39+
40+item : Parser Char
41+item = P (\inp => case unpack inp of
42+ [] => Left "Error! Parsing empty list."
43+ (x::xs) => Right (x, pack xs))
44+
45+
46+{-
47+Choice
48+--------
49+---}
50+
51+(|||) : Parser a -> Parser a -> Parser a
52+p ||| q = p `mplus` q
53+
54+
55+--{-
56+--Derived primitives
57+---}
58+
59+sat : (Char -> Bool) -> Parser Char
60+sat p = item >>= (\x => if p x then return x else failure "failed")
61+
62+oneof : List Char -> Parser Char
63+oneof xs = sat (\x => elem x xs)
64+
65+digit : Parser Char
66+digit = sat isDigit
67+
68+lower : Parser Char
69+lower = sat isLower
70+
71+upper : Parser Char
72+upper = sat isUpper
73+
74+letter : Parser Char
75+letter = sat isAlpha
76+
77+alphanum : Parser Char
78+alphanum = sat isAlphaNum
79+
80+char : Char -> Parser Char
81+char x = sat (== x)
82+
83+string : String -> Parser String
84+helper : List Char -> Parser (List Char)
85+string s = do result <- helper (unpack s)
86+ return (pack result)
87+
88+helper [] = return []
89+helper (x::xs) = do char x
90+ string (cast xs)
91+ return (x :: xs)
92+
93+many1 : Parser a -> Parser (List a)
94+many : Parser a -> Parser (List a)
95+many1 p = do v <- p
96+ vs <- many p
97+ return (v::vs)
98+
99+
100+many p = many1 p `mplus` return []
101+
102+
103+
104+ident : Parser String
105+ident = do x <- letter
106+ xs <- many1 alphanum
107+ return (pack(x::xs))
108+
109+
110+nat : Parser Int
111+nat = do xs <- many digit
112+ return (cast (cast xs))
113+
114+
115+int : Parser Int
116+int = do char '-'
117+ n <- nat
118+ return (-n)
119+ `mplus` nat
120+
121+space : Parser ()
122+space = do many (sat isSpace)
123+ return ()
124+--{-
125+--Ignoring spacing
126+---}
127+
128+token : Parser a -> Parser a
129+token p = do space
130+ v <- p
131+ space
132+ return v
133+
134+identifier : Parser String
135+identifier = token ident
136+
137+natural : Parser Int
138+natural = token nat
139+
140+integer : Parser Int
141+integer = token int
142+
143+symbol : String -> Parser String
144+symbol xs = token (string xs)
145+
146+--apply : Parser a -> String -> List (a,String)
147+--apply p = parse (space >>= (\_ => p))
148+
149+--{-
150+-- Expressions
151+---}
152+
153+factor : Parser Int
154+term : Parser Int
155+expr : Parser Int
156+expr = do t <- term
157+ do symbol "+"
158+ e <- expr
159+ Right (t+e)
160+ ||| Right t
161+
162+
163+factor = do symbol "("
164+ do e <- expr
165+ symbol ")"
166+ return e
167+ ||| natural
168+
169+term = do f <- factor
170+ do symbol "*"
171+ t <- term
172+ return (f * t)
173+ ||| return f
174+
175+
176+
177+eval : String -> Maybe Int
178+eval xs = case (parse expr xs) of
179+ Right (n,rest) => if rest == "" then Just n else Nothing
180+ Left msg => Nothing
181+
182+
183+
git-credential-osxkeychainnew file

Binary file not shown.

rts/closure.onew file

Binary file not shown.

rts/libidris_rts.anew file

Binary file not shown.