src: NED files: enclose identifiers within comments in backquotes

Using _scripts/quote-identifiers-in-comments.py plus manual adjustments

src/inet/applications/generic/IpvxTrafGen.ned

@@ -8,13 +8,13 @@
 package inet.applications.generic;
 
 //
-// Sends IP or IPv6 datagrams to the given address at the given sendInterval.
-// The sendInterval can be a constant or a random value (e.g. exponential(1)).
-// If the destAddresses parameter contains more than one address, one
+// Sends IP or IPv6 datagrams to the given address at the given `sendInterval`.
+// The `sendInterval` can be a constant or a random value (e.g. exponential(1)).
+// If the `destAddresses` parameter contains more than one address, one
 // of them is randomly chosen for each packet. An address may be given in the
 // dotted decimal notation (or, for IPv6, in the usual notation with colons),
-// or with the module name. (The L3AddressResolver class is used to resolve
-// the address.) To disable the model, set destAddresses to "".
+// or with the module name. (The `L3AddressResolver` class is used to resolve
+// the address.) To disable the model, set `destAddresses` to "".
 //
 // The peer can be ~IpvxTrafSink or another ~IpvxTrafGen (it handles received packets
 // exactly like ~IpvxTrafSink).

src/inet/applications/netperfmeter/NetPerfMeter.ned

@@ -24,7 +24,7 @@ import inet.applications.contract.IApp;
 // Application model for comparing the performance of various transport
 // protocols.
 //
-// The NetPerfMeter model simultaneously transmits bidirectional flows to an
+// The ~NetPerfMeter model simultaneously transmits bidirectional flows to an
 // endpoint, and measures the resulting flow bandwidths and QoS. Since the
 // application behavior is the same for all underlying transport layer
 // protocols, it allows for comparing the performance of various transport

src/inet/applications/pingapp/PingApp.ned

@@ -14,24 +14,24 @@ import inet.applications.contract.IApp;
 // and calculates the packet loss and round trip times of the replies.
 // It works exactly like 'ping' except that it is possible to specify
 // several destination addresses as a space separated list of IP addresses
-// or module names. (The L3AddressResolver class is used to resolve the address.)
+// or module names. (The `L3AddressResolver` class is used to resolve the address.)
 // Specifying '*' allows pinging ALL configured network interfaces in the
 // whole simulation. This is useful to check if a host can reach ALL other
 // hosts in the network (i.e. routing tables were set up properly).
 //
-// Start/stop time, sendInterval etc. can be specified via parameters. An address
+// Start/stop time, `sendInterval` etc. can be specified via parameters. An address
 // may be given in the dotted decimal notation (or, for IPv6, in the usual
 // notation with colons), or with the module name.
-// (The L3AddressResolver class is used to resolve the address.)
+// (The `L3AddressResolver` class is used to resolve the address.)
 //
 // To specify the number of ping requests sent to a single destination address,
 // use the 'count' parameter. After the specified number of ping requests was
-// sent to a destination address, the application goes to sleep for 'sleepDuration'.
+// sent to a destination address, the application goes to sleep for `sleepDuration`.
 // Once the sleep timer has expired, the application switches to the next destination
 // and starts pinging again. The application stops pinging once all destination
-// addresses were tested or the simulation time reaches 'stopTime'.
+// addresses were tested or the simulation time reaches `stopTime`.
 //
-// To disable send, specify empty destAddr.
+// To disable send, specify empty `destAddr`.
 //
 // Every ping request is sent out with a sequence number, and replies are
 // expected to arrive in the same order. Whenever there's a jump in the

src/inet/applications/rtpapp/RtpApplication.ned

@@ -9,7 +9,7 @@
 package inet.applications.rtpapp;
 
 //
-// An application which uses RTP. It acts as a sender if the parameter fileName is
+// An application which uses RTP. It acts as a sender if the parameter `fileName` is
 // set, and as a receiver if the parameter is empty.
 //
 simple RtpApplication

src/inet/applications/tcpapp/TcpBasicClientApp.ned

@@ -20,7 +20,7 @@ import inet.applications.contract.IApp;
 // by messages of class ~GenericAppMsg.
 //
 // By default, reading from the socket is not rate limited. To allow rate
-// limiting, set autoRead=false, and use the readSize and readDelay parameters
+// limiting, set autoRead=false, and use the `readSize` and `readDelay` parameters
 // to set a rate limit. This will allow TCP flow control to come into effect.
 //
 // Compatible with both IPv4 (~Ipv4) and IPv6 (~Ipv6).

src/inet/applications/tcpapp/TcpClientSocketIo.ned

@@ -9,15 +9,15 @@ package inet.applications.tcpapp;
 
 //
 // This module opens a TCP connection to a given address and port and lets the
-// module connected to its trafficIn and trafficOut gates send and receive
-// data over that connection. When data is received on the trafficIn gate, it is
-// forwarded on the TCP connection via the socketOut gate, and vice versa. This
+// module connected to its `trafficIn` and `trafficOut` gates send and receive
+// data over that connection. When data is received on the `trafficIn` gate, it is
+// forwarded on the TCP connection via the `socketOut` gate, and vice versa. This
 // module simplifies the task of data exchange over a TCP connection. The TCP
-// connection is opened when the module first receives data on its trafficIn
+// connection is opened when the module first receives data on its `trafficIn`
 // gate.
 //
 // By default, reading from the socket is not rate limited. To allow rate
-// limiting, set autoRead=false, and use the readSize and readDelay parameters
+// limiting, set autoRead=false, and use the `readSize` and `readDelay` parameters
 // to set a rate limit. This will allow TCP flow control to come into effect.
 //
 // @see ~TcpServerSocketIo

src/inet/applications/tcpapp/TcpEchoApp.ned

@@ -9,16 +9,16 @@ package inet.applications.tcpapp;
 
 //
 // Accepts any number of incoming TCP connections, and sends back the data that
-// arrives on them. The echoFactor parameter controls the amount of data to be
+// arrives on them. The `echoFactor` parameter controls the amount of data to be
 // sent back. If echoFactor==1, the received data is echoed back without change.
-// For any other positive value of echoFactor, a message of appropriate length
-// (datalen*echoFactor) without content (see ByteCountChunk C++ class) is sent
+// For any other positive value of `echoFactor`, a message of appropriate length
+// (datalen*`echoFactor`) without content (see `ByteCountChunk` C++ class) is sent
 // back.
 //
-// The reply can also be delayed by a constant time (echoDelay parameter).
+// The reply can also be delayed by a constant time (`echoDelay` parameter).
 //
 // By default, reading from the socket is not rate-limited. To allow rate
-// limiting, set autoRead=false, and use the readSize and readDelay parameters
+// limiting, set autoRead=false, and use the `readSize` and `readDelay` parameters
 // to set a rate limit. This will allow TCP flow control to come into effect.
 //
 // Compatible with both ~Ipv4 and ~Ipv6.

src/inet/applications/tcpapp/TcpGenericServerApp.ned

@@ -19,11 +19,11 @@ import inet.applications.contract.IApp;
 // large the reply should be (number of bytes). For each received
 // ~GenericAppMsg, ~TcpGenericServerApp will create another ~GenericAppMsg with
 // the requested length as a response and send it back. The reply can be delayed
-// by a constant time (replyDelay parameter).
+// by a constant time (`replyDelay` parameter).
 //
 // By default, the server does not impose rate limiting on data reads from the
-// socket. To enable rate limiting, you can set "autoRead" to "false" and
-// configure the "readSize" and "readDelay" parameters, thereby facilitating TCP
+// socket. To enable rate limiting, you can set `autoRead` to "false" and
+// configure the `readSize` and `readDelay` parameters, thereby facilitating TCP
 // flow control.
 //
 // Compatible with both ~Ipv4 and ~Ipv6.

src/inet/applications/tcpapp/TcpServerHostApp.ned

@@ -13,12 +13,12 @@ import inet.applications.contract.IApp;
 // This module hosts TCP-based server applications. It dynamically creates
 // and launches a new "thread" object for each incoming connection.
 //
-// Server threads should be subclassed from the TcpServerThreadBase
+// Server threads should be subclassed from the `TcpServerThreadBase`
 // C++ class, registered in the C++ code using the Define_Module() macro,
-// and the module type should be specified in the serverThreadModuleType
+// and the module type should be specified in the `serverThreadModuleType`
 // parameter of ~TcpServerHostApp. The thread object will receive events
-// via a callback interface (methods like established(), dataArrived(),
-// peerClosed(), timerExpired()), and can send packets via TcpSocket's send()
+// via a callback interface (methods like established(), `dataArrived()`,
+// `peerClosed()`, `timerExpired()`), and can send packets via `TcpSocket`'s send()
 // method.
 //
 // Compatible with both ~Ipv4 and ~Ipv6.

src/inet/applications/tcpapp/TcpServerListener.ned

@@ -16,10 +16,10 @@ import inet.applications.contract.IApp;
 // will be appended to the connection[] submodule array of the parent of
 // this module, i.e., they will be siblings of this module.
 //
-// Accepted TCP connections will inherit the autoRead setting of this module. To
+// Accepted TCP connections will inherit the `autoRead` setting of this module. To
 // allow rate limiting on the connections, set autoRead=false here, and use
-// corresponding parameters of the connection handling module (e.g., readSize and
-// readDelay) to set a rate limit. This will allow TCP flow control to come into
+// corresponding parameters of the connection handling module (e.g., `readSize` and
+// `readDelay`) to set a rate limit. This will allow TCP flow control to come into
 // effect.
 //
 // @see ~TcpServerApp, ~TcpServerConnection

src/inet/applications/tcpapp/TcpServerSocketIo.ned

@@ -9,14 +9,14 @@ package inet.applications.tcpapp;
 
 //
 // Manages an established TCP connection. It handles data transmission to and
-// from a module connected via the trafficIn and trafficOut gates. When data is
-// received on the trafficIn gate, it is forwarded on the TCP connection via the
-// socketOut gate, and vice versa. This module simplifies the task of data
+// from a module connected via the `trafficIn` and `trafficOut` gates. When data is
+// received on the `trafficIn` gate, it is forwarded on the TCP connection via the
+// `socketOut` gate, and vice versa. This module simplifies the task of data
 // exchange over an established TCP connection.
 //
 // Note that reading from the socket is only rate limited if the connection was
 // originally created with the autoRead=false setting. Then, you can use the
-// readSize and readDelay parameters to set a rate limit. This will allow TCP
+// `readSize` and `readDelay` parameters to set a rate limit. This will allow TCP
 // flow control to come into effect.
 //
 // @see ~TcpServerConnection, ~TcpServerListener, ~TcpClientSocketIo

src/inet/applications/tcpapp/TcpSessionApp.ned

@@ -20,57 +20,57 @@ import inet.applications.contract.IApp;
 //
 // Regarding the type of opening the connection, the application may
 // be either a client or a server. When active=false, the application
-// will listen on the given local localPort, and wait for an incoming connection.
-// When active=true, the application will bind to the given localAddress:localPort,
-// and connect to the connectAddress:connectPort. To use an ephemeral port
-// as local port, set the localPort parameter to -1.
+// will listen on the given local `localPort`, and wait for an incoming connection.
+// When active=true, the application will bind to the given `localAddress:localPort`,
+// and connect to the `connectAddress:connectPort`. To use an ephemeral port
+// as local port, set the `localPort` parameter to -1.
 //
 // Even when in server mode (active=false), the application will only
 // serve one incoming connection. Further connect attempts will be
 // refused by TCP (it will send RST) for lack of LISTENing connections.
 //
-// The time of opening the connection is in the tOpen parameter.
+// The time of opening the connection is in the `tOpen` parameter.
 //
 // <b>Sending data</b>
 //
 // Regardless of the type of OPEN, the application can be made to send
-// data. One way of specifying sending is via the tSend, sendBytes
-// parameters, the other way is with sendScript. With the former, sendBytes
-// bytes will be sent at tSend. With sendScript, the format is
+// data. One way of specifying sending is via the `tSend`, `sendBytes`
+// parameters, the other way is with `sendScript`. With the former, `sendBytes`
+// bytes will be sent at `tSend`. With `sendScript`, the format is
 // "<time> <numBytes>;<time> <numBytes>;..."
 //
 // <b>Closing the connection</b>
 //
-// The application will issue a TCP CLOSE at time tClose. If tClose=-1, no
+// The application will issue a TCP CLOSE at time `tClose`. If tClose=-1, no
 // CLOSE will be issued.
 //
 // <b>Reception rate limiting</b>
 //
 // By default, reading from the socket is not rate limited. To allow rate
-// limiting, set autoRead=false, and use the readSize and readDelay parameters
+// limiting, set autoRead=false, and use the `readSize` and `readDelay` parameters
 // to set a rate limit. This will allow TCP flow control to come into effect.
 //
 // <b>Configuring the App</b>
 //
-// Currently you have three dataTransferMode choices:
+// Currently you have three `dataTransferMode` choices:
 //
 //   -# Set them to "bytecount".
 //      This mode manages "virtual bytes", that is, only byte counts are
-//      transmitted over the TCP connection and no actual data. cMessage
+//      transmitted over the TCP connection and no actual data. `cMessage`
 //      contents, and even message boundaries are not preserved with these
-//      classes: for example, if the client sends a single cMessage with
+//      classes: for example, if the client sends a single `cMessage` with
 //      length = 1 megabyte over TCP, the receiver-side client will see a
 //      sequence of MSS-sized messages.
 //
 //   -# Use "object", which transmits
-//      cMessage objects (and subclasses) over a TCP connection. The same
+//      `cMessage` objects (and subclasses) over a TCP connection. The same
 //      message object sequence that was sent by the client to the
 //      sender-side TCP entity will be reproduced on the receiver side.
-//      If a client sends a cMessage with length = 1 megabyte, the
+//      If a client sends a `cMessage` with length = 1 megabyte, the
 //      receiver-side client will receive the same message object (or a clone)
 //      after the TCP entities have completed simulating the transmission
 //      of 1 megabyte over the connection. This is a different behavior
-//      from TCPVirtualDataSendQueue/RcvQueue.
+//      from `TCPVirtualDataSendQueue`/`RcvQueue`.
 //      This mode is not implemented in ~TcpNsc yet.
 //
 //   -# Use "bytestream", which transmits real bytes of messages.

src/inet/applications/tcpapp/TcpSinkApp.ned

@@ -15,7 +15,7 @@ package inet.applications.tcpapp;
 // which allows collecting per-connection statistics in a convenient way.
 //
 // By default, reading from the socket is not rate limited. To allow rate
-// limiting, set autoRead=false, and use the readSize and readDelay parameters
+// limiting, set autoRead=false, and use the `readSize` and `readDelay` parameters
 // to set a rate limit. This will allow TCP flow control to come into effect.
 //
 module TcpSinkApp extends TcpServerHostApp

src/inet/applications/tcpapp/TelnetApp.ned

@@ -21,7 +21,7 @@ import inet.applications.contract.IApp;
 // write your model accordingly.
 //
 // By default, reading from the socket is not rate limited. To allow rate
-// limiting, set autoRead=false, and use the readSize and readDelay parameters
+// limiting, set autoRead=false, and use the `readSize` and `readDelay` parameters
 // to set a rate limit. This will allow TCP flow control to come into effect.
 //
 simple TelnetApp like IApp

src/inet/applications/udpapp/UdpBasicApp.ned

@@ -14,16 +14,16 @@ import inet.applications.contract.IApp;
 // Compatible with both ~Ipv4 and ~Ipv6.
 //
 // The sending interval can be a constant or a random value (e.g. exponential(1)).
-// If the destAddresses parameter contains more than one address, one
+// If the `destAddresses` parameter contains more than one address, one
 // of them is randomly chosen for each packet. An address may be given in the
-// dotted decimal notation, or with the module name. (The L3AddressResolver
+// dotted decimal notation, or with the module name. (The `L3AddressResolver`
 // class is used to resolve the address.) To disable the model, set
-// destAddresses to "".
+// `destAddresses` to "".
 //
 // Received packets are discarded.
 //
 // The peer can be a ~UdpSink, another ~UdpBasicApp (it handles received packets
-// like ~UdpSink), or a ~UdpEchoApp. When used with ~UdpEchoApp, the rcvdPkLifetime
+// like ~UdpSink), or a ~UdpEchoApp. When used with ~UdpEchoApp, the `rcvdPkLifetime`
 // statistic will contain the round-trip times.
 //
 simple UdpBasicApp like IApp