summary refs log tree commit diff stats
path: root/lib/impure
diff options
context:
space:
mode:
Diffstat (limited to 'lib/impure')
-rw-r--r--lib/impure/db_mysql.nim52
-rw-r--r--lib/impure/db_postgres.nim116
-rw-r--r--lib/impure/db_sqlite.nim42
-rw-r--r--lib/impure/dialogs.nim8
-rw-r--r--lib/impure/fenv.nim12
-rw-r--r--lib/impure/graphics.nim242
-rw-r--r--lib/impure/osinfo_posix.nim31
-rw-r--r--lib/impure/osinfo_win.nim10
-rw-r--r--lib/impure/rdstdin.nim10
-rw-r--r--lib/impure/re.nim151
-rw-r--r--lib/impure/ssl.nim36
-rw-r--r--lib/impure/web.nim63
-rw-r--r--lib/impure/zipfiles.nim24
13 files changed, 368 insertions, 429 deletions
diff --git a/lib/impure/db_mysql.nim b/lib/impure/db_mysql.nim
index ce48a32ed..37bea45b4 100644
--- a/lib/impure/db_mysql.nim
+++ b/lib/impure/db_mysql.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -82,17 +82,17 @@ proc tryExec*(db: TDbConn, query: TSqlQuery, args: varargs[string, `$`]): bool {
   tags: [FReadDB, FWriteDb].} =
   ## tries to execute the query and returns true if successful, false otherwise.
   var q = dbFormat(query, args)
-  return mysql.RealQuery(db, q, q.len) == 0'i32
+  return mysql.realQuery(db, q, q.len) == 0'i32
 
 proc rawExec(db: TDbConn, query: TSqlQuery, args: varargs[string, `$`]) =
   var q = dbFormat(query, args)
-  if mysql.RealQuery(db, q, q.len) != 0'i32: dbError(db)
+  if mysql.realQuery(db, q, q.len) != 0'i32: dbError(db)
 
 proc exec*(db: TDbConn, query: TSqlQuery, args: varargs[string, `$`]) {.
   tags: [FReadDB, FWriteDb].} =
   ## executes the query and raises EDB if not successful.
   var q = dbFormat(query, args)
-  if mysql.RealQuery(db, q, q.len) != 0'i32: dbError(db)
+  if mysql.realQuery(db, q, q.len) != 0'i32: dbError(db)
     
 proc newRow(L: int): TRow = 
   newSeq(result, L)
@@ -100,8 +100,8 @@ proc newRow(L: int): TRow =
   
 proc properFreeResult(sqlres: mysql.PRES, row: cstringArray) =  
   if row != nil:
-    while mysql.FetchRow(sqlres) != nil: discard
-  mysql.FreeResult(sqlres)
+    while mysql.fetchRow(sqlres) != nil: discard
+  mysql.freeResult(sqlres)
   
 iterator fastRows*(db: TDbConn, query: TSqlQuery,
                    args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
@@ -109,13 +109,13 @@ iterator fastRows*(db: TDbConn, query: TSqlQuery,
   ## fast, but potenially dangerous: If the for-loop-body executes another
   ## query, the results can be undefined. For MySQL this is the case!.
   rawExec(db, query, args)
-  var sqlres = mysql.UseResult(db)
+  var sqlres = mysql.useResult(db)
   if sqlres != nil:
-    var L = int(mysql.NumFields(sqlres))
+    var L = int(mysql.numFields(sqlres))
     var result = newRow(L)
     var row: cstringArray
     while true:
-      row = mysql.FetchRow(sqlres)
+      row = mysql.fetchRow(sqlres)
       if row == nil: break
       for i in 0..L-1: 
         setLen(result[i], 0)
@@ -131,11 +131,11 @@ proc getRow*(db: TDbConn, query: TSqlQuery,
   ## retrieves a single row. If the query doesn't return any rows, this proc
   ## will return a TRow with empty strings for each column.
   rawExec(db, query, args)
-  var sqlres = mysql.UseResult(db)
+  var sqlres = mysql.useResult(db)
   if sqlres != nil:
-    var L = int(mysql.NumFields(sqlres))
+    var L = int(mysql.numFields(sqlres))
     result = newRow(L)
-    var row = mysql.FetchRow(sqlres)
+    var row = mysql.fetchRow(sqlres)
     if row != nil: 
       for i in 0..L-1: 
         setLen(result[i], 0)
@@ -150,13 +150,13 @@ proc getAllRows*(db: TDbConn, query: TSqlQuery,
   ## executes the query and returns the whole result dataset.
   result = @[]
   rawExec(db, query, args)
-  var sqlres = mysql.UseResult(db)
+  var sqlres = mysql.useResult(db)
   if sqlres != nil:
-    var L = int(mysql.NumFields(sqlres))
+    var L = int(mysql.numFields(sqlres))
     var row: cstringArray
     var j = 0
     while true:
-      row = mysql.FetchRow(sqlres)
+      row = mysql.fetchRow(sqlres)
       if row == nil: break
       setLen(result, j+1)
       newSeq(result[j], L)
@@ -166,12 +166,12 @@ proc getAllRows*(db: TDbConn, query: TSqlQuery,
         else:
           result[j][i] = $row[i]
       inc(j)
-    mysql.FreeResult(sqlres)
+    mysql.freeResult(sqlres)
 
 iterator rows*(db: TDbConn, query: TSqlQuery, 
                args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
-  ## same as `FastRows`, but slower and safe.
-  for r in items(GetAllRows(db, query, args)): yield r
+  ## same as `fastRows`, but slower and safe.
+  for r in items(getAllRows(db, query, args)): yield r
 
 proc getValue*(db: TDbConn, query: TSqlQuery, 
                args: varargs[string, `$`]): string {.tags: [FReadDB].} = 
@@ -179,7 +179,7 @@ proc getValue*(db: TDbConn, query: TSqlQuery,
   ## result dataset. Returns "" if the dataset contains no rows or the database
   ## value is NULL.
   result = ""
-  for row in FastRows(db, query, args): 
+  for row in fastRows(db, query, args): 
     result = row[0]
     break
 
@@ -188,16 +188,16 @@ proc tryInsertId*(db: TDbConn, query: TSqlQuery,
   ## executes the query (typically "INSERT") and returns the 
   ## generated ID for the row or -1 in case of an error.
   var q = dbFormat(query, args)
-  if mysql.RealQuery(db, q, q.len) != 0'i32: 
+  if mysql.realQuery(db, q, q.len) != 0'i32: 
     result = -1'i64
   else:
-    result = mysql.InsertId(db)
+    result = mysql.insertId(db)
   
 proc insertId*(db: TDbConn, query: TSqlQuery, 
                args: varargs[string, `$`]): int64 {.tags: [FWriteDb].} = 
   ## executes the query (typically "INSERT") and returns the 
   ## generated ID for the row.
-  result = TryInsertID(db, query, args)
+  result = tryInsertID(db, query, args)
   if result < 0: dbError(db)
 
 proc execAffectedRows*(db: TDbConn, query: TSqlQuery, 
@@ -206,7 +206,7 @@ proc execAffectedRows*(db: TDbConn, query: TSqlQuery,
   ## runs the query (typically "UPDATE") and returns the
   ## number of affected rows
   rawExec(db, query, args)
-  result = mysql.AffectedRows(db)
+  result = mysql.affectedRows(db)
 
 proc close*(db: TDbConn) {.tags: [FDb].} = 
   ## closes the database connection.
@@ -216,7 +216,7 @@ proc open*(connection, user, password, database: string): TDbConn {.
   tags: [FDb].} =
   ## opens a database connection. Raises `EDb` if the connection could not
   ## be established.
-  result = mysql.Init(nil)
+  result = mysql.init(nil)
   if result == nil: dbError("could not open database connection") 
   let
     colonPos = connection.find(':')
@@ -224,9 +224,9 @@ proc open*(connection, user, password, database: string): TDbConn {.
                   else:            substr(connection, 0, colonPos-1)
     port: int32 = if colonPos < 0: 0'i32
                   else:            substr(connection, colonPos+1).parseInt.int32
-  if mysql.RealConnect(result, host, user, password, database, 
+  if mysql.realConnect(result, host, user, password, database, 
                        port, nil, 0) == nil:
     var errmsg = $mysql.error(result)
-    db_mysql.Close(result)
+    db_mysql.close(result)
     dbError(errmsg)
 
diff --git a/lib/impure/db_postgres.nim b/lib/impure/db_postgres.nim
index 510cb8e45..6691c5703 100644
--- a/lib/impure/db_postgres.nim
+++ b/lib/impure/db_postgres.nim
@@ -1,7 +1,7 @@
 #
 #
-#            Nimrod's Runtime Library
-#        (c) Copyright 2012 Andreas Rumpf
+#            Nim's Runtime Library
+#        (c) Copyright 2014 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
@@ -16,16 +16,16 @@ type
   TDbConn* = PPGconn   ## encapsulates a database connection
   TRow* = seq[string]  ## a row of a dataset. NULL database values will be
                        ## transformed always to the empty string.
-  EDb* = object of EIO ## exception that is raised if a database error occurs
+  EDb* = object of IOError ## exception that is raised if a database error occurs
   
   TSqlQuery* = distinct string ## an SQL query string
   TSqlPrepared* = distinct string ## a identifier for the prepared queries
 
-  FDb* = object of FIO ## effect that denotes a database operation
-  FReadDb* = object of FDB   ## effect that denotes a read operation
-  FWriteDb* = object of FDB  ## effect that denotes a write operation
+  FDb* = object of IOEffect ## effect that denotes a database operation
+  FReadDb* = object of FDb   ## effect that denotes a read operation
+  FWriteDb* = object of FDb  ## effect that denotes a write operation
 
-proc sql*(query: string): TSqlQuery {.noSideEffect, inline.} =
+proc sql*(query: string): TSqlQuery {.noSideEffect, inline.} =  
   ## constructs a TSqlQuery from the string `query`. This is supposed to be 
   ## used as a raw-string-literal modifier:
   ## ``sql"update user set counter = counter + 1"``
@@ -38,7 +38,7 @@ proc dbError*(db: TDbConn) {.noreturn.} =
   ## raises an EDb exception.
   var e: ref EDb
   new(e)
-  e.msg = $PQerrorMessage(db)
+  e.msg = $pqErrorMessage(db)
   raise e
 
 proc dbError*(msg: string) {.noreturn.} =
@@ -73,30 +73,30 @@ proc tryExec*(db: TDbConn, query: TSqlQuery,
               args: varargs[string, `$`]): bool {.tags: [FReadDB, FWriteDb].} =
   ## tries to execute the query and returns true if successful, false otherwise.
   var arr = allocCStringArray(args)
-  var res = PQexecParams(db, query.string, int32(args.len), nil, arr,
+  var res = pqexecParams(db, query.string, int32(args.len), nil, arr,
                         nil, nil, 0)
   deallocCStringArray(arr)
-  result = PQresultStatus(res) == PGRES_COMMAND_OK
-  PQclear(res)
+  result = pqresultStatus(res) == PGRES_COMMAND_OK
+  pqclear(res)
 
 proc exec*(db: TDbConn, query: TSqlQuery, args: varargs[string, `$`]) {.
   tags: [FReadDB, FWriteDb].} =
   ## executes the query and raises EDB if not successful.
   var arr = allocCStringArray(args)
-  var res = PQexecParams(db, query.string, int32(args.len), nil, arr,
+  var res = pqexecParams(db, query.string, int32(args.len), nil, arr,
                         nil, nil, 0)
   deallocCStringArray(arr)
-  if PQresultStatus(res) != PGRES_COMMAND_OK: dbError(db)
-  PQclear(res)
+  if pqresultStatus(res) != PGRES_COMMAND_OK: dbError(db)
+  pqclear(res)
 
 proc exec*(db: TDbConn, stmtName: TSqlPrepared,
           args: varargs[string]) {.tags: [FReadDB, FWriteDb].} =
   var arr = allocCStringArray(args)
-  var res = PQexecPrepared(db, stmtName.string, int32(args.len), arr,
+  var res = pqexecPrepared(db, stmtName.string, int32(args.len), arr,
                            nil, nil, 0)
   deallocCStringArray(arr)
-  if PQResultStatus(res) != PGRES_COMMAND_OK: dbError(db)
-  PQclear(res)
+  if pqResultStatus(res) != PGRES_COMMAND_OK: dbError(db)
+  pqclear(res)
 
 proc newRow(L: int): TRow =
   newSeq(result, L)
@@ -105,30 +105,30 @@ proc newRow(L: int): TRow =
 proc setupQuery(db: TDbConn, query: TSqlQuery,
                 args: varargs[string]): PPGresult =
   var arr = allocCStringArray(args)
-  result = PQexecParams(db, query.string, int32(args.len), nil, arr,
+  result = pqexecParams(db, query.string, int32(args.len), nil, arr,
                         nil, nil, 0)
   deallocCStringArray(arr)
-  if PQResultStatus(result) != PGRES_TUPLES_OK: dbError(db)
+  if pqResultStatus(result) != PGRES_TUPLES_OK: dbError(db)
 
 proc setupQuery(db: TDbConn, stmtName: TSqlPrepared,
                  args: varargs[string]): PPGresult =
   var arr = allocCStringArray(args)
-  result = PQexecPrepared(db, stmtName.string, int32(args.len), arr,
+  result = pqexecPrepared(db, stmtName.string, int32(args.len), arr,
                           nil, nil, 0)
   deallocCStringArray(arr)
-  if PQResultStatus(result) != PGRES_TUPLES_OK: dbError(db)
+  if pqResultStatus(result) != PGRES_TUPLES_OK: dbError(db)
 
 proc prepare*(db: TDbConn; stmtName: string, query: TSqlQuery;
               nParams: int): TSqlPrepared =
-  var res = PQprepare(db, stmtName, query.string, int32(nParams), nil)
-  if PQResultStatus(res) != PGRES_COMMAND_OK: dbError(db)
+  var res = pqprepare(db, stmtName, query.string, int32(nParams), nil)
+  if pqResultStatus(res) != PGRES_COMMAND_OK: dbError(db)
   return TSqlPrepared(stmtName)
    
 proc setRow(res: PPGresult, r: var TRow, line, cols: int32) =
   for col in 0..cols-1:
     setLen(r[col], 0)
-    var x = PQgetvalue(res, line, col)
-    if x == nil:
+    let x = pqgetvalue(res, line, col)
+    if x.isNil:
       r[col] = nil
     else:
       add(r[col], x)
@@ -139,67 +139,67 @@ iterator fastRows*(db: TDbConn, query: TSqlQuery,
   ## fast, but potenially dangerous: If the for-loop-body executes another
   ## query, the results can be undefined. For Postgres it is safe though.
   var res = setupQuery(db, query, args)
-  var L = PQnfields(res)
+  var L = pqnfields(res)
   var result = newRow(L)
-  for i in 0..PQntuples(res)-1:
+  for i in 0..pqntuples(res)-1:
     setRow(res, result, i, L)
     yield result
-  PQclear(res)
+  pqclear(res)
 
 iterator fastRows*(db: TDbConn, stmtName: TSqlPrepared,
                    args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
   ## executes the prepared query and iterates over the result dataset.
   var res = setupQuery(db, stmtName, args)
-  var L = PQnfields(res)
+  var L = pqNfields(res)
   var result = newRow(L)
-  for i in 0..PQntuples(res)-1:
+  for i in 0..pqNtuples(res)-1:
     setRow(res, result, i, L)
     yield result
-  PQclear(res)
+  pqClear(res)
 
 proc getRow*(db: TDbConn, query: TSqlQuery,
              args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
   ## retrieves a single row. If the query doesn't return any rows, this proc
   ## will return a TRow with empty strings for each column.
   var res = setupQuery(db, query, args)
-  var L = PQnfields(res)
+  var L = pqnfields(res)
   result = newRow(L)
   setRow(res, result, 0, L)
-  PQclear(res)
+  pqclear(res)
 
 proc getRow*(db: TDbConn, stmtName: TSqlPrepared,
-              args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
-    var res = setupQuery(db, stmtName, args)
-    var L = PQnfields(res)
-    result = newRow(L)
-    setRow(res, result, 0, L)
-    PQclear(res)
+             args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
+  var res = setupQuery(db, stmtName, args)
+  var L = pqNfields(res)
+  result = newRow(L)
+  setRow(res, result, 0, L)
+  pqClear(res)
 
 proc getAllRows*(db: TDbConn, query: TSqlQuery,
                  args: varargs[string, `$`]): seq[TRow] {.tags: [FReadDB].} =
   ## executes the query and returns the whole result dataset.
   result = @[]
-  for r in FastRows(db, query, args):
+  for r in fastRows(db, query, args):
     result.add(r)
 
 proc getAllRows*(db: TDbConn, stmtName: TSqlPrepared,
                  args: varargs[string, `$`]): seq[TRow] {.tags: [FReadDB].} =
   ## executes the prepared query and returns the whole result dataset.
   result = @[]
-  for r in FastRows(db, stmtName, args):
+  for r in fastRows(db, stmtName, args):
     result.add(r)
 
 iterator rows*(db: TDbConn, query: TSqlQuery,
                args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
-  ## same as `FastRows`, but slower and safe.
-  for r in items(GetAllRows(db, query, args)): yield r
+  ## same as `fastRows`, but slower and safe.
+  for r in items(getAllRows(db, query, args)): yield r
 
 proc getValue*(db: TDbConn, query: TSqlQuery,
                args: varargs[string, `$`]): string {.tags: [FReadDB].} =
   ## executes the query and returns the first column of the first row of the
   ## result dataset. Returns "" if the dataset contains no rows or the database
   ## value is NULL.
-  var x = PQgetvalue(setupQuery(db, query, args), 0, 0)
+  var x = pqgetvalue(setupQuery(db, query, args), 0, 0)
   result = if isNil(x): "" else: $x
   
 proc tryInsertID*(db: TDbConn, query: TSqlQuery,
@@ -208,10 +208,10 @@ proc tryInsertID*(db: TDbConn, query: TSqlQuery,
   ## generated ID for the row or -1 in case of an error. For Postgre this adds
   ## ``RETURNING id`` to the query, so it only works if your primary key is
   ## named ``id``. 
-  var x = PQgetvalue(setupQuery(db, TSqlQuery(string(query) & " RETURNING id"),
+  var x = pqgetvalue(setupQuery(db, TSqlQuery(string(query) & " RETURNING id"), 
     args), 0, 0)
   if not isNil(x):
-    result = ParseBiggestInt($x)
+    result = parseBiggestInt($x)
   else:
     result = -1
 
@@ -221,7 +221,7 @@ proc insertID*(db: TDbConn, query: TSqlQuery,
   ## generated ID for the row. For Postgre this adds
   ## ``RETURNING id`` to the query, so it only works if your primary key is
   ## named ``id``. 
-  result = TryInsertID(db, query, args)
+  result = tryInsertID(db, query, args)
   if result < 0: dbError(db)
   
 proc execAffectedRows*(db: TDbConn, query: TSqlQuery,
@@ -230,14 +230,14 @@ proc execAffectedRows*(db: TDbConn, query: TSqlQuery,
   ## executes the query (typically "UPDATE") and returns the
   ## number of affected rows.
   var q = dbFormat(query, args)
-  var res = PQExec(db, q)
-  if PQresultStatus(res) != PGRES_COMMAND_OK: dbError(db)
-  result = parseBiggestInt($PQcmdTuples(res))
-  PQclear(res)
+  var res = pqExec(db, q)
+  if pqresultStatus(res) != PGRES_COMMAND_OK: dbError(db)
+  result = parseBiggestInt($pqcmdTuples(res))
+  pqclear(res)
 
 proc close*(db: TDbConn) {.tags: [FDb].} =
   ## closes the database connection.
-  if db != nil: PQfinish(db)
+  if db != nil: pqfinish(db)
 
 proc open*(connection, user, password, database: string): TDbConn {.
   tags: [FDb].} =
@@ -249,16 +249,14 @@ proc open*(connection, user, password, database: string): TDbConn {.
   ##
   ## Example:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##
-  ##      con = Open("", "", "", "host=localhost port=5432 dbname=mydb")
+  ##      con = open("", "", "", "host=localhost port=5432 dbname=mydb")
   ##
   ## See http://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-CONNSTRING
   ## for more information.
   ##
   ## Note that the connection parameter is not used but exists to maintain
-  ## the nimrod db api.
-  result = PQsetdbLogin(nil, nil, nil, nil, database, user, password)
-  if PQStatus(result) != CONNECTION_OK: dbError(result) # result = nil
-
-
+  ## the nim db api.
+  result = pqsetdbLogin(nil, nil, nil, nil, database, user, password)
+  if pqStatus(result) != CONNECTION_OK: dbError(result) # result = nil
diff --git a/lib/impure/db_sqlite.nim b/lib/impure/db_sqlite.nim
index 809ee7039..bc9e0b591 100644
--- a/lib/impure/db_sqlite.nim
+++ b/lib/impure/db_sqlite.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -16,13 +16,13 @@ type
   TDbConn* = PSqlite3  ## encapsulates a database connection
   TRow* = seq[string]  ## a row of a dataset. NULL database values will be
                        ## transformed always to the empty string.
-  EDb* = object of EIO ## exception that is raised if a database error occurs
+  EDb* = object of IOError ## exception that is raised if a database error occurs
   
   TSqlQuery* = distinct string ## an SQL query string
   
-  FDb* = object of FIO ## effect that denotes a database operation
-  FReadDb* = object of FDB   ## effect that denotes a read operation
-  FWriteDb* = object of FDB  ## effect that denotes a write operation
+  FDb* = object of IOEffect ## effect that denotes a database operation
+  FReadDb* = object of FDb   ## effect that denotes a read operation
+  FWriteDb* = object of FDb  ## effect that denotes a write operation
   
 proc sql*(query: string): TSqlQuery {.noSideEffect, inline.} =  
   ## constructs a TSqlQuery from the string `query`. This is supposed to be 
@@ -65,16 +65,16 @@ proc dbFormat(formatstr: TSqlQuery, args: varargs[string]): string =
       add(result, c)
   
 proc tryExec*(db: TDbConn, query: TSqlQuery, 
-              args: varargs[string, `$`]): bool {.tags: [FReadDB, FWriteDb].} =
+              args: varargs[string, `$`]): bool {.tags: [FReadDb, FWriteDb].} =
   ## tries to execute the query and returns true if successful, false otherwise.
   var q = dbFormat(query, args)
-  var stmt: sqlite3.PStmt
+  var stmt: sqlite3.Pstmt
   if prepare_v2(db, q, q.len.cint, stmt, nil) == SQLITE_OK:
     if step(stmt) == SQLITE_DONE:
       result = finalize(stmt) == SQLITE_OK
 
 proc exec*(db: TDbConn, query: TSqlQuery, args: varargs[string, `$`])  {.
-  tags: [FReadDB, FWriteDb].} =
+  tags: [FReadDb, FWriteDb].} =
   ## executes the query and raises EDB if not successful.
   if not tryExec(db, query, args): dbError(db)
   
@@ -83,11 +83,11 @@ proc newRow(L: int): TRow =
   for i in 0..L-1: result[i] = ""
   
 proc setupQuery(db: TDbConn, query: TSqlQuery, 
-                args: varargs[string]): PStmt = 
+                args: varargs[string]): Pstmt = 
   var q = dbFormat(query, args)
   if prepare_v2(db, q, q.len.cint, result, nil) != SQLITE_OK: dbError(db)
   
-proc setRow(stmt: PStmt, r: var TRow, cols: cint) =
+proc setRow(stmt: Pstmt, r: var TRow, cols: cint) =
   for col in 0..cols-1:
     setLen(r[col], column_bytes(stmt, col)) # set capacity
     setLen(r[col], 0)
@@ -95,12 +95,12 @@ proc setRow(stmt: PStmt, r: var TRow, cols: cint) =
     if not isNil(x): add(r[col], x)
   
 iterator fastRows*(db: TDbConn, query: TSqlQuery,
-                   args: varargs[string, `$`]): TRow  {.tags: [FReadDB].} =
+                   args: varargs[string, `$`]): TRow  {.tags: [FReadDb].} =
   ## executes the query and iterates over the result dataset. This is very 
   ## fast, but potenially dangerous: If the for-loop-body executes another
   ## query, the results can be undefined. For Sqlite it is safe though.
   var stmt = setupQuery(db, query, args)
-  var L = (columnCount(stmt))
+  var L = (column_count(stmt))
   var result = newRow(L)
   while step(stmt) == SQLITE_ROW: 
     setRow(stmt, result, L)
@@ -108,30 +108,30 @@ iterator fastRows*(db: TDbConn, query: TSqlQuery,
   if finalize(stmt) != SQLITE_OK: dbError(db)
 
 proc getRow*(db: TDbConn, query: TSqlQuery,
-             args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
+             args: varargs[string, `$`]): TRow {.tags: [FReadDb].} =
   ## retrieves a single row. If the query doesn't return any rows, this proc
   ## will return a TRow with empty strings for each column.
   var stmt = setupQuery(db, query, args)
-  var L = (columnCount(stmt))
+  var L = (column_count(stmt))
   result = newRow(L)
   if step(stmt) == SQLITE_ROW: 
     setRow(stmt, result, L)
   if finalize(stmt) != SQLITE_OK: dbError(db)
 
 proc getAllRows*(db: TDbConn, query: TSqlQuery, 
-                 args: varargs[string, `$`]): seq[TRow] {.tags: [FReadDB].} =
+                 args: varargs[string, `$`]): seq[TRow] {.tags: [FReadDb].} =
   ## executes the query and returns the whole result dataset.
   result = @[]
   for r in fastRows(db, query, args):
     result.add(r)
 
 iterator rows*(db: TDbConn, query: TSqlQuery, 
-               args: varargs[string, `$`]): TRow {.tags: [FReadDB].} =
+               args: varargs[string, `$`]): TRow {.tags: [FReadDb].} =
   ## same as `FastRows`, but slower and safe.
   for r in fastRows(db, query, args): yield r
 
 proc getValue*(db: TDbConn, query: TSqlQuery, 
-               args: varargs[string, `$`]): string {.tags: [FReadDB].} = 
+               args: varargs[string, `$`]): string {.tags: [FReadDb].} = 
   ## executes the query and returns the first column of the first row of the
   ## result dataset. Returns "" if the dataset contains no rows or the database
   ## value is NULL.
@@ -153,7 +153,7 @@ proc tryInsertID*(db: TDbConn, query: TSqlQuery,
   ## executes the query (typically "INSERT") and returns the 
   ## generated ID for the row or -1 in case of an error. 
   var q = dbFormat(query, args)
-  var stmt: sqlite3.PStmt
+  var stmt: sqlite3.Pstmt
   result = -1
   if prepare_v2(db, q, q.len.cint, stmt, nil) == SQLITE_OK:
     if step(stmt) == SQLITE_DONE:
@@ -172,18 +172,18 @@ proc insertID*(db: TDbConn, query: TSqlQuery,
   
 proc execAffectedRows*(db: TDbConn, query: TSqlQuery, 
                        args: varargs[string, `$`]): int64 {.
-                       tags: [FReadDB, FWriteDb].} = 
+                       tags: [FReadDb, FWriteDb].} = 
   ## executes the query (typically "UPDATE") and returns the
   ## number of affected rows.
   exec(db, query, args)
   result = changes(db)
 
-proc close*(db: TDbConn) {.tags: [FDB].} = 
+proc close*(db: TDbConn) {.tags: [FDb].} = 
   ## closes the database connection.
   if sqlite3.close(db) != SQLITE_OK: dbError(db)
     
 proc open*(connection, user, password, database: string): TDbConn {.
-  tags: [FDB].} =
+  tags: [FDb].} =
   ## opens a database connection. Raises `EDb` if the connection could not
   ## be established. Only the ``connection`` parameter is used for ``sqlite``.
   var db: TDbConn
diff --git a/lib/impure/dialogs.nim b/lib/impure/dialogs.nim
index 00ba2663e..4ea66a6e6 100644
--- a/lib/impure/dialogs.nim
+++ b/lib/impure/dialogs.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -8,7 +8,7 @@
 #
 
 
-## This module implements portable dialogs for Nimrod; the implementation
+## This module implements portable dialogs for Nim; the implementation
 ## builds on the GTK interface. On Windows, native dialogs are shown instead.
 
 import
@@ -200,14 +200,14 @@ proc chooseDir*(window: PWindow, root: string = ""): string =
       BrowseInfo: TBrowseInfo
       DisplayName: array [0..MAX_PATH, char]
       TempPath: array [0..MAX_PATH, char]
-    Result = ""
+    result = ""
     #BrowseInfo.hwndOwner = Application.Handle
     BrowseInfo.pszDisplayName = DisplayName
     BrowseInfo.ulFlags = 1 #BIF_RETURNONLYFSDIRS
     lpItemID = SHBrowseForFolder(cast[LPBrowseInfo](addr(BrowseInfo)))
     if lpItemId != nil:
       discard SHGetPathFromIDList(lpItemID, TempPath)
-      Result = $TempPath
+      result = $TempPath
       discard GlobalFreePtr(lpItemID)
   else:
     var chooser = file_chooser_dialog_new("Select Directory", window,
diff --git a/lib/impure/fenv.nim b/lib/impure/fenv.nim
index 9d7c8809b..1859f7be7 100644
--- a/lib/impure/fenv.nim
+++ b/lib/impure/fenv.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2014 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -42,16 +42,6 @@ var
     ## case the default environment will be used
 
 type
-  TFloatClass* = enum ## describes the class a floating point value belongs to.
-                      ## This is the type that is returned by `classify`.
-    fcNormal,    ## value is an ordinary nonzero floating point value
-    fcSubnormal, ## value is a subnormal (a very small) floating point value
-    fcZero,      ## value is zero
-    fcNegZero,   ## value is the negative zero
-    fcNan,       ## value is Not-A-Number (NAN)
-    fcInf,       ## value is positive infinity
-    fcNegInf     ## value is negative infinity
-
   Tfenv* {.importc: "fenv_t", header: "<fenv.h>", final, pure.} =
     object ## Represents the entire floating-point environment. The
            ## floating-point environment refers collectively to any
diff --git a/lib/impure/graphics.nim b/lib/impure/graphics.nim
index 2c8e96460..dfadb46ee 100644
--- a/lib/impure/graphics.nim
+++ b/lib/impure/graphics.nim
@@ -1,20 +1,20 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf, Dominik Picheta
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
 #
 
-## This module implements graphical output for Nimrod; the current
+## This module implements graphical output for Nim; the current
 ## implementation uses SDL but the interface is meant to support multiple
 ## backends some day. There is no need to init SDL as this module does that 
 ## implicitly.
 
 import colors, math
 from sdl import PSurface # Bug
-from sdl_ttf import OpenFont, closeFont
+from sdl_ttf import openFont, closeFont
 
 type
   TRect* = tuple[x, y, width, height: int]
@@ -25,24 +25,24 @@ type
     w*, h*: Natural
     s*: sdl.PSurface
   
-  EGraphics* = object of EIO
+  EGraphics* = object of IOError
 
   TFont {.pure, final.} = object
     f: sdl_ttf.PFont
-    color: SDL.TColor
+    color: sdl.TColor
   PFont* = ref TFont ## represents a font
 
-proc toSdlColor*(c: TColor): Sdl.TColor =
-  ## Convert colors.TColor to SDL.TColor
+proc toSdlColor*(c: Color): sdl.TColor =
+  ## Convert colors.TColor to sdl.TColor
   var x = c.extractRGB  
   result.r = x.r and 0xff
   result.g = x.g and 0xff
   result.b = x.b and 0xff
 
-proc createSdlColor*(sur: PSurface, c: TColor, alpha: int = 0): int32 =
+proc createSdlColor*(sur: PSurface, c: Color, alpha: int = 0): int32 =
   ## Creates a color using ``sdl.MapRGBA``.
   var x = c.extractRGB
-  return sdl.MapRGBA(sur.s.format, x.r and 0xff, x.g and 0xff, 
+  return sdl.mapRGBA(sur.s.format, x.r and 0xff, x.g and 0xff, 
                      x.b and 0xff, alpha and 0xff)
 
 proc toSdlRect*(r: TRect): sdl.TRect =
@@ -53,7 +53,7 @@ proc toSdlRect*(r: TRect): sdl.TRect =
   result.h = uint16(r.height)
 
 proc raiseEGraphics = 
-  raise newException(EGraphics, $SDL.GetError())
+  raise newException(EGraphics, $sdl.getError())
   
 proc surfaceFinalizer(s: PSurface) = sdl.freeSurface(s.s)
   
@@ -62,21 +62,21 @@ proc newSurface*(width, height: int): PSurface =
   new(result, surfaceFinalizer)
   result.w = width
   result.h = height
-  result.s = SDL.CreateRGBSurface(SDL.SWSURFACE, width, height, 
+  result.s = sdl.createRGBSurface(sdl.SWSURFACE, width, height, 
       32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0)
   if result.s == nil:
     raiseEGraphics()
   
-  assert(not sdl.MustLock(result.s))
+  assert(not sdl.mustLock(result.s))
 
 proc fontFinalizer(f: PFont) = closeFont(f.f)
 
 proc newFont*(name = "VeraMono.ttf", size = 9, color = colBlack): PFont =  
   ## Creates a new font object. Raises ``EIO`` if the font cannot be loaded.
   new(result, fontFinalizer)
-  result.f = OpenFont(name, size.cint)
+  result.f = openFont(name, size.cint)
   if result.f == nil:
-    raise newException(EIO, "Could not open font file: " & name)
+    raise newException(IOError, "Could not open font file: " & name)
   result.color = toSdlColor(color)
 
 var
@@ -92,7 +92,7 @@ proc newScreenSurface*(width, height: int): PSurface =
   new(result, surfaceFinalizer)
   result.w = width
   result.h = height
-  result.s = SDL.SetVideoMode(width, height, 0, 0)
+  result.s = sdl.setVideoMode(width, height, 0, 0)
   if result.s == nil:
     raiseEGraphics()
 
@@ -100,7 +100,7 @@ proc writeToBMP*(sur: PSurface, filename: string) =
   ## Saves the contents of the surface `sur` to the file `filename` as a 
   ## BMP file.
   if sdl.saveBMP(sur.s, filename) != 0:
-    raise newException(EIO, "cannot write: " & filename)
+    raise newException(IOError, "cannot write: " & filename)
 
 type
   TPixels = array[0..1000_000-1, int32]
@@ -110,44 +110,44 @@ template setPix(video, pitch, x, y, col: expr): stmt =
   video[y * pitch + x] = int32(col)
 
 template getPix(video, pitch, x, y: expr): expr = 
-  colors.TColor(video[y * pitch + x])
+  colors.Color(video[y * pitch + x])
 
 const
   ColSize = 4
 
-proc getPixel(sur: PSurface, x, y: Natural): colors.TColor {.inline.} =
+proc getPixel(sur: PSurface, x, y: Natural): colors.Color {.inline.} =
   assert x <% sur.w
   assert y <% sur.h
   result = getPix(cast[PPixels](sur.s.pixels), sur.s.pitch.int div ColSize, 
                   x, y)
 
-proc setPixel(sur: PSurface, x, y: Natural, col: colors.TColor) {.inline.} =
+proc setPixel(sur: PSurface, x, y: Natural, col: colors.Color) {.inline.} =
   assert x <% sur.w
   assert y <% sur.h
   var pixs = cast[PPixels](sur.s.pixels)
   #pixs[y * (sur.s.pitch div colSize) + x] = int(col)
   setPix(pixs, sur.s.pitch.int div ColSize, x, y, col)
 
-proc `[]`*(sur: PSurface, p: TPoint): TColor =
+proc `[]`*(sur: PSurface, p: TPoint): Color =
   ## get pixel at position `p`. No range checking is done!
   result = getPixel(sur, p.x, p.y)
 
-proc `[]`*(sur: PSurface, x, y: int): TColor =
+proc `[]`*(sur: PSurface, x, y: int): Color =
   ## get pixel at position ``(x, y)``. No range checking is done!
   result = getPixel(sur, x, y)
 
-proc `[]=`*(sur: PSurface, p: TPoint, col: TColor) =
+proc `[]=`*(sur: PSurface, p: TPoint, col: Color) =
   ## set the pixel at position `p`. No range checking is done!
   setPixel(sur, p.x, p.y, col)
 
-proc `[]=`*(sur: PSurface, x, y: int, col: TColor) =
+proc `[]=`*(sur: PSurface, x, y: int, col: Color) =
   ## set the pixel at position ``(x, y)``. No range checking is done!
   setPixel(sur, x, y, col)
 
 proc blit*(destSurf: PSurface, destRect: TRect, srcSurf: PSurface, 
            srcRect: TRect) =
   ## Copies ``srcSurf`` into ``destSurf``
-  var destTRect, srcTRect: SDL.TRect
+  var destTRect, srcTRect: sdl.TRect
 
   destTRect.x = int16(destRect.x)
   destTRect.y = int16(destRect.y)
@@ -159,12 +159,12 @@ proc blit*(destSurf: PSurface, destRect: TRect, srcSurf: PSurface,
   srcTRect.w = uint16(srcRect.width)
   srcTRect.h = uint16(srcRect.height)
 
-  if SDL.blitSurface(srcSurf.s, addr(srcTRect), destSurf.s, addr(destTRect)) != 0:
+  if sdl.blitSurface(srcSurf.s, addr(srcTRect), destSurf.s, addr(destTRect)) != 0:
     raiseEGraphics()
 
 proc textBounds*(text: string, font = defaultFont): tuple[width, height: int] =
   var w, h: cint
-  if sdl_ttf.SizeUTF8(font.f, text, w, h) < 0: raiseEGraphics()
+  if sdl_ttf.sizeUTF8(font.f, text, w, h) < 0: raiseEGraphics()
   result.width = int(w)
   result.height = int(h)
 
@@ -175,21 +175,21 @@ proc drawText*(sur: PSurface, p: TPoint, text: string, font = defaultFont) =
   new(textSur, surfaceFinalizer)
   
   # Render the text
-  textSur.s = sdl_ttf.RenderTextBlended(font.f, text, font.color)
+  textSur.s = sdl_ttf.renderTextBlended(font.f, text, font.color)
   # Merge the text surface with sur
   sur.blit((p.x, p.y, sur.w, sur.h), textSur, (0, 0, sur.w, sur.h))
 
 proc drawText*(sur: PSurface, p: TPoint, text: string,
-               bg: TColor, font = defaultFont) =
+               bg: Color, font = defaultFont) =
   ## Draws text, at location ``p`` with font ``font``. ``bg`` 
   ## is the background color.
   var textSur: PSurface # This surface will have the text drawn on it
   new(textSur, surfaceFinalizer)
-  textSur.s = sdl_ttf.RenderTextShaded(font.f, text, font.color, toSdlColor(bg))
+  textSur.s = sdl_ttf.renderTextShaded(font.f, text, font.color, toSdlColor(bg))
   # Merge the text surface with sur
   sur.blit((p.x, p.y, sur.w, sur.h), textSur, (0, 0, sur.w, sur.h))
   
-proc drawCircle*(sur: PSurface, p: TPoint, r: Natural, color: TColor) =
+proc drawCircle*(sur: PSurface, p: TPoint, r: Natural, color: Color) =
   ## draws a circle with center `p` and radius `r` with the given color
   ## onto the surface `sur`.
   var video = cast[PPixels](sur.s.pixels)
@@ -229,7 +229,7 @@ proc `>-<`(val: int, s: PSurface): int {.inline.} =
 proc `>|<`(val: int, s: PSurface): int {.inline.} = 
   return if val < 0: 0 elif val >= s.h: s.h-1 else: val
 
-proc drawLine*(sur: PSurface, p1, p2: TPoint, color: TColor) =
+proc drawLine*(sur: PSurface, p1, p2: TPoint, color: Color) =
   ## draws a line between the two points `p1` and `p2` with the given color
   ## onto the surface `sur`.
   var stepx, stepy: int = 0
@@ -273,7 +273,7 @@ proc drawLine*(sur: PSurface, p1, p2: TPoint, color: TColor) =
       fraction = fraction + dx
       setPix(video, pitch, x0, y0, color)
 
-proc drawHorLine*(sur: PSurface, x, y, w: Natural, Color: TColor) =
+proc drawHorLine*(sur: PSurface, x, y, w: Natural, color: Color) =
   ## draws a horizontal line from (x,y) to (x+w-1, y).
   var video = cast[PPixels](sur.s.pixels)
   var pitch = sur.s.pitch.int div ColSize
@@ -282,7 +282,7 @@ proc drawHorLine*(sur: PSurface, x, y, w: Natural, Color: TColor) =
     for i in 0 .. min(sur.s.w-x, w)-1:
       setPix(video, pitch, x + i, y, color)
 
-proc drawVerLine*(sur: PSurface, x, y, h: Natural, Color: TColor) =
+proc drawVerLine*(sur: PSurface, x, y, h: Natural, color: Color) =
   ## draws a vertical line from (x,y) to (x, y+h-1).
   var video = cast[PPixels](sur.s.pixels)
   var pitch = sur.s.pitch.int div ColSize
@@ -291,7 +291,7 @@ proc drawVerLine*(sur: PSurface, x, y, h: Natural, Color: TColor) =
     for i in 0 .. min(sur.s.h-y, h)-1:
       setPix(video, pitch, x, y + i, color)
 
-proc fillCircle*(s: PSurface, p: TPoint, r: Natural, color: TColor) =
+proc fillCircle*(s: PSurface, p: TPoint, r: Natural, color: Color) =
   ## draws a circle with center `p` and radius `r` with the given color
   ## onto the surface `sur` and fills it.
   var a = 1 - r
@@ -301,11 +301,11 @@ proc fillCircle*(s: PSurface, p: TPoint, r: Natural, color: TColor) =
   var y = p.y
   while px <= py:
     # Fill up the middle half of the circle
-    DrawVerLine(s, x + px, y, py + 1, color)
-    DrawVerLine(s, x + px, y - py, py, color)
+    drawVerLine(s, x + px, y, py + 1, color)
+    drawVerLine(s, x + px, y - py, py, color)
     if px != 0:
-      DrawVerLine(s, x - px, y, py + 1, color)
-      DrawVerLine(s, x - px, y - py, py, color)
+      drawVerLine(s, x - px, y, py + 1, color)
+      drawVerLine(s, x - px, y - py, py, color)
     if a < 0:
       a = a + (2 * px + 3)
     else:
@@ -313,13 +313,13 @@ proc fillCircle*(s: PSurface, p: TPoint, r: Natural, color: TColor) =
       py = py - 1
       # Fill up the left/right half of the circle
       if py >= px:
-        DrawVerLine(s, x + py + 1, y, px + 1, color)
-        DrawVerLine(s, x + py + 1, y - px, px, color)
-        DrawVerLine(s, x - py - 1, y, px + 1, color)
-        DrawVerLine(s, x - py - 1, y - px,  px, color)
+        drawVerLine(s, x + py + 1, y, px + 1, color)
+        drawVerLine(s, x + py + 1, y - px, px, color)
+        drawVerLine(s, x - py - 1, y, px + 1, color)
+        drawVerLine(s, x - py - 1, y - px,  px, color)
     px = px + 1
 
-proc drawRect*(sur: PSurface, r: TRect, color: TColor) =
+proc drawRect*(sur: PSurface, r: TRect, color: Color) =
   ## draws a rectangle.
   var video = cast[PPixels](sur.s.pixels)
   var pitch = sur.s.pitch.int div ColSize
@@ -337,78 +337,78 @@ proc drawRect*(sur: PSurface, r: TRect, color: TColor) =
       setPix(video, pitch, r.x, r.y + i, color)
       setPix(video, pitch, r.x + minW - 1, r.y + i, color) # Draw right side
     
-proc fillRect*(sur: PSurface, r: TRect, col: TColor) =
+proc fillRect*(sur: PSurface, r: TRect, col: Color) =
   ## Fills a rectangle using sdl's ``FillRect`` function.
   var rect = toSdlRect(r)
-  if sdl.FillRect(sur.s, addr(rect), sur.createSdlColor(col)) == -1:
+  if sdl.fillRect(sur.s, addr(rect), sur.createSdlColor(col)) == -1:
     raiseEGraphics()
 
-proc plot4EllipsePoints(sur: PSurface, CX, CY, X, Y: Natural, col: TColor) =
+proc plot4EllipsePoints(sur: PSurface, cx, cy, x, y: Natural, col: Color) =
   var video = cast[PPixels](sur.s.pixels)
   var pitch = sur.s.pitch.int div ColSize
-  if CX+X <= sur.s.w-1:
-    if CY+Y <= sur.s.h-1: setPix(video, pitch, CX+X, CY+Y, col)
-    if CY-Y <= sur.s.h-1: setPix(video, pitch, CX+X, CY-Y, col)    
-  if CX-X <= sur.s.w-1:
-    if CY+Y <= sur.s.h-1: setPix(video, pitch, CX-X, CY+Y, col)
-    if CY-Y <= sur.s.h-1: setPix(video, pitch, CX-X, CY-Y, col)
-
-proc drawEllipse*(sur: PSurface, CX, CY, XRadius, YRadius: Natural, 
-                  col: TColor) =
+  if cx+x <= sur.s.w-1:
+    if cy+y <= sur.s.h-1: setPix(video, pitch, cx+x, cy+y, col)
+    if cy-y <= sur.s.h-1: setPix(video, pitch, cx+x, cy-y, col)    
+  if cx-x <= sur.s.w-1:
+    if cy+y <= sur.s.h-1: setPix(video, pitch, cx-x, cy+y, col)
+    if cy-y <= sur.s.h-1: setPix(video, pitch, cx-x, cy-y, col)
+
+proc drawEllipse*(sur: PSurface, cx, cy, xRadius, yRadius: Natural, 
+                  col: Color) =
   ## Draws an ellipse, ``CX`` and ``CY`` specify the center X and Y of the 
   ## ellipse, ``XRadius`` and ``YRadius`` specify half the width and height
   ## of the ellipse.
   var 
-    X, Y: Natural
-    XChange, YChange: Int
-    EllipseError: Natural
-    TwoASquare, TwoBSquare: Natural
-    StoppingX, StoppingY: Natural
+    x, y: Natural
+    xChange, yChange: int
+    ellipseError: Natural
+    twoASquare, twoBSquare: Natural
+    stoppingX, stoppingY: Natural
     
-  TwoASquare = 2 * XRadius * XRadius
-  TwoBSquare = 2 * YRadius * YRadius
-  X = XRadius
-  Y = 0
-  XChange = YRadius * YRadius * (1 - 2 * XRadius)
-  YChange = XRadius * XRadius
-  EllipseError = 0
-  StoppingX = TwoBSquare * XRadius
-  StoppingY = 0
+  twoASquare = 2 * xRadius * xRadius
+  twoBSquare = 2 * yRadius * yRadius
+  x = xRadius
+  y = 0
+  xChange = yRadius * yRadius * (1 - 2 * xRadius)
+  yChange = xRadius * xRadius
+  ellipseError = 0
+  stoppingX = twoBSquare * xRadius
+  stoppingY = 0
   
-  while StoppingX >=  StoppingY: # 1st set of points, y` > - 1
-    sur.Plot4EllipsePoints(CX, CY, X, Y, col)
-    inc(Y)
-    inc(StoppingY, TwoASquare)
-    inc(EllipseError, YChange)
-    inc(YChange, TwoASquare)
-    if (2 * EllipseError + XChange) > 0 :
+  while stoppingX >=  stoppingY: # 1st set of points, y` > - 1
+    sur.plot4EllipsePoints(cx, cy, x, y, col)
+    inc(y)
+    inc(stoppingY, twoASquare)
+    inc(ellipseError, yChange)
+    inc(yChange, twoASquare)
+    if (2 * ellipseError + xChange) > 0 :
       dec(x)
-      dec(StoppingX, TwoBSquare)
-      inc(EllipseError, XChange)
-      inc(XChange, TwoBSquare)
+      dec(stoppingX, twoBSquare)
+      inc(ellipseError, xChange)
+      inc(xChange, twoBSquare)
       
   # 1st point set is done; start the 2nd set of points
-  X = 0
-  Y = YRadius
-  XChange = YRadius * YRadius
-  YChange = XRadius * XRadius * (1 - 2 * YRadius)
-  EllipseError = 0
-  StoppingX = 0
-  StoppingY = TwoASquare * YRadius
-  while StoppingX <= StoppingY:
-    sur.Plot4EllipsePoints(CX, CY, X, Y, col)
-    inc(X)
-    inc(StoppingX, TwoBSquare)
-    inc(EllipseError, XChange)
-    inc(XChange,TwoBSquare)
-    if (2 * EllipseError + YChange) > 0:
-      dec(Y)
-      dec(StoppingY, TwoASquare)
-      inc(EllipseError, YChange)
-      inc(YChange,TwoASquare)
+  x = 0
+  y = yRadius
+  xChange = yRadius * yRadius
+  yChange = xRadius * xRadius * (1 - 2 * yRadius)
+  ellipseError = 0
+  stoppingX = 0
+  stoppingY = twoASquare * yRadius
+  while stoppingX <= stoppingY:
+    sur.plot4EllipsePoints(cx, cy, x, y, col)
+    inc(x)
+    inc(stoppingX, twoBSquare)
+    inc(ellipseError, xChange)
+    inc(xChange,twoBSquare)
+    if (2 * ellipseError + yChange) > 0:
+      dec(y)
+      dec(stoppingY, twoASquare)
+      inc(ellipseError, yChange)
+      inc(yChange,twoASquare)
   
 
-proc plotAA(sur: PSurface, x, y: int, c: float, color: TColor) =
+proc plotAA(sur: PSurface, x, y: int, c: float, color: Color) =
   if (x > 0 and x < sur.s.w) and (y > 0 and y < sur.s.h):
     var video = cast[PPixels](sur.s.pixels)
     var pitch = sur.s.pitch.int div ColSize
@@ -424,7 +424,7 @@ template cround(x: expr): expr = ipart(x + 0.5)
 template fpart(x: expr): expr = x - ipart(x)
 template rfpart(x: expr): expr = 1.0 - fpart(x)
 
-proc drawLineAA*(sur: PSurface, p1, p2: TPoint, color: TColor) =
+proc drawLineAA*(sur: PSurface, p1, p2: TPoint, color: Color) =
   ## Draws a anti-aliased line from ``p1`` to ``p2``, using Xiaolin Wu's 
   ## line algorithm
   var (x1, x2, y1, y2) = (p1.x.toFloat(), p2.x.toFloat(), 
@@ -444,11 +444,11 @@ proc drawLineAA*(sur: PSurface, p1, p2: TPoint, color: TColor) =
     swap(x2, y2)
     swap(dx, dy)
   
-  template doPlot(x, y: int, c: float, color: TColor): stmt =
+  template doPlot(x, y: int, c: float, color: Color): stmt =
     if ax < ay:
-      sur.PlotAA(y, x, c, color)
+      sur.plotAA(y, x, c, color)
     else:
-      sur.PlotAA(x, y, c, color)
+      sur.plotAA(x, y, c, color)
   
   if x2 < x1:
     swap(x1, x2)
@@ -482,22 +482,22 @@ proc drawLineAA*(sur: PSurface, p1, p2: TPoint, color: TColor) =
     intery = intery + gradient
     inc(x)
 
-proc fillSurface*(sur: PSurface, color: TColor) =
+proc fillSurface*(sur: PSurface, color: Color) =
   ## Fills the entire surface with ``color``.
-  if sdl.FillRect(sur.s, nil, sur.createSdlColor(color)) == -1:
+  if sdl.fillRect(sur.s, nil, sur.createSdlColor(color)) == -1:
     raiseEGraphics()
 
 template withEvents*(surf: PSurface, event: expr, actions: stmt): stmt {.
   immediate.} =
   ## Simple template which creates an event loop. ``Event`` is the name of the
   ## variable containing the TEvent object.
-  while True:
-    var event: SDL.TEvent
-    if SDL.WaitEvent(addr(event)) == 1:
+  while true:
+    var event: sdl.TEvent
+    if sdl.waitEvent(addr(event)) == 1:
       actions
 
-if sdl.Init(sdl.INIT_VIDEO) < 0: raiseEGraphics()
-if sdl_ttf.Init() < 0: raiseEGraphics()
+if sdl.init(sdl.INIT_VIDEO) < 0: raiseEGraphics()
+if sdl_ttf.init() < 0: raiseEGraphics()
 
 when isMainModule:
   var surf = newScreenSurface(800, 600)
@@ -539,19 +539,19 @@ when isMainModule:
   withEvents(surf, event):
     var eventp = addr(event)
     case event.kind:
-    of SDL.QUITEV:
+    of sdl.QUITEV:
       break
-    of SDL.KEYDOWN:
-      var evk = sdl.EvKeyboard(eventp)
-      if evk.keysym.sym == SDL.K_LEFT:
+    of sdl.KEYDOWN:
+      var evk = sdl.evKeyboard(eventp)
+      if evk.keysym.sym == sdl.K_LEFT:
         surf.drawHorLine(395, 300, 50, colBlack)
         echo("Drawing")
-      elif evk.keysym.sym == SDL.K_ESCAPE:
+      elif evk.keysym.sym == sdl.K_ESCAPE:
         break
       else:
         echo(evk.keysym.sym)
-    of SDL.MOUSEBUTTONDOWN:
-      var mbd = sdl.EvMouseButton(eventp)
+    of sdl.MOUSEBUTTONDOWN:
+      var mbd = sdl.evMouseButton(eventp)
       if mouseStartX == -1 or mouseStartY == -1:
         mouseStartX = int(mbd.x)
         mouseStartY = int(mbd.y)
@@ -560,16 +560,16 @@ when isMainModule:
         mouseStartX = -1
         mouseStartY = -1
         
-    of SDL.MouseMotion:
-      var mm = sdl.EvMouseMotion(eventp)
+    of sdl.MOUSEMOTION:
+      var mm = sdl.evMouseMotion(eventp)
       if mouseStartX != -1 and mouseStartY != -1:
         surf.drawLineAA((mouseStartX, mouseStartY), (int(mm.x), int(mm.y)), colPurple)
       #echo(mm.x, " ", mm.y, " ", mm.yrel)
     
     else:
-      #echo(event.kind)
+      discard "echo(event.kind)"
       
-    SDL.UpdateRect(surf.s, 0, 0, 800, 600)
+    sdl.updateRect(surf.s, 0, 0, 800, 600)
     
   surf.writeToBMP("test.bmp")
-  SDL.Quit()
+  sdl.quit()
diff --git a/lib/impure/osinfo_posix.nim b/lib/impure/osinfo_posix.nim
index 4fde82012..1baff8c55 100644
--- a/lib/impure/osinfo_posix.nim
+++ b/lib/impure/osinfo_posix.nim
@@ -1,20 +1,21 @@
 import posix, strutils, os
 
-type
-  Tstatfs {.importc: "struct statfs64", 
-            header: "<sys/statfs.h>", final, pure.} = object
-    f_type: int
-    f_bsize: int
-    f_blocks: int
-    f_bfree: int
-    f_bavail: int
-    f_files: int
-    f_ffree: int
-    f_fsid: int
-    f_namelen: int
+when false:
+  type
+    Tstatfs {.importc: "struct statfs64", 
+              header: "<sys/statfs.h>", final, pure.} = object
+      f_type: int
+      f_bsize: int
+      f_blocks: int
+      f_bfree: int
+      f_bavail: int
+      f_files: int
+      f_ffree: int
+      f_fsid: int
+      f_namelen: int
 
-proc statfs(path: string, buf: var Tstatfs): int {.
-  importc, header: "<sys/vfs.h>".}
+  proc statfs(path: string, buf: var Tstatfs): int {.
+    importc, header: "<sys/vfs.h>".}
 
 
 proc getSystemVersion*(): string =
@@ -23,7 +24,7 @@ proc getSystemVersion*(): string =
   var unix_info: TUtsname
   
   if uname(unix_info) != 0:
-    os.OSError()
+    os.raiseOSError(osLastError())
   
   if $unix_info.sysname == "Linux":
     # Linux
diff --git a/lib/impure/osinfo_win.nim b/lib/impure/osinfo_win.nim
index 572e50273..f423a34a3 100644
--- a/lib/impure/osinfo_win.nim
+++ b/lib/impure/osinfo_win.nim
@@ -375,7 +375,7 @@ proc getFileSize*(file: string): BiggestInt =
     var hFile = findFirstFileA(file, fileData)
   
   if hFile == INVALID_HANDLE_VALUE:
-    raise newException(EIO, $getLastError())
+    raise newException(IOError, $getLastError())
   
   return fileData.nFileSizeLow
 
@@ -386,10 +386,10 @@ proc getDiskFreeSpaceEx*(lpDirectoryName: cstring, lpFreeBytesAvailableToCaller,
 
 proc getPartitionInfo*(partition: string): TPartitionInfo =
   ## Retrieves partition info, for example ``partition`` may be ``"C:\"``
-  var FreeBytes, TotalBytes, TotalFreeBytes: TFiletime 
-  var res = getDiskFreeSpaceEx(r"C:\", FreeBytes, TotalBytes, 
-                               TotalFreeBytes)
-  return (FreeBytes, TotalBytes)
+  var freeBytes, totalBytes, totalFreeBytes: TFiletime 
+  discard getDiskFreeSpaceEx(r"C:\", freeBytes, totalBytes, 
+                               totalFreeBytes)
+  return (freeBytes, totalBytes)
 
 when isMainModule:
   var r = getMemoryInfo()
diff --git a/lib/impure/rdstdin.nim b/lib/impure/rdstdin.nim
index 1037d3bda..07ef13fd9 100644
--- a/lib/impure/rdstdin.nim
+++ b/lib/impure/rdstdin.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -15,13 +15,13 @@
 
 when defined(Windows):
   proc readLineFromStdin*(prompt: string): TaintedString {.
-                          tags: [FReadIO, FWriteIO].} = 
+                          tags: [ReadIOEffect, WriteIOEffect].} = 
     ## Reads a line from stdin.
     stdout.write(prompt)
     result = readLine(stdin)
 
   proc readLineFromStdin*(prompt: string, line: var TaintedString): bool {.
-                          tags: [FReadIO, FWriteIO].} =
+                          tags: [ReadIOEffect, WriteIOEffect].} =
     ## Reads a `line` from stdin. `line` must not be
     ## ``nil``! May throw an IO exception.
     ## A line of text may be delimited by ``CR``, ``LF`` or
@@ -35,7 +35,7 @@ else:
   import readline, history
     
   proc readLineFromStdin*(prompt: string): TaintedString {.
-                          tags: [FReadIO, FWriteIO].} =
+                          tags: [ReadIOEffect, WriteIOEffect].} =
     var buffer = readline.readLine(prompt)
     if isNil(buffer): quit(0)
     result = TaintedString($buffer)
@@ -44,7 +44,7 @@ else:
     readline.free(buffer)
 
   proc readLineFromStdin*(prompt: string, line: var TaintedString): bool {.
-                          tags: [FReadIO, FWriteIO].} =
+                          tags: [ReadIOEffect, WriteIOEffect].} =
     var buffer = readline.readLine(prompt)
     if isNil(buffer): quit(0)
     line = TaintedString($buffer)
diff --git a/lib/impure/re.nim b/lib/impure/re.nim
index ac07b2d6b..6e3a69c62 100644
--- a/lib/impure/re.nim
+++ b/lib/impure/re.nim
@@ -1,13 +1,13 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
 #
 
-## Regular expression support for Nimrod. Consider using the pegs module
+## Regular expression support for Nim. Consider using the pegs module
 ## instead.
 ## This module is implemented by providing a wrapper around the
 ## `PRCE (Perl-Compatible Regular Expressions) <http://www.pcre.org>`_
@@ -28,7 +28,7 @@ const
     ## More subpatterns cannot be captured!
 
 type
-  TRegexFlag* = enum     ## options for regular expressions
+  RegexFlag* = enum     ## options for regular expressions
     reIgnoreCase = 0,    ## do caseless matching
     reMultiLine = 1,     ## ``^`` and ``$`` match newlines within data 
     reDotAll = 2,        ## ``.`` matches anything including NL
@@ -36,17 +36,20 @@ type
     reStudy = 4          ## study the expression (may be omitted if the
                          ## expression will be used only once)
     
-  TRegexDesc {.pure, final.}  = object 
+  RegexDesc = object 
     h: PPcre
     e: ptr TExtra
     
-  TRegex* = ref TRegexDesc ## a compiled regular expression
+  Regex* = ref RegexDesc ## a compiled regular expression
     
-  EInvalidRegEx* = object of EInvalidValue
+  RegexError* = object of ValueError
     ## is raised if the pattern is no valid regular expression.
 
+{.deprecated: [TRegexFlag: RegexFlag, TRegexDesc: RegexDesc, TRegex: Regex,
+    EInvalidRegEx: RegexError].}
+
 proc raiseInvalidRegex(msg: string) {.noinline, noreturn.} = 
-  var e: ref EInvalidRegEx
+  var e: ref RegexError
   new(e)
   e.msg = msg
   raise e
@@ -55,11 +58,11 @@ proc rawCompile(pattern: string, flags: cint): PPcre =
   var
     msg: cstring
     offset: cint
-  result = pcre.Compile(pattern, flags, addr(msg), addr(offset), nil)
+  result = pcre.compile(pattern, flags, addr(msg), addr(offset), nil)
   if result == nil:
     raiseInvalidRegex($msg & "\n" & pattern & "\n" & repeatChar(offset) & "^\n")
 
-proc finalizeRegEx(x: TRegex) = 
+proc finalizeRegEx(x: Regex) = 
   # XXX This is a hack, but PCRE does not export its "free" function properly.
   # Sigh. The hack relies on PCRE's implementation (see ``pcre_get.c``).
   # Fortunately the implementation is unlikely to change. 
@@ -67,8 +70,8 @@ proc finalizeRegEx(x: TRegex) =
   if not isNil(x.e):
     pcre.free_substring(cast[cstring](x.e))
 
-proc re*(s: string, flags = {reExtended, reStudy}): TRegex =
-  ## Constructor of regular expressions. Note that Nimrod's
+proc re*(s: string, flags = {reExtended, reStudy}): Regex =
+  ## Constructor of regular expressions. Note that Nim's
   ## extended raw string literals support this syntax ``re"[abc]"`` as
   ## a short form for ``re(r"[abc]")``.
   new(result, finalizeRegEx)
@@ -78,39 +81,39 @@ proc re*(s: string, flags = {reExtended, reStudy}): TRegex =
     result.e = pcre.study(result.h, 0, msg)
     if not isNil(msg): raiseInvalidRegex($msg)
 
-proc matchOrFind(s: string, pattern: TRegex, matches: var openArray[string],
+proc matchOrFind(s: string, pattern: Regex, matches: var openArray[string],
                  start, flags: cint): cint =
   var
-    rawMatches: array[0..maxSubpatterns * 3 - 1, cint]
-    res = pcre.Exec(pattern.h, pattern.e, s, len(s).cint, start, flags,
-      cast[ptr cint](addr(rawMatches)), maxSubpatterns * 3)
+    rawMatches: array[0..MaxSubpatterns * 3 - 1, cint]
+    res = pcre.exec(pattern.h, pattern.e, s, len(s).cint, start, flags,
+      cast[ptr cint](addr(rawMatches)), MaxSubpatterns * 3)
   if res < 0'i32: return res
   for i in 1..int(res)-1:
     var a = rawMatches[i * 2]
     var b = rawMatches[i * 2 + 1]
     if a >= 0'i32: matches[i-1] = substr(s, int(a), int(b)-1)
-    else: matches[i-1] = ""
+    else: matches[i-1] = nil
   return rawMatches[1] - rawMatches[0]
   
-proc findBounds*(s: string, pattern: TRegex, matches: var openArray[string],
+proc findBounds*(s: string, pattern: Regex, matches: var openArray[string],
                  start = 0): tuple[first, last: int] =
   ## returns the starting position and end position of `pattern` in `s` 
   ## and the captured
   ## substrings in the array `matches`. If it does not match, nothing
   ## is written into `matches` and ``(-1,0)`` is returned.
   var
-    rawMatches: array[0..maxSubpatterns * 3 - 1, cint]
-    res = pcre.Exec(pattern.h, pattern.e, s, len(s).cint, start.cint, 0'i32,
-      cast[ptr cint](addr(rawMatches)), maxSubpatterns * 3)
+    rawMatches: array[0..MaxSubpatterns * 3 - 1, cint]
+    res = pcre.exec(pattern.h, pattern.e, s, len(s).cint, start.cint, 0'i32,
+      cast[ptr cint](addr(rawMatches)), MaxSubpatterns * 3)
   if res < 0'i32: return (-1, 0)
   for i in 1..int(res)-1:
     var a = rawMatches[i * 2]
     var b = rawMatches[i * 2 + 1]
     if a >= 0'i32: matches[i-1] = substr(s, int(a), int(b)-1)
-    else: matches[i-1] = ""
+    else: matches[i-1] = nil
   return (rawMatches[0].int, rawMatches[1].int - 1)
   
-proc findBounds*(s: string, pattern: TRegex, 
+proc findBounds*(s: string, pattern: Regex, 
                  matches: var openArray[tuple[first, last: int]],
                  start = 0): tuple[first, last: int] =
   ## returns the starting position and end position of ``pattern`` in ``s`` 
@@ -118,9 +121,9 @@ proc findBounds*(s: string, pattern: TRegex,
   ## If it does not match, nothing is written into `matches` and
   ## ``(-1,0)`` is returned.
   var
-    rawMatches: array[0..maxSubpatterns * 3 - 1, cint]
-    res = pcre.Exec(pattern.h, pattern.e, s, len(s).cint, start.cint, 0'i32,
-      cast[ptr cint](addr(rawMatches)), maxSubpatterns * 3)
+    rawMatches: array[0..MaxSubpatterns * 3 - 1, cint]
+    res = pcre.exec(pattern.h, pattern.e, s, len(s).cint, start.cint, 0'i32,
+      cast[ptr cint](addr(rawMatches)), MaxSubpatterns * 3)
   if res < 0'i32: return (-1, 0)
   for i in 1..int(res)-1:
     var a = rawMatches[i * 2]
@@ -129,25 +132,25 @@ proc findBounds*(s: string, pattern: TRegex,
     else: matches[i-1] = (-1,0)
   return (rawMatches[0].int, rawMatches[1].int - 1)
 
-proc findBounds*(s: string, pattern: TRegex, 
+proc findBounds*(s: string, pattern: Regex, 
                  start = 0): tuple[first, last: int] =
   ## returns the starting position of `pattern` in `s`. If it does not
   ## match, ``(-1,0)`` is returned.
   var
     rawMatches: array[0..3 - 1, cint]
-    res = pcre.Exec(pattern.h, nil, s, len(s).cint, start.cint, 0'i32,
+    res = pcre.exec(pattern.h, nil, s, len(s).cint, start.cint, 0'i32,
       cast[ptr cint](addr(rawMatches)), 3)
   if res < 0'i32: return (int(res), 0)
   return (int(rawMatches[0]), int(rawMatches[1]-1))
   
-proc matchOrFind(s: string, pattern: TRegex, start, flags: cint): cint =
-  var rawMatches: array [0..maxSubpatterns * 3 - 1, cint]
-  result = pcre.Exec(pattern.h, pattern.e, s, len(s).cint, start, flags,
-                    cast[ptr cint](addr(rawMatches)), maxSubpatterns * 3)
+proc matchOrFind(s: string, pattern: Regex, start, flags: cint): cint =
+  var rawMatches: array [0..MaxSubpatterns * 3 - 1, cint]
+  result = pcre.exec(pattern.h, pattern.e, s, len(s).cint, start, flags,
+                    cast[ptr cint](addr(rawMatches)), MaxSubpatterns * 3)
   if result >= 0'i32:
     result = rawMatches[1] - rawMatches[0]
 
-proc match*(s: string, pattern: TRegex, matches: var openArray[string],
+proc match*(s: string, pattern: Regex, matches: var openArray[string],
            start = 0): bool =
   ## returns ``true`` if ``s[start..]`` matches the ``pattern`` and
   ## the captured substrings in the array ``matches``. If it does not
@@ -156,67 +159,67 @@ proc match*(s: string, pattern: TRegex, matches: var openArray[string],
   return matchOrFind(s, pattern, matches, start.cint, 
                      pcre.ANCHORED) == cint(s.len - start)
 
-proc match*(s: string, pattern: TRegex, start = 0): bool =
+proc match*(s: string, pattern: Regex, start = 0): bool =
   ## returns ``true`` if ``s[start..]`` matches the ``pattern``.
   return matchOrFind(s, pattern, start.cint, pcre.ANCHORED) == cint(s.len-start)
 
-proc matchLen*(s: string, pattern: TRegex, matches: var openArray[string],
+proc matchLen*(s: string, pattern: Regex, matches: var openArray[string],
               start = 0): int =
   ## the same as ``match``, but it returns the length of the match,
   ## if there is no match, -1 is returned. Note that a match length
   ## of zero can happen.
   return matchOrFind(s, pattern, matches, start.cint, pcre.ANCHORED)
 
-proc matchLen*(s: string, pattern: TRegex, start = 0): int =
+proc matchLen*(s: string, pattern: Regex, start = 0): int =
   ## the same as ``match``, but it returns the length of the match,
   ## if there is no match, -1 is returned. Note that a match length
   ## of zero can happen. 
   return matchOrFind(s, pattern, start.cint, pcre.ANCHORED)
 
-proc find*(s: string, pattern: TRegex, matches: var openArray[string],
+proc find*(s: string, pattern: Regex, matches: var openArray[string],
            start = 0): int =
   ## returns the starting position of ``pattern`` in ``s`` and the captured
   ## substrings in the array ``matches``. If it does not match, nothing
   ## is written into ``matches`` and -1 is returned.
   var
-    rawMatches: array[0..maxSubpatterns * 3 - 1, cint]
-    res = pcre.Exec(pattern.h, pattern.e, s, len(s).cint, start.cint, 0'i32,
-      cast[ptr cint](addr(rawMatches)), maxSubpatterns * 3)
+    rawMatches: array[0..MaxSubpatterns * 3 - 1, cint]
+    res = pcre.exec(pattern.h, pattern.e, s, len(s).cint, start.cint, 0'i32,
+      cast[ptr cint](addr(rawMatches)), MaxSubpatterns * 3)
   if res < 0'i32: return res
   for i in 1..int(res)-1:
     var a = rawMatches[i * 2]
     var b = rawMatches[i * 2 + 1]
     if a >= 0'i32: matches[i-1] = substr(s, int(a), int(b)-1)
-    else: matches[i-1] = ""
+    else: matches[i-1] = nil
   return rawMatches[0]
 
-proc find*(s: string, pattern: TRegex, start = 0): int =
+proc find*(s: string, pattern: Regex, start = 0): int =
   ## returns the starting position of ``pattern`` in ``s``. If it does not
   ## match, -1 is returned.
   var
     rawMatches: array[0..3 - 1, cint]
-    res = pcre.Exec(pattern.h, nil, s, len(s).cint, start.cint, 0'i32,
+    res = pcre.exec(pattern.h, nil, s, len(s).cint, start.cint, 0'i32,
       cast[ptr cint](addr(rawMatches)), 3)
   if res < 0'i32: return res
   return rawMatches[0]
   
-iterator findAll*(s: string, pattern: TRegex, start = 0): string = 
+iterator findAll*(s: string, pattern: Regex, start = 0): string = 
   ## Yields all matching *substrings* of `s` that match `pattern`.
   ##
   ## Note that since this is an iterator you should not modify the string you
   ## are iterating over: bad things could happen.
   var i = int32(start)
-  var rawMatches: array[0..maxSubpatterns * 3 - 1, cint]
+  var rawMatches: array[0..MaxSubpatterns * 3 - 1, cint]
   while true:
-    let res = pcre.Exec(pattern.h, pattern.e, s, len(s).cint, i, 0'i32,
-      cast[ptr cint](addr(rawMatches)), maxSubpatterns * 3)
+    let res = pcre.exec(pattern.h, pattern.e, s, len(s).cint, i, 0'i32,
+      cast[ptr cint](addr(rawMatches)), MaxSubpatterns * 3)
     if res < 0'i32: break
     let a = rawMatches[0]
     let b = rawMatches[1]
     yield substr(s, int(a), int(b)-1)
     i = b
 
-proc findAll*(s: string, pattern: TRegex, start = 0): seq[string] = 
+proc findAll*(s: string, pattern: Regex, start = 0): seq[string] = 
   ## returns all matching *substrings* of `s` that match `pattern`.
   ## If it does not match, @[] is returned.
   accumulateResult(findAll(s, pattern, start))
@@ -224,11 +227,11 @@ proc findAll*(s: string, pattern: TRegex, start = 0): seq[string] =
 when not defined(nimhygiene):
   {.pragma: inject.}
 
-template `=~` *(s: string, pattern: TRegex): expr = 
+template `=~` *(s: string, pattern: Regex): expr = 
   ## This calls ``match`` with an implicit declared ``matches`` array that 
   ## can be used in the scope of the ``=~`` call: 
   ## 
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##
   ##   if line =~ re"\s*(\w+)\s*\=\s*(\w+)": 
   ##     # matches a key=value pair:
@@ -242,41 +245,41 @@ template `=~` *(s: string, pattern: TRegex): expr =
   ##   else:
   ##     echo("syntax error")
   ##
-  bind maxSubPatterns
+  bind MaxSubPatterns
   when not declaredInScope(matches):
     var matches {.inject.}: array[0..MaxSubpatterns-1, string]
   match(s, pattern, matches)
 
 # ------------------------- more string handling ------------------------------
 
-proc contains*(s: string, pattern: TRegex, start = 0): bool =
+proc contains*(s: string, pattern: Regex, start = 0): bool =
   ## same as ``find(s, pattern, start) >= 0``
   return find(s, pattern, start) >= 0
 
-proc contains*(s: string, pattern: TRegex, matches: var openArray[string],
+proc contains*(s: string, pattern: Regex, matches: var openArray[string],
               start = 0): bool =
   ## same as ``find(s, pattern, matches, start) >= 0``
   return find(s, pattern, matches, start) >= 0
 
-proc startsWith*(s: string, prefix: TRegex): bool =
+proc startsWith*(s: string, prefix: Regex): bool =
   ## returns true if `s` starts with the pattern `prefix`
   result = matchLen(s, prefix) >= 0
 
-proc endsWith*(s: string, suffix: TRegex): bool =
+proc endsWith*(s: string, suffix: Regex): bool =
   ## returns true if `s` ends with the pattern `prefix`
   for i in 0 .. s.len-1:
     if matchLen(s, suffix, i) == s.len - i: return true
 
-proc replace*(s: string, sub: TRegex, by = ""): string =
+proc replace*(s: string, sub: Regex, by = ""): string =
   ## Replaces `sub` in `s` by the string `by`. Captures cannot be 
   ## accessed in `by`. Examples:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##   "var1=key; var2=key2".replace(re"(\w+)'='(\w+)")
   ##
   ## Results in:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##
   ##   "; "
   result = ""
@@ -289,24 +292,26 @@ proc replace*(s: string, sub: TRegex, by = ""): string =
     prev = match.last + 1
   add(result, substr(s, prev))
   
-proc replacef*(s: string, sub: TRegex, by: string): string =
+proc replacef*(s: string, sub: Regex, by: string): string =
   ## Replaces `sub` in `s` by the string `by`. Captures can be accessed in `by`
   ## with the notation ``$i`` and ``$#`` (see strutils.`%`). Examples:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ## "var1=key; var2=key2".replacef(re"(\w+)'='(\w+)", "$1<-$2$2")
   ##
   ## Results in:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##
   ## "var1<-keykey; val2<-key2key2"
   result = ""
-  var caps: array[0..maxSubpatterns-1, string]
+  var caps: array[0..MaxSubpatterns-1, string]
   var prev = 0
   while true:
     var match = findBounds(s, sub, caps, prev)
     if match.first < 0: break
+    assert result != nil
+    assert s != nil
     add(result, substr(s, prev, match.first-1))
     addf(result, by, caps)
     prev = match.last + 1
@@ -314,7 +319,7 @@ proc replacef*(s: string, sub: TRegex, by: string): string =
   when false:
     result = ""
     var i = 0
-    var caps: array[0..maxSubpatterns-1, string]
+    var caps: array[0..MaxSubpatterns-1, string]
     while i < s.len:
       var x = matchLen(s, sub, caps, i)
       if x <= 0:
@@ -327,12 +332,12 @@ proc replacef*(s: string, sub: TRegex, by: string): string =
     add(result, substr(s, i))
   
 proc parallelReplace*(s: string, subs: openArray[
-                      tuple[pattern: TRegex, repl: string]]): string = 
+                      tuple[pattern: Regex, repl: string]]): string = 
   ## Returns a modified copy of `s` with the substitutions in `subs`
   ## applied in parallel.
   result = ""
   var i = 0
-  var caps: array[0..maxSubpatterns-1, string]
+  var caps: array[0..MaxSubpatterns-1, string]
   while i < s.len:
     block searchSubs:
       for j in 0..high(subs):
@@ -347,26 +352,26 @@ proc parallelReplace*(s: string, subs: openArray[
   add(result, substr(s, i))  
   
 proc transformFile*(infile, outfile: string,
-                    subs: openArray[tuple[pattern: TRegex, repl: string]]) =
+                    subs: openArray[tuple[pattern: Regex, repl: string]]) =
   ## reads in the file `infile`, performs a parallel replacement (calls
   ## `parallelReplace`) and writes back to `outfile`. Raises ``EIO`` if an
   ## error occurs. This is supposed to be used for quick scripting.
   var x = readFile(infile).string
   writeFile(outfile, x.parallelReplace(subs))
   
-iterator split*(s: string, sep: TRegex): string =
+iterator split*(s: string, sep: Regex): string =
   ## Splits the string `s` into substrings.
   ##
   ## Substrings are separated by the regular expression `sep`.
   ## Examples:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##   for word in split("00232this02939is39an22example111", re"\d+"):
   ##     writeln(stdout, word)
   ##
   ## Results in:
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##   "this"
   ##   "is"
   ##   "an"
@@ -386,7 +391,7 @@ iterator split*(s: string, sep: TRegex): string =
     if first < last:
       yield substr(s, first, last-1)
 
-proc split*(s: string, sep: TRegex): seq[string] =
+proc split*(s: string, sep: Regex): seq[string] =
   ## Splits the string `s` into substrings.
   accumulateResult(split(s, sep))
   
@@ -447,6 +452,14 @@ when isMainModule:
     assert matches[1] == "abc"
   else:
     assert false
+  
+  if "abc" =~ re"(cba)?.*":
+    assert matches[0] == nil
+  else: assert false
+
+  if "abc" =~ re"().*":
+    assert matches[0] == ""
+  else: assert false
     
   assert "var1=key; var2=key2".endsWith(re"\w+=\w+")
   assert("var1=key; var2=key2".replacef(re"(\w+)=(\w+)", "$1<-$2$2") ==
diff --git a/lib/impure/ssl.nim b/lib/impure/ssl.nim
index 54d524c7b..bb7cfc0d3 100644
--- a/lib/impure/ssl.nim
+++ b/lib/impure/ssl.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Dominik Picheta
 #
 #    See the file "copying.txt", included in this
@@ -8,31 +8,31 @@
 #
 
 ## This module provides an easy to use sockets-style 
-## nimrod interface to the OpenSSL library.
+## nim interface to the OpenSSL library.
 
 {.deprecated.}
 
 import openssl, strutils, os
 
 type
-  TSecureSocket* {.final.} = object
-    ssl: PSSL
-    bio: PBIO
+  TSecureSocket* = object
+    ssl: SslPtr
+    bio: BIO
 
 proc connect*(sock: var TSecureSocket, address: string, 
-    port: int): Int =
+    port: int): int =
   ## Connects to the specified `address` on the specified `port`.
   ## Returns the result of the certificate validation.
   SslLoadErrorStrings()
   ERR_load_BIO_strings()
   
   if SSL_library_init() != 1:
-    OSError()
+    raiseOSError(osLastError())
   
   var ctx = SSL_CTX_new(SSLv23_client_method())
   if ctx == nil:
     ERR_print_errors_fp(stderr)
-    OSError()
+    raiseOSError(osLastError())
     
   #if SSL_CTX_load_verify_locations(ctx, 
   #   "/tmp/openssl-0.9.8e/certs/vsign1.pem", NIL) == 0:
@@ -41,14 +41,14 @@ proc connect*(sock: var TSecureSocket, address: string,
   
   sock.bio = BIO_new_ssl_connect(ctx)
   if BIO_get_ssl(sock.bio, addr(sock.ssl)) == 0:
-    OSError()
+    raiseOSError(osLastError())
 
   if BIO_set_conn_hostname(sock.bio, address & ":" & $port) != 1:
-    OSError()
+    raiseOSError(osLastError())
   
   if BIO_do_connect(sock.bio) <= 0:
     ERR_print_errors_fp(stderr)
-    OSError()
+    raiseOSError(osLastError())
   
   result = SSL_get_verify_result(sock.ssl)
 
@@ -57,30 +57,30 @@ proc recvLine*(sock: TSecureSocket, line: var TaintedString): bool =
   ## Returns false when no data is available to be read.
   ## `Line` must be initialized and not nil!
   setLen(line.string, 0)
-  while True:
+  while true:
     var c: array[0..0, char]
     var n = BIO_read(sock.bio, c, c.len.cint)
-    if n <= 0: return False
+    if n <= 0: return false
     if c[0] == '\r':
       n = BIO_read(sock.bio, c, c.len.cint)
       if n > 0 and c[0] == '\L':
-        return True
+        return true
       elif n <= 0:
-        return False
-    elif c[0] == '\L': return True
+        return false
+    elif c[0] == '\L': return true
     add(line.string, c)
 
 
 proc send*(sock: TSecureSocket, data: string) =
   ## Writes `data` to the socket.
   if BIO_write(sock.bio, data, data.len.cint) <= 0:
-    OSError()
+    raiseOSError(osLastError())
 
 proc close*(sock: TSecureSocket) =
   ## Closes the socket
   if BIO_free(sock.bio) <= 0:
     ERR_print_errors_fp(stderr)
-    OSError()
+    raiseOSError(osLastError())
 
 when isMainModule:
   var s: TSecureSocket
diff --git a/lib/impure/web.nim b/lib/impure/web.nim
deleted file mode 100644
index 5f04422d1..000000000
--- a/lib/impure/web.nim
+++ /dev/null
@@ -1,63 +0,0 @@
-#

-#

-#            Nimrod's Runtime Library

-#        (c) Copyright 2012 Andreas Rumpf

-#

-#    See the file "copying.txt", included in this

-#    distribution, for details about the copyright.

-#

-

-## This module contains simple high-level procedures for dealing with the

-## web. Use cases: 

-##

-## * requesting URLs

-## * sending and retrieving emails

-## * sending and retrieving files from an FTP server

-##

-## Currently only requesting URLs is implemented. The implementation depends

-## on the libcurl library!

-##

-## **Deprecated since version 0.8.8:** Use the

-## `httpclient <httpclient.html>`_ module instead. 

-## 

-

-{.deprecated.}

-

-import libcurl, streams

-

-proc curlwrapperWrite(p: pointer, size, nmemb: int, 

-                      data: pointer): int {.cdecl.} = 

-  var stream = cast[PStream](data)

-  stream.writeData(p, size*nmemb)

-  return size*nmemb

-

-proc URLretrieveStream*(url: string): PStream = 

-  ## retrieves the given `url` and returns a stream which one can read from to

-  ## obtain the contents. Returns nil if an error occurs.

-  result = newStringStream()

-  var hCurl = easy_init() 

-  if hCurl == nil: return nil

-  if easy_setopt(hCurl, OPT_URL, url) != E_OK: return nil

-  if easy_setopt(hCurl, OPT_WRITEFUNCTION, 

-                      curlwrapperWrite) != E_OK: return nil

-  if easy_setopt(hCurl, OPT_WRITEDATA, result) != E_OK: return nil

-  if easy_perform(hCurl) != E_OK: return nil

-  easy_cleanup(hCurl)

-  

-proc URLretrieveString*(url: string): TaintedString = 

-  ## retrieves the given `url` and returns the contents. Returns nil if an

-  ## error occurs.

-  var stream = newStringStream()

-  var hCurl = easy_init()

-  if hCurl == nil: return

-  if easy_setopt(hCurl, OPT_URL, url) != E_OK: return

-  if easy_setopt(hCurl, OPT_WRITEFUNCTION, 

-                      curlwrapperWrite) != E_OK: return

-  if easy_setopt(hCurl, OPT_WRITEDATA, stream) != E_OK: return

-  if easy_perform(hCurl) != E_OK: return

-  easy_cleanup(hCurl)

-  result = stream.data.TaintedString

-

-when isMainModule:

-  echo URLretrieveString("http://nimrod-code.org/")

-

diff --git a/lib/impure/zipfiles.nim b/lib/impure/zipfiles.nim
index b9f89dda0..c22294061 100644
--- a/lib/impure/zipfiles.nim
+++ b/lib/impure/zipfiles.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2012 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -13,18 +13,18 @@ import
   streams, libzip, times, os
 
 type
-  TZipArchive* = object of TObject ## represents a zip archive
-    mode: TFileMode
+  TZipArchive* = object of RootObj ## represents a zip archive
+    mode: FileMode
     w: PZip
 
 
 proc zipError(z: var TZipArchive) = 
-  var e: ref EIO
+  var e: ref IOError
   new(e)
   e.msg = $zip_strerror(z.w)
   raise e
   
-proc open*(z: var TZipArchive, filename: string, mode: TFileMode = fmRead): bool =
+proc open*(z: var TZipArchive, filename: string, mode: FileMode = fmRead): bool =
   ## Opens a zip file for reading, writing or appending. All file modes are 
   ## supported. Returns true iff successful, false otherwise.
   var err, flags: int32
@@ -57,7 +57,7 @@ proc addFile*(z: var TZipArchive, dest, src: string) =
   ## may contain a path that will be created. 
   assert(z.mode != fmRead) 
   if not fileExists(src):
-    raise newException(EIO, "File '" & src & "' does not exist")
+    raise newException(IOError, "File '" & src & "' does not exist")
   var zipsrc = zip_source_file(z.w, src, 0, -1)
   if zipsrc == nil:
     #echo("Dest: " & dest)
@@ -74,7 +74,7 @@ proc addFile*(z: var TZipArchive, file: string) =
   
 proc mySourceCallback(state, data: pointer, len: int, 
                       cmd: TZipSourceCmd): int {.cdecl.} = 
-  var src = cast[PStream](state)
+  var src = cast[Stream](state)
   case cmd
   of ZIP_SOURCE_OPEN: 
     if src.setPositionImpl != nil: setPosition(src, 0) # reset
@@ -95,7 +95,7 @@ proc mySourceCallback(state, data: pointer, len: int,
   of constZIP_SOURCE_FREE: GC_unref(src)
   else: assert(false)
   
-proc addFile*(z: var TZipArchive, dest: string, src: PStream) = 
+proc addFile*(z: var TZipArchive, dest: string, src: Stream) = 
   ## Adds a file named with `dest` to the archive `z`. `dest`
   ## may contain a path. The file's content is read from the `src` stream.
   assert(z.mode != fmRead)
@@ -109,14 +109,14 @@ proc addFile*(z: var TZipArchive, dest: string, src: PStream) =
 # -------------- zip file stream ---------------------------------------------
 
 type
-  TZipFileStream = object of TStream
+  TZipFileStream = object of StreamObj
     f: PZipFile
 
   PZipFileStream* = 
     ref TZipFileStream ## a reader stream of a file within a zip archive 
 
-proc fsClose(s: PStream) = zip_fclose(PZipFileStream(s).f)
-proc fsReadData(s: PStream, buffer: pointer, bufLen: int): int = 
+proc fsClose(s: Stream) = zip_fclose(PZipFileStream(s).f)
+proc fsReadData(s: Stream, buffer: pointer, bufLen: int): int = 
   result = zip_fread(PZipFileStream(s).f, buffer, bufLen)
 
 proc newZipFileStream(f: PZipFile): PZipFileStream = 
@@ -146,7 +146,7 @@ iterator walkFiles*(z: var TZipArchive): string =
     inc(i)
 
 
-proc extractFile*(z: var TZipArchive, srcFile: string, dest: PStream) =
+proc extractFile*(z: var TZipArchive, srcFile: string, dest: Stream) =
   ## extracts a file from the zip archive `z` to the destination stream.
   var strm = getStream(z, srcFile)
   while true:
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-02-10 05:15:51 +0000