further development of httpserver

examples/allany.nim

@@ -0,0 +1,17 @@
+# All and any
+
+template all(container, cond: expr): expr =
+  block:
+    var result = true
+    for item in items(container):
+      if not cond(item):
+        result = false
+        break
+    result
+
+if all("mystring", {'a'..'z'}.contains): 
+  echo "works"
+else: 
+  echo "does not work"
+
+

lib/devel/httpserver.nim

@@ -134,14 +134,6 @@ proc executeCgi(client: TSocket, path, query: string, meth: TRequestMethod) =
 
 # --------------- Server Setup -----------------------------------------------
 
-proc startup(): tuple[socket: TSocket, port: TPort] =
-  var s = socket(AF_INET)
-  if s == InvalidSocket: OSError()
-  bindAddr(s)
-  listen(s)
-  result.socket = s
-  result.port = getSockName(s)
-
 proc acceptRequest(client: TSocket) =
   var cgi = false
   var query = ""
@@ -181,16 +173,80 @@ proc acceptRequest(client: TSocket) =
     else:
       executeCgi(client, path, query, meth)
 
-proc main =  
+type
-  var (server, port) = startup()
+  TServer* = object
-  echo("httpserver running on port ", int16(port))
+    socket: TSocket
+    port: TPort
+    client*: TSocket      ## the socket to write the file data to
+    path*, query*: string ## path and query the client requested
+    
+proc open*(s: var TServer, port = TPort(0)) = 
+  ## creates a new server at port `port`. If ``port == 0`` a free port is
+  ## aquired that can be accessed later by the ``port`` proc.
+  s.socket = socket(AF_INET)
+  if s.socket == InvalidSocket: OSError()
+  bindAddr(s.socket)
+  listen(s.socket)
+  s.port = getSockName(s.socket)
+  s.client = InvalidSocket
+  s.path = ""
+  s.query = ""
   
-  while true:
+proc port*(s: var TServer): TPort = 
-    var client = accept(server)
+  ## get the port number the server has aquired.
-    if client == InvalidSocket: OSError()
+  result = s.port
-    acceptRequest(client)
+  
-    close(client)
+proc next*(s: var TServer) = 
-  close(server)
+  ## proceed to the first/next request.
+  s.client = accept(s.socket)
+  headers(s.client, "")
+  var buf = ""
+  discard recvLine(s.client, buf)
+  var data = buf.split()
+  if cmpIgnoreCase(data[0], "GET") == 0:
+    var q = find(data[1], '?')
+    if q >= 0:
+      s.query = data[1].copy(q+1)
+      s.path = data[1].copy(0, q-1)
+    else:
+      s.query = ""
+      s.path = data[1]
+  else:
+    unimplemented(s.client)
+
+proc close*(s: TServer) =
+  close(s.socket)
+
+proc run*(handleRequest: proc (client: TSocket, path, query: string): bool, 
+          port = TPort(0)) =
+  ## encapsulates the server object and main loop
+  var s: TServer
+  open(s, port)
+  echo("httpserver running on port ", s.port)
+  while true: 
+    next(s)
+    if handleRequest(s.client, s.path, s.query): break
+    close(s.client)
+  close(s.socket)
+
+when false:
+  proc main =  
+    var (server, port) = startup()
+    echo("httpserver running on port ", int16(port))
+    
+    while true:
+      var client = accept(server)
+      if client == InvalidSocket: OSError()
+      acceptRequest(client)
+      close(client)
+    close(server)
 
 when isMainModule:
-  main()
+  var counter = 0
+  proc handleRequest(client: TSocket, path, query: string): bool {.procvar.} =
+    inc(counter)
+    client.send("Hallo, Andreas for the $#th time." % $counter & wwwNL)
+    return false # do not stop processing
+  
+  run(handleRequest)
+

lib/pure/sockets.nim

@@ -66,6 +66,8 @@ const
 proc `==`*(a, b: TSocket): bool {.borrow.}
 proc `==`*(a, b: TPort): bool {.borrow.}
 
+proc `$`* (p: TPort): string = result = $ze(int16(p))
+
 proc ToInt(domain: TDomain): cint =
   case domain
   of AF_UNIX:        result = posix.AF_UNIX

rod/scanner.nim

@@ -408,7 +408,6 @@ proc handleDecChars(L: var TLexer, xi: var int) =
     inc(L.bufpos)
 
 proc getEscapedChar(L: var TLexer, tok: var TToken) = 
-  var xi: int
   inc(L.bufpos)               # skip '\'
   case L.buf[L.bufpos]
   of 'n', 'N': 
@@ -447,14 +446,14 @@ proc getEscapedChar(L: var TLexer, tok: var TToken) =
     Inc(L.bufpos)
   of 'x', 'X': 
     inc(L.bufpos)
-    xi = 0
+    var xi = 0
     handleHexChar(L, xi)
     handleHexChar(L, xi)
     add(tok.literal, Chr(xi))
   of '0'..'9': 
     if matchTwoChars(L, '0', {'0'..'9'}): 
       lexMessage(L, warnOctalEscape)
-    xi = 0
+    var xi = 0
     handleDecChars(L, xi)
     if (xi <= 255): add(tok.literal, Chr(xi))
     else: lexMessage(L, errInvalidCharacterConstant)
@@ -505,8 +504,7 @@ proc getString(L: var TLexer, tok: var TToken, rawMode: bool) =
       else: 
         add(tok.literal, buf[pos])
         Inc(pos)
-    L.bufpos = pos +
+    L.bufpos = pos + 3 # skip the three """
-        3                     # skip the three """
   else: 
     # ordinary string literal
     if rawMode: tok.tokType = tkRStrLit
@@ -787,4 +785,4 @@ proc rawGetTok(L: var TLexer, tok: var TToken) =
         lexMessage(L, errInvalidToken, c & " (\\" & $(ord(c)) & ')')
         Inc(L.bufpos)
   
-dummyIdent = getIdent("")
+dummyIdent = getIdent("")

tests/tfinally.nim

@@ -6,5 +6,5 @@ proc main: int =
   finally: 
     echo "came here"
     
-echo main()
+discard main() #OUT came here
 

tests/tmatrix.nim

@@ -21,18 +21,18 @@ proc `[,]`*(m: TMatrix, x, y: int): float {.inline.} =
 proc `[,]=`*(m: var TMatrix, x, y: int, val: float) {.inline.} =
   m.data[x|y] = val
   
-proc `[$..$, $..$]`*(m: TMatrix, a, b, c, d: int): TMatrix =
+proc `[$ .. $, $ .. $]`*(m: TMatrix, a, b, c, d: int): TMatrix =
   result = createMatrix(b-a+1, d-c+1)
   for x in a..b:
     for y in c..d:
       result[x-a, y-c] = m[x, y]
 
-proc `[$..$, $..$]=`*(m: var TMatrix, a, b, c, d: int, val: float) =
+proc `[$ .. $, $ .. $]=`*(m: var TMatrix, a, b, c, d: int, val: float) =
   for x in a..b:
     for y in c..d:
       m[x, y] = val
 
-proc `[$..$, $..$]=`*(m: var TMatrix, a, b, c, d: int, val: TMatrix) =
+proc `[$ .. $, $ .. $]=`*(m: var TMatrix, a, b, c, d: int, val: TMatrix) =
   assert val.width == b-a+1
   assert val.height == d-c+1
   for x in a..b:
@@ -57,4 +57,4 @@ for i in 0..w-1:
   m[i, i] = 1.0
 
 for i in 0..w-1:
-  stdout.write(m[i,i]) #OUT 1.01.01.0
+  stdout.write(m[i,i]) #OUT 111