Document %.*Q

PUBLISHED_FROM=5dc567f8978d5414835f7a2338a78ae9eb683f55

docs/design-concept/intro.md

@@ -8,7 +8,7 @@ items:
 ---
 
 Mongoose is a multi-protocol networking library that implements non-blocking,
-asyncronous IO and provides event-based API. It has three basic data
+asyncronous IO and provides event-based APIs. It has three basic data
 structures:
 
 - `struct mg_mgr` is an event manager that holds all active connections
@@ -16,14 +16,14 @@ structures:
 - `struct mbuf` describes data buffer (received or sent data)
 
 Connections could be either *listening*, *outbound* or *inbound*. Outbound
-connections are created by `mg_connect()` call.  Listening connections are
-created by `mg_bind()` call.  Inbound connections are those accepted by a
-listening connection.  Each connection is described by `struct mg_connection`
+connections are created by the `mg_connect()` call. Listening connections are
+created by the `mg_bind()` call. Inbound connections are those accepted by a
+listening connection. Each connection is described by the `struct mg_connection`
 structure, which has a number of fields like socket, event handler function,
-send/receive buffer, flags, et cetera.
+send/receive buffer, flags, etc.
 
-Mongoose usage pattern is to declare and initialize event manager, create
+Mongoose's usage pattern is to declare and initialise event manager, create
 connections and create an event loop by calling `mg_mgr_poll()` in a loop.
 `mg_mgr_poll()` iterates over all sockets, accepts new connections, sends and
-receives data, closes connections, and calls event handler functions for the
+receives data, closes connections and calls event handler functions for the
 respective events.

docs/design-concept/memory-buffers.md

@@ -2,13 +2,13 @@
 title: Memory buffers
 ---
 
-Each connection has send and receive buffer, `struct mg_connection::send_mbuf`
+Each connection has a send and receive buffer, `struct mg_connection::send_mbuf`
 and `struct mg_connection::recv_mbuf` respectively. When data arrives,
-Mongoose appends received data to the `recv_mbuf` and triggers `MG_EV_RECV`
-event. User may send data back by calling one of the output functions, like
+Mongoose appends received data to the `recv_mbuf` and triggers an `MG_EV_RECV`
+event. The user may send data back by calling one of the output functions, like
 `mg_send()` or `mg_printf()`. Output functions append data to the `send_mbuf`.
 When Mongoose successfully writes data to the socket, it discards data from
-`struct mg_connection::send_mbuf` and sends `MG_EV_SEND` event. When connection
-is closed, `MG_EV_CLOSE` event is sent.
+`struct mg_connection::send_mbuf` and sends an `MG_EV_SEND` event. When the connection
+is closed, an `MG_EV_CLOSE` event is sent.
 
 ![](media/mbuf.png)

docs/overview.md

@@ -3,16 +3,16 @@ title: Overview
 ---
 
 Mongoose is a swiss army knife for embedded network programming.
-It implements event-driven non-blocking API for TCP, UDP, HTTP,
-WebSocket, CoAP, MQTT for both client and server mode.
+It implements event-driven non-blocking APIs for TCP, UDP, HTTP,
+WebSocket, CoAP, MQTT for client and server mode.
 Features include:
 
 - Cross-platform: works on Linux/UNIX, MacOS, QNX, eCos, Windows, Android,
-  iPhone, FreeRTOS (TI CC3200, ESP8266), etc
+  iPhone, FreeRTOS (TI CC3200, ESP8266) and more
 - Single-threaded, asynchronous, non-blocking core with simple event-based API
 - Native support for [PicoTCP embedded TCP/IP stack](http://www.picotcp.com),
   [LWIP embedded TCP/IP stack](https://en.wikipedia.org/wiki/LwIP)
-- Builtin protocols:
+- Built-in protocols:
    - plain TCP, plain UDP, SSL/TLS (over TCP, one-way or two-way)
    - HTTP client and server
    - WebSocket client and server

docs/usage-example/intro.md

@@ -3,7 +3,7 @@ title: Usage Example
 ---
 
 - Copy `mongoose.c` and `mongoose.h` to your build tree
-- Write code that uses Mongoose API, e.g. in `my_app.c`
+- Write code that uses the Mongoose API, e.g. in `my_app.c`
 - Compile application: `$ cc my_app.c mongoose.c`
 
 ```c