Memory layout of a data structure

From Rosetta Code
Task
Memory layout of a data structure
You are encouraged to solve this task according to the task description, using any language you may know.

It is often useful to control the memory layout of fields in a data structure to match an interface control definition, or to interface with hardware. Define a data structure matching the RS-232 Plug Definition. Use the 9-pin definition for brevity.

Pin Settings for Plug
(Reverse order for socket.)
__________________________________________
1  2  3  4  5  6  7  8  9  10 11 12 13
 14 15 16 17 18 19 20 21 22 23 24 25
_________________
1  2  3  4  5
6  7  8  9
25 pin                        9 pin
1 - PG   Protective ground
2 - TD   Transmitted data     3
3 - RD   Received data        2
4 - RTS  Request to send      7
5 - CTS  Clear to send        8
6 - DSR  Data set ready       6
7 - SG   Signal ground        5
8 - CD   Carrier detect       1
9 - + voltage (testing)
10 - - voltage (testing)
11 -
12 - SCD  Secondary CD
13 - SCS  Secondary CTS
14 - STD  Secondary TD
15 - TC   Transmit clock
16 - SRD  Secondary RD
17 - RC   Receiver clock
18 -
19 - SRS  Secondary RTS            
20 - DTR  Data terminal ready      4
21 - SQD  Signal quality detector
22 - RI   Ring indicator           9
23 - DRS  Data rate select
24 - XTC  External clock
25 -

6502 Assembly[edit]

soft_rs232_lo equ $20 ;%87654321
soft_rs232_hi equ $21 ;%-------9

The values $20 and $21 do not matter; any zero page memory location is acceptable. The comments explain which bit position represents which pin, written in the format one would write a binary literal in the assembler. A "-" means that particular bit is unused.

This example non-destructively writes a "1" to pin 3:

LDA soft_rs232_lo
ora #%00000100
sta soft_rs232_lo

The common practice is to have "soft" ports in zero page which get written to the memory-mapped location of the actual hardware interface by only a single subroutine that is run at a fixed interval. All other routines only ever update the "soft" port. (Hardware ports such as this example are typically write-only so the only way to non-destructively write to individual bits is through this indirect method.)

68000 Assembly[edit]

Thanks to the low-level nature of assembly, this task is actually rather straightforward. Using equ directives we can easily abstract the bit numbers with convenient labels without having to remember what they are.

BIT_0 equ $1
BIT_1 equ $2
BIT_2 equ $4
BIT_3 equ $8
BIT_4 equ $10
BIT_5 equ $20
BIT_6 equ $40
BIT_7 equ $80

BIT_8 equ $100
BIT_9 equ $200

RS232_9_TD equ BIT_3
RS232_9_RD equ BIT_2
RS232_9_RTS equ BIT_7
RS232_9_CTS equ BIT_8
RS232_9_DSR equ BIT_6
RS232_9_SG equ BIT_5
RS232_9_CD equ BIT_1

With these aliases defined, we can easily write these constants, or any combination thereof, to the memory-mapped RS232 port.

(Disclaimer: I have no idea how this protocol actually works. So there's a good chance that these values should not be combined this way when working with actual RS232 hardware. But that's not really important to this task. I'm just showing how you can define constants and write them to the port.)

rs232_9pin_port equ $A00000             
;I chose $A00000 arbitrarily as an example, its actual address depends on the wiring.

MOVE.W #RS232_9_CTS,rs232_9pin_port   
MOVE.W #RS232_9_CTS|RS232_9_RD|RS232_9_SG,rs232_9pin_port  ;bitwise OR can be used at compile time to combine the labels.


Ada[edit]

type Bit is mod 2;
type Rs_232_Layout is record
   Carrier_Detect      : Bit;
   Received_Data       : Bit;
   Transmitted_Data    : Bit;
   Data_Terminal_ready : Bit;
   Signal_Ground       : Bit;
   Data_Set_Ready      : Bit;
   Request_To_Send     : Bit;
   Clear_To_Send       : Bit;
   Ring_Indicator      : Bit;
end record;

for Rs_232_Layout use record
   Carrier_Detect      at 0 range 0..0;
   Received_Data       at 0 range 1..1;
   Transmitted_Data    at 0 range 2..2;
   Data_Terminal_Ready at 0 range 3..3;
   Signal_Ground       at 0 range 4..4;
   Data_Set_Ready      at 0 range 5..5;
   Request_To_Send     at 0 range 6..6;
   Clear_To_Send       at 0 range 7..7;
   Ring_Indicator      at 0 range 8..8;
end record;

ALGOL 68[edit]

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d
MODE RSTWOTHREETWO = BITS;
INT ofs = bits width - 9;
INT 
   lwb rs232           = ofs + 1,
   carrier detect      = ofs + 1,
   received data       = ofs + 2,
   transmitted data    = ofs + 3,
   data terminal ready = ofs + 4,
   signal ground       = ofs + 5,
   data set ready      = ofs + 6,
   request to send     = ofs + 7,
   clear to send       = ofs + 8,
   ring indicator      = ofs + 9,
   upb rs232           = ofs + 9;
 
RSTWOTHREETWO rs232 bits := 2r10000000; # up to bits width, OR #
print(("received data: ",received data ELEM rs232bits, new line));

rs232 bits := bits pack((FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE));
print(("received data: ",received data ELEM rs232bits, new line))

Output:

received data: T
received data: T

C/C++[edit]

Note: The order of the fields is implementation-defined (i.e. the first bit might be the least-significant one or the most-significant one). On GCC and MSVC++, the first bit is the least-significant one.

struct RS232_data
{
  unsigned carrier_detect        : 1;
  unsigned received_data         : 1;
  unsigned transmitted_data      : 1;
  unsigned data_terminal_ready   : 1;
  unsigned signal_ground         : 1;
  unsigned data_set_ready        : 1;
  unsigned request_to_send       : 1;
  unsigned clear_to_send         : 1;
  unsigned ring_indicator        : 1;
};

The ":1" gives the number of allocated bits. For unused bits (e.g. pin 11 in the 25-pin version above) the field name can be omitted.

Since as stated before the order of bits can't be assured but it could be important if we need to interact with hardware, the best way is to define bit masks; of course actual writing/reading to/from an hardware "register" greater than a single byte must be done taking care of endianness.

D[edit]

Tango version[edit]

Implementation uses tango's BitArray structure.

Library: tango
module controlFieldsInStruct;

import tango.core.BitArray;
import tango.io.Stdout;
import tango.text.convert.Integer;

class RS232Wrapper(int Length = 9)
{
    static assert(Length == 9 || Length == 25, "ERROR, wrong type");
    BitArray ba; 
    static uint[char[]] _map;
 
    public:

    static if (Length == 9) {
        static this() {
            _map = [ cast(char[])
                "CD"  : 1, "RD"  : 2, "TD"  : 3, "DTR" : 4, "SG"  : 5,
                "DSR" : 6, "RTS" : 7, "CTS" : 8, "RI"  : 9 
            ];  
        }   
    } else {
        static this() {
            _map = [ cast(char[])
                "PG"  : 1u, "TD"  :  2, "RD"  :  3, "RTS" :  4, "CTS" :  5,  
                "DSR" :  6, "SG"  :  7, "CD"  :  8, "+"   :  9, "-"   : 10, 
                "SCD" : 12, "SCS" : 13, "STD" : 14, "TC"  : 15, "SRD" : 16, 
                "RC"  : 17, "SRS" : 19, "DTR" : 20, "SQD" : 21, "RI"  : 22, 
                "DRS" : 23, "XTC" : 24
            ];  
        }   
    }   


    this() {
        ba.length = Length;
    }   

    bool opIndex(uint pos) { return ba[pos]; }
    bool opIndexAssign(bool b, uint pos) { return (ba[pos] = b); }
    bool opIndex(char[] name) {
        assert (name in _map, "don't know that plug: " ~ name);
        return opIndex(_map[name]);
    }   
    bool opIndexAssign(bool b, char[] name) {
        assert (name in _map, "don't know that plug: " ~ name);
        return opIndexAssign(b, _map[name]);
    }   
    void opSliceAssign(bool b) { foreach (ref r; ba) r = b; }
    char[] toString() {
        char[] ret = "[";
        foreach (name, value; _map)
            ret ~= name ~ ":" ~ (ba[value]?"1":"0") ~", ";
        ret ~= "]";
        return ret;
    }   
}

int main(char[][] args)
{
    auto ba = new RS232Wrapper!(25);

    // set all bits
    ba[] = 1;
    ba["RD"] = 0;
    ba[5] = 0;

    Stdout (ba).newline;

    return 0;
}

Output:

[RD:0, RI:1, DSR:1, SG:1, DTR:1, TC:1, TD:1, CD:1, SQD:1, +:1, -:1, SRD:1, RTS:1, SRS:1, STD:1, PG:1, SCD:1, CTS:0, DRS:1, SCS:1, XTC:1, RC:1 ]

Phobos version[edit]

Not tested.

import std.bitmanip;

struct RS232_data {
    static if (std.system.endian == std.system.Endian.bigEndian) {
        mixin(bitfields!(bool, "carrier_detect",      1,
                         bool, "received_data",       1,
                         bool, "transmitted_data",    1,
                         bool, "data_terminal_ready", 1,
                         bool, "signal_ground",       1,
                         bool, "data_set_ready",      1,
                         bool, "request_to_send",     1,
                         bool, "clear_to_send",       1,
                         bool, "ring_indicator",      1,
                         bool, "",                    7));
    } else {
        mixin(bitfields!(bool, "",                    7,
                         bool, "ring_indicator",      1,
                         bool, "clear_to_send",       1,
                         bool, "request_to_send",     1,
                         bool, "data_set_ready",      1,
                         bool, "signal_ground",       1,
                         bool, "data_terminal_ready", 1,
                         bool, "transmitted_data",    1,
                         bool, "received_data",       1,
                         bool, "carrier_detect",      1));
    }

    static assert(RS232_data.sizeof == 2);
}

void main() {}

Forth[edit]

Low level hardware control is a typical use of Forth. None of this is standard, however, since hardware I/O mechanisms differ on different systems. Forth does not have a structure mechanism, much less bitfields. These would be represented instead via bitmask constants if doing real serial port control.

 : masks ( n -- ) 0 do 1 i lshift constant loop ;
 
 9 masks DCD RxD TxD DTR SG DSR RTS CTS RI

Example usage, assuming I/O primitives in and out:

 hex
 3fd constant com1-ctrl
 decimal
 
 : wait-ready
   begin
     com1-ctrl in
     CTS and
   until ;
 : wait-rx
   begin
     com1-ctrl in
     CTS and 0=
   until ;
 
 : send-byte ( b -- )   \ send assuming N81 (no parity, 8 bits data, 1 bit frame)
   255 and
   9 0 do
     RTS com1-ctrl out
     wait-ready
     dup 1 and if TxD else 0 then com1-ctrl out
     wait-rx
     2/
   loop drop ;

Of course, this is a very simplified view of the full RS-232 protocol. Also, although this represents the order of the pins in a D-9 connector, this would not necessarily be the same as the order of the bits in a control register.

Fortran[edit]

Modern[edit]

F90 introduced the ability to define compound data aggregates, as had been used from the start by COBOL in the 1960s. Thus, one could define
       TYPE RS232PIN9
        LOGICAL CARRIER_DETECT		!1
        LOGICAL RECEIVED_DATA		!2
        LOGICAL TRANSMITTED_DATA	!3
        LOGICAL DATA_TERMINAL_READY	!4
        LOGICAL SIGNAL_GROUND		!5
        LOGICAL DATA_SET_READY		!6
        LOGICAL REQUEST_TO_SEND		!7
        LOGICAL CLEAR_TO_SEND		!8
        LOGICAL RING_INDICATOR		!9
       END TYPE RS232PIN9

But it would be nearly pointless to do so.

Fortran's LOGICAL type is defined to occupy as much space as the default INTEGER type, which is typically thirty-two bits. This was done to simplify questions of storage size for large collections of assorted types of variables in a COMMON storage area. Further, true and false may not be signified by 1 and 0 but by -1 and 0, or, something else. Many compilers continue to support the old-style storage size indications that were introduced for binary computers and so would allow LOGICAL*1, but alas, this does not mean one bit, it means one byte. There is no equivalent of a key word PACKED (as in Pascal for example) whereby it might be indicated that a collection of items are to be stored "adjacent" and not aligned to byte or word boundaries. But, without a storage type equivalent to BIT(1) such as pl/i offers, this won't help either. Such packing can make reading or writing to a variable quite difficult - imagine a 32-bit integer variable offset by three bits - which is why some languages offer the keyword ALIGNED.

However, all is not quite lost. Given that one can access the special storage word containing the status of the nine-pin socket, presumably returning what can be regarded as a thirty-two bit integer (to accommodate a 25-pin socket), then, given certain knowledge of the ordering of the pins versus the bits of the integer (are bits counted from left-to-right or right-to-left, starting at one or at zero?), and certain knowledge that the nine bits are at the high-order end of the word or at the low-order end of the word (the IBM 1130's card reader placed the image of a column of a card, twelve bits, at the high-order end of its sixteen-bit word), it would be merely a matter of tedium to unpack those bits with suitable expressions and place the appropriate values into the components of a variable of type RS232PIN9. Such variables can then be juggled in the usual way, for instance using NAMELIST style I/O whereby the values are presented along with the names of the variables holding them. For output, this could be achieved with suitable FORMAT statements.

There may be available library functions IAND(i,j) and IOR(i,j) for dealing with integer variables, otherwise it becomes a matter of integer arithmetic. Unpacking or re-packing a data structure (say, as found in a disc file record) is straightforward but tedious, and, aside from the sizes and types of the components one must have definite knowledge of the endianness of the data as in the aggregate (read from disc) compared to the endianness of the cpu running your procedure. Easiest is of course to have the same style cpu for both.

Older style[edit]

Without the ability to create data aggregates via TYPE statements, whereby a single variable might sprawl across memory as above, one instead prepared a collection of variables, usually with some systematic name convention linking the names of the parts. These variables would be anywhere in memory and so had no particular memory layout in themselves. However, when stored as a record in a disc file a data structure is created with a definite layout, and this is manifest in the READ and WRITE statements involved. Suppose the statement was WRITE (F,REC = n) THIS,M,NAME meaning that the n'th record of file unit F was to be written. The types of the variables would be known, and their sizes also. Say REAL*8 THIS, INTEGER*1 M, and CHARACTER*28 NAME. Such a record could be read (or written) by READ (F,REC = n) STUFF given a declaration CHARACTER*37 STUFF (counting on fingers as necessary) and the various parts of the data aggregate could be indexed within STUFF. However, the interpretation of the interior bytes of multi-byte items such as integer and floating-point variables is complicated by the endianness of the processor, a confounding nuisance.

It is further possible to declare that STUFF is to occupy the same storage as the named variables. If the declaration was CHARACTER*1 STUFF(37), then EQUIVALENCE (STUFF(1),THIS),(STUFF(9),M),(STUFF(10),NAME) would mean that STUFF occupied the same storage as those variables, or rather, that the variables occupied the same storage as STUFF - indeed, they could overlay each other, which would be unlikely to be helpful. This could mean that a floating-point or integer variable was not aligned to a word boundary with the consequent penalty in access, for instance by having THIS start with STUFF(2) because M was put first. Some systems may not allow byte-based addressing, only word-based so complications can arise. But this demonstrates precise knowledge of the memory layout of a data structure. The more modern compilers that allow the TYPE declaration typically do not allow the appearance of such variables in EQUIVALENCE statements, to prevent access to the memory layout of such data structures. Others allow a new version of EQUIVALENCE (which the moderns deprecate) via the MAP statement, but this is not standard Fortran.

As before stated, there is no BIT facility, so packing is to byte boundaries. But, if one is determined to store thousands of records with minimal storage use, it may seem worth the effort to engage in the arithmetic to pack the likes of say three bits, followed by the thirty-two bits of a floating-point value, and so on, into a sequence of bytes which then would be written. In such a situation it may even be worth packing only a portion of the floating-point variable, if reduced precision is acceptable and one is certain of the usage of the bits within such a number. However, given the difficulty of access to the parts of such a packed aggregate, it is usually better to leave the byte/word packing and unpacking to the I/O system as via WRITE (F,REC = n) THIS,M,NAME and then manipulate the variables as their conveniently-aligned in-memory forms as ordinary variables, only repacking to the data structure form with a subsequent WRITE statement.

The INTEGER*n opportunity is not fully flexible in that powers of two are usually the only options so that a value that might fit into INTEGER*3 will have to go into INTEGER*4. In any case this style is not helpful for decimal machines or binary computers whose word size is not a power of two. It is possible to break away from a byte base, especially when there are many variables with small ranges to represent. Suppose that V3 only has values 0, 1, 2; V5 has only 0, 1, 2, 3, 4; V4 only 0, 1, 2, 3; and V2 only 0, 1. Then a set of values could be encoded as a single decimal number: say 1230 for the four variables in that order, which would fit into a two byte integer instead of four one byte integers. That is merely changing base 256 to base 10, notionally, but a better packing is possible, Consider V = V3 + 3*(V5 + 5*(V4 + 4*(V2))) whose maximum value would be 2 + 3*(4 + 5*(3 + 4*1)) = 119, which will fit into one byte. If there were many such variables, then their packed values might require larger integers for even greater sharing. Variables with fractional values can be treated in a similar way, cautiously...

With careful planning, such a compound value may even have helpful numerical properties, of service for (some) multi-key sorts. In the example, V2 is the high-order value so if a desired sort key happened to include V2, V4, V5, V3 then a four-variable comparison could be done in just one test. Unless the value overflows into the sign bit. This may not be a problem if the sorted order is merely to facilitate a binary search that will use the same ordering, but there can still be surprises. The B6700 used a 48-bit word and its compiler did not offer the then-unknown CHARACTER type. One might store six eight-bit characters in a word without worrying over the ordering that will result - the B6700 had no integer representation as such, using floating-point numbers with no fractional part, so the numerical values resulting from character codes would be quite odd. However, it also worked in base eight and although forty-eight is divisible by three, the requirement for the sign of the exponent and the sign of the value uses only two bits. Thus, one bit, the topmost, did not participate in arithmetic operations and as a result, arithmetic could not distinguish between characters in the high end of a word that differed in their highest bit. Even .EQ. would fail and the compiler offered a special substitute, .IS. to test for equality. Other languages that offered character manipulation (such as the extensions to Algol) used entirely different methods that avoided this problem.

In a similar way, text content may employ only a limited character set so perhaps five bits per symbol would suffice, or some other packing scheme might suggest itself. There is also a whole world of compression algorithms. The end result is that a data structure manifesting as records in a disc file may be difficult to unpack into a convenient internal form even given a careful description of the layout.

Free Pascal[edit]

The FPC (Free Pascal compiler) carefully defines the internal memory structure of data type in its “Programmer’s guide”.

program rs232(input, output, stdErr);
type
	{$packEnum 2}{$scopedEnums off}
	pin = (carrierDetect, receivedData, transmittedData, dataTerminalReady,
		signalGround, dataSetReady, requestToSend, clearToSend, ringIndicator);
	{$packSet 2}
	pins = set of pin;
var
	signal: pins;
	// for demonstration purposes, in order to reveal the memory layout
	signalMemoryStructure: word absolute signal;
	{$if sizeOf(signal) <> sizeOf(word)} // just as safe-guard
		{$fatal signal size}
	{$endIf}
begin
	signal := [];
	include(signal, signalGround); // equivalent to signal := signal + [signalGround];
	// for demonstration purposes: obviously we know this is always `true`
	if signalGround in signal then
	begin
		writeLn(binStr(signalMemoryStructure, bitSizeOf(signal)));
	end;
end.
Output:
0000000000010000

FreeBASIC[edit]

' FB 1.05.0 Win64

' using bit fields
Type RS232_Pin9
  carrierDetect     : 1 As UByte 
  receivedData      : 1 As UByte 
  transmittedData   : 1 As UByte
  dataTerminalReady : 1 As UByte
  signalGround      : 1 As UByte
  dataSetReady      : 1 As UByte
  requestToSend     : 1 As UByte
  clearToSend       : 1 As UByte
  ringIndicator     : 1 As UByte
End Type

Print SizeOf(RS232_Pin9)  '' 2 bytes
Sleep

Go[edit]

Go does not have named bits as part of the type system. Instead, constants are typically defined as shown. For a word of bits with special meanings like this, a type would be defined though, as shown. Static typing rules then control assignments and comparisons at the word level. At the bit level, it helps to follow naming conventions so that, say, using a 9-pin constant on a 25-pin word would be an obvious error in the source code.

package main

import "fmt"

type rs232p9 uint16

const (
	CD9  rs232p9 = 1 << iota // Carrier detect
	RD9                      // Received data
	TD9                      // Transmitted data
	DTR9                     // Data terminal ready
	SG9                      // signal ground
	DSR9                     // Data set ready
	RTS9                     // Request to send
	CTS9                     // Clear to send
	RI9                      // Ring indicator
)

func main() {
	// set some nonsense bits just for example
	p := RI9 | TD9 | CD9
	fmt.Printf("Type=%T value=%#04x\n", p, p)
}
Output:
Type=main.rs232p9 value=0x0105

J[edit]

J does not support "structures", nor "fields in a structure". Instead, J supports arrays. And, of course, J could have labels corresponding to the elements of an array representing the state (voltage, current, logical bit value, whatever) of each pin of a 9-pin RS-232 plug:

default=: 0#~#|:'labels comments'=:|:(4 ({.@;:@{. ; }.)]);._2 {{)n
RD   Received data
TD   Transmitted data
DTR  Data terminal ready
SG   Signal ground
DSR  Data set ready
RTS  Request to send
CTS  Clear to send
RI   Ring indicator
}}

indices=: labels (i. ;: ::]) ]
ndx=: [ {~ [ indices ]
asgn=: {{ y (x indices m)} x }}

Example use:

      example=: default NB. new instance
      example ndx 'RI CTS'
0 0
      example=: example 'RI RTS TD' asgn 1 2 3
      example ndx 'RI CTS'
1 0

Julia[edit]

If the nine-pin version of the serial port is as specified above:

1  2  3  4  5
6  7  8  9
                        9 pin
PG   Protective ground
TD   Transmitted data     3
RD   Received data        2
RTS  Request to send      7
CTS  Clear to send        8
DSR  Data set ready       6
SG   Signal ground        5
CD   Carrier detect       1
+ voltage (testing)

We can then make the following code for a new serial port type:

mutable struct NinePinSerialPort
    pins::BitArray
    function NinePinSerialPort()
        this = new()
        this.pins = BitArray(9)
    end
end

const CD = 1
const RD = 2
const TD = 3
const SG = 5
const DSR = 6
const RTS = 7
const CTS = 8

# Here we test the type's code.
port = NinePinSerialPort()
println("Port is now at defaults, which are $port")
port[CTS] = true
println("CD pin of port, which is pin $CD, is now $(port[CD])")
println("CTS pin of port, which is pin $CTS, is now $(port[CTS])")
println("port is now: $port")
Output:
Port is now at defaults, which are Bool[false, false, false, false, false, false, false, false, false]
CD pin of port, which is pin 1, is now false
CTS pin of port, which is pin 8, is now true
port is now: Bool[false, false, false, false, false, false, false, true, false]

Kotlin[edit]

If it were only desired to access pin settings by position (albeit starting from pin 0 rather than pin 1), then a java.util.BitSet could be used to model this task.

However, if access by both position and name is required, then a data class with 9 named boolean properties would be more suitable. This automatically generates functions called component1, component2 etc. to get the pin values by pin number. However, a function needs to be written manually to set pin values by pin number:

// version 1.0.6

const val OFF = false
const val ON  = true

fun toOnOff(b: Boolean) = if (b) "ON" else "OFF"

data class Rs232Pins9(
    var carrierDetect     : Boolean = OFF,
    var receivedData      : Boolean = OFF,
    var transmittedData   : Boolean = OFF,
    var dataTerminalReady : Boolean = OFF,
    var signalGround      : Boolean = OFF,
    var dataSetReady      : Boolean = OFF,
    var requestToSend     : Boolean = OFF,
    var clearToSend       : Boolean = OFF,
    var ringIndicator     : Boolean = OFF
) {
    fun setPin(n: Int, v: Boolean) {
        when (n) {
            1 -> carrierDetect     = v
            2 -> receivedData      = v
            3 -> transmittedData   = v
            4 -> dataTerminalReady = v
            5 -> signalGround      = v  
            6 -> dataSetReady      = v
            7 -> requestToSend     = v
            8 -> clearToSend       = v
            9 -> ringIndicator     = v   
        }
    }
}

fun main(args: Array<String>) {
    val plug = Rs232Pins9(carrierDetect = ON, receivedData = ON) // set first two pins, say
    println(toOnOff(plug.component2()))                          // print value of pin 2 by number
    plug.transmittedData = ON                                    // set pin 3 by name
    plug.setPin(4, ON)                                           // set pin 4 by number
    println(toOnOff(plug.component3()))                          // print value of pin 3 by number
    println(toOnOff(plug.dataTerminalReady))                     // print value of pin 4 by name 
    println(toOnOff(plug.ringIndicator))                         // print value of pin 9 by name
}
Output:
ON
ON
ON
OFF

MATLAB / Octave[edit]

Defining structs in MATLAB is kind of bulky, making a class definition might be cleaner for this purpose. If you need to enumerate each pin rather than set the state of the pin using the name of the pin, you can use struct2cell() on the rs232 struct, which will return a cell array whose entries are the value of each of the structs fields in the order in which they were defined.

>> rs232 = struct('carrier_detect', logical(1),...
'received_data' , logical(1), ...
'transmitted_data', logical(1),...
'data_terminal_ready', logical(1),...
'signal_ground', logical(1),...
'data_set_ready', logical(1),...
'request_to_send', logical(1),...
'clear_to_send', logical(1),...
'ring_indicator', logical(1))

rs232 = 

         carrier_detect: 1
          received_data: 1
       transmitted_data: 1
    data_terminal_ready: 1
          signal_ground: 1
         data_set_ready: 1
        request_to_send: 1
          clear_to_send: 1
         ring_indicator: 1

>> struct2cell(rs232)

ans = 

    [1]
    [1]
    [1]
    [1]
    [1]
    [1]
    [1]
    [1]
    [1]

Mercury[edit]

Mercury does not have data types that mark down to individual bits. Instead it allows you to use symbolic names (as per the rs232_pin type definition below with its constructors like carrier_detect) and to easily map those names to a value if you so choose (as per the to_index/1 function below).

This is, admittedly, more verbose than the equivalent code would be in, say, C, but it permits things which are more difficult to pull off in such languages. First, the code here is perfectly type safe (despite the use of unsafe_set and unsafe_clear). It is literally impossible to set or clear bits outside of the bounds of the bit array used in the physical representation. It is as easy to set and clear individual bits in the bit array as it is to use bit notation in C, and it's easier to do than when using the safer "integer variable with bitwise operators" technique. Setting and clearing groups of bits is even easier via the rs232_set_bits/2 function: merely pass in a list of symbolic names. Changing the bitwise representation is a matter of changing the bit numbers in to_index/1 and possibly changing the size of the bit array in rs232_bits/1. Indeed the entire underlying representation and implementation can change without the interface changing at all.

Aiding in changing the underlying representation at will is the fact that the exposed type—rs232— is an opaque data type. Instead of exposing the fact of the bitmap implementation to the outside world, it is carefully concealed by the implementation. It is impossible for any code using this module to operate on the underlying bitmap with anything other than the API which has been exposed. This means that should it be deemed desirable to instead use an int as the underlying representation, this can be done without changing even one byte of client code.

rs232.m[edit]

:- module rs232.

:- interface.

:- import_module bool, io, list, string.

:- type rs232_pin
   ---> carrier_detect
      ; received_data
      ; transmitted_data
      ; data_terminal_ready
      ; signal_ground
      ; data_set_ready
      ; request_to_send
      ; clear_to_send
      ; ring_indicator.

:- type rs232.

:- func rs232_bits       = rs232.
:- func rs232_bits(bool) = rs232.

:- func rs232_set(rs232, rs232_pin)   = rs232.
:- func rs232_clear(rs232, rs232_pin) = rs232.

:- pred rs232_is_set(rs232::in, rs232_pin::in) is semidet.
:- pred rs232_is_clear(rs232::in, rs232_pin::in) is semidet.

:- func rs232_set_bits(rs232, list(rs232_pin))   = rs232.
:- func rs232_clear_bits(rs232, list(rs232_pin)) = rs232.

:- func to_string(rs232) = string.

:- pred write_rs232(rs232::in, io::di, io::uo) is det.

:- implementation.

:- import_module bitmap.

:- type rs232 == bitmap.

rs232_bits          = rs232_bits(no).
rs232_bits(Default) = bitmap.init(9, Default).

rs232_set(A, Pin)   = unsafe_set(A, to_index(Pin)).
rs232_clear(A, Pin) = unsafe_clear(A, to_index(Pin)).

rs232_is_set(A, Pin)   :- unsafe_is_set(A, to_index(Pin)).
rs232_is_clear(A, Pin) :- unsafe_is_clear(A, to_index(Pin)).

rs232_set_bits(A, Pins)   = foldl((func(Pin, B) = rs232_set(B, Pin)), Pins, A).
rs232_clear_bits(A, Pins) = foldl((func(Pin, B) = rs232_clear(B, Pin)), Pins, A).

to_string(A) = bitmap.to_string(A).

write_rs232(A, !IO) :- write_bitmap(resize(A, 16, no), !IO).
                       % cannot write a bitmap that isn't byte-divisible

:- func to_index(rs232_pin) = bit_index.
to_index(carrier_detect)      = 0.
to_index(received_data)       = 1.
to_index(transmitted_data)    = 2.
to_index(data_terminal_ready) = 3.
to_index(signal_ground)       = 4.
to_index(data_set_ready)      = 5.
to_index(request_to_send)     = 6.
to_index(clear_to_send)       = 7.
to_index(ring_indicator)      = 8.

:- end_module rs232.

rs232_main.m[edit]

:- module rs232_main.

:- interface.

:- import_module io.

:- pred main(io::di, io::uo) is det.

:- implementation.

:- import_module bitmap, bool, list, rs232.

main(!IO) :-
    Com1 = rs232_set_bits(rs232_bits, [data_terminal_ready, data_set_ready]),
    Com2 = rs232_clear_bits(rs232_bits(yes), [data_terminal_ready, data_set_ready]),

    write_string("Com1 bits = ", !IO),
    write_string(to_string(Com1), !IO), nl(!IO),

    write_string("Com2 bits = ", !IO),
    write_string(to_string(Com2), !IO), nl(!IO),

    write_string("Com1 DTR is ", !IO),
    ( if rs232_is_set(Com1, data_terminal_ready) then
        write_string("set.", !IO), nl(!IO)
    else
        write_string("clear.", !IO), nl(!IO)
    ),

    write_string("Com2 DSR is ", !IO),
    ( if rs232_is_clear(Com2, data_set_ready) then
        write_string("clear.", !IO), nl(!IO)
    else
        write_string("set.", !IO), nl(!IO)
    ).

:- end_module rs232_main.

Usage and output[edit]

 $ mmc --make rs232_main
 $ ./rs232_main
 Com1 bits = <9:1400>
 Com2 bits = <9:EB80>
 Com1 DTR is set.
 Com2 DSR is clear.

Nim[edit]

type
  rs232Data = enum
    carrierDetect,
    receivedData,
    transmittedData,
    dataTerminalReady,
    signalGround,
    dataSetReady,
    requestToSend,
    clearToSend,
    ringIndicator

# Bit vector of 9 bits
var bv = {carrierDetect, signalGround, ringIndicator}
echo cast[uint16](bv) # Conversion of bitvector to 2 bytes for writing

let readValue: uint16 = 123
bv = cast[set[rs232Data]](readValue) # Conversion of a read value to bitvector
echo bv

Output:

273
{carrierDetect, receivedData, dataTerminalReady, signalGround, dataSetReady, requestToSend}

OCaml[edit]

Library: extlib

open ExtLib
class rs232_data = object
  val d = BitSet.create 9

  method carrier_detect      = BitSet.is_set d 0
  method received_data       = BitSet.is_set d 1
  method transmitted_data    = BitSet.is_set d 2
  method data_terminal_ready = BitSet.is_set d 3
  method signal_ground       = BitSet.is_set d 4
  method data_set_ready      = BitSet.is_set d 5
  method request_to_send     = BitSet.is_set d 6
  method clear_to_send       = BitSet.is_set d 7
  method ring_indicator      = BitSet.is_set d 8

  method set_carrier_detect      b = (if b then BitSet.set else BitSet.unset) d 0
  method set_received_data       b = (if b then BitSet.set else BitSet.unset) d 1
  method set_transmitted_data    b = (if b then BitSet.set else BitSet.unset) d 2
  method set_data_terminal_ready b = (if b then BitSet.set else BitSet.unset) d 3
  method set_signal_ground       b = (if b then BitSet.set else BitSet.unset) d 4
  method set_data_set_ready      b = (if b then BitSet.set else BitSet.unset) d 5
  method set_request_to_send     b = (if b then BitSet.set else BitSet.unset) d 6
  method set_clear_to_send       b = (if b then BitSet.set else BitSet.unset) d 7
  method set_ring_indicator      b = (if b then BitSet.set else BitSet.unset) d 8
end
;;

Pascal[edit]

Pascal itself does not define, how data types have to be stored in memory. It is up to the processor (i. e. compiler) to choose appropriate mechanism. The FPC (Free Pascal compiler) does predictably define how it stores data.

Perl[edit]

use Bit::Vector::Minimal qw();
my $vec = Bit::Vector::Minimal->new(size => 24);

my %rs232 = reverse (
     1 => 'PG   Protective ground',
     2 => 'TD   Transmitted data',
     3 => 'RD   Received data',
     4 => 'RTS  Request to send',
     5 => 'CTS  Clear to send',
     6 => 'DSR  Data set ready',
     7 => 'SG   Signal ground',
     8 => 'CD   Carrier detect',
     9 => '+ voltage (testing)',
    10 => '- voltage (testing)',
    12 => 'SCD  Secondary CD',
    13 => 'SCS  Secondary CTS',
    14 => 'STD  Secondary TD',
    15 => 'TC   Transmit clock',
    16 => 'SRD  Secondary RD',
    17 => 'RC   Receiver clock',
    19 => 'SRS  Secondary RTS',
    20 => 'DTR  Data terminal ready',
    21 => 'SQD  Signal quality detector',
    22 => 'RI   Ring indicator',
    23 => 'DRS  Data rate select',
    24 => 'XTC  External clock',
);

$vec->set($rs232{'RD   Received data'}, 1);
$vec->get($rs232{'TC   Transmit clock'});

Phix[edit]

Phix does not support bit-fields directly. The nearest/sanest thing to do probably goes something like this (completely untested)

constant CD=1, RD=2, TD=3, DTR=4, ...
atom addr = allocate(2)  -- or wherever
--read
sequence bits = int_to_bits(peek2u(addr),16)
integer dtr = bits[DTR]
--write
bits[DTR] = 1
poke2(addr,bits_to_int(bits))

Naturally, you would be well advised to sequester such grubby details away in a small and separate unit/source code file (eg RS232.e) with a domain specific public API that does not leak implementation details (eg keep those constants private). There are 1/2/4/8 byte variants of peek and poke, and int-to-bits can extract anything from 1 to 53 bits on a 32-bit runtime, or up to 64 on a 64-bit runtime. Alternatively you could use bit-masks, or it may be possible to enhance builtins/cffi.e to manage bit-fields, then again the above C entry does not exactly inspire confidence.

PicoLisp[edit]

PicoLisp can handle bit fields or bit structures only as bignums. They can be manipulated with '&', '|' and 'x|', or tested with 'bit?'.

# Define bit constants
(for (N . Mask) '(CD RD TD DTR SG DSR RTS CTS RI)
   (def Mask (>> (- 1 N) 1)) )

# Test if Clear to send
(when (bit? CTS Data)
   ... )

PL/I[edit]

declare 1 RS232_layout,
   2 Carrier_Detect       Bit(1),
   2 Received_Data        Bit(1),
   2 Transmitted_Data     Bit(1),
   2 Data_Terminal_ready  Bit(1),
   2 Signal_Ground        Bit(1),
   2 Data_Set_Ready       Bit(1),
   2 Request_To_Send      Bit(1),
   2 Clear_To_Send        Bit(1),
   2 Ring_Indicator       Bit(1);

Python[edit]

The ctypes module allows for the creation of Structures that can map between the structures of C and python datatypes. Within Structures, bit fields can be created.

from ctypes import Structure, c_int

rs232_9pin  = "_0 CD RD TD DTR SG DSR RTS CTS RI".split()
rs232_25pin = ( "_0  PG  TD  RD  RTS CTS DSR SG  CD  pos neg"
                "_11 SCD SCS STD TC  SRD RC"
                "_18 SRS DTR SQD RI DRS XTC" ).split()

class RS232_9pin(Structure):
    _fields_ = [(__, c_int, 1) for __ in rs232_9pin]

	
class RS232_25pin(Structure):
    _fields_ = [(__, c_int, 1) for __ in rs232_25pin]

Racket[edit]

#lang racket

(require ffi/unsafe)

(define (_autobitmask l)
  (_bitmask (append* (for/list ([x l] [i (in-naturals)]) `(,x = ,(expt 2 i))))))

(define _rs232 (_autobitmask '(CD RD TD DTR SG DSR RTS CTS RI )))

;; Usually it will get used when using foreign functions automatically, but
;; this demonstrates the conversions explicitly
(require (only-in '#%foreign ctype-scheme->c ctype-c->scheme))
((ctype-scheme->c _rs232) '(SG TD RI)) ; -> 276
((ctype-c->scheme _rs232) 276)         ; -> '(TD SG RI)

Raku[edit]

(formerly Perl 6) The following is specced to work, but implementation of shaped arrays is not quite complete.

enum T_RS232 <
    carrier_detect
    received_data
    transmitted_data
    data_terminal_ready
    signal_ground
    data_set_ready
    request_to_send
    clear_to_send
    ring_indicator
>;

my bit @signal[T_RS232];

@signal[signal_ground] = 1;

In the absence of shaped arrays, you can do the usual bit-twiddling tricks on a native integer of sufficient size. (Such an integer could presumably be mapped directly to a device register.)

$signal +|= 1 +< signal_ground;

Using a native int is likelier to work on a big-endian machine in any case. Another almost-there solution is the mapping of C representational types into Raku for native interfaces, but it does not yet support bit fields.

REXX[edit]

version 1[edit]

/* REXX ***************************************************************
* Decode Memory structure of  RS-232 Plug Definition
* Not sure if I understood it completely :-) Open for corrections
* You never stop learning (as long as you live)
* 03.08.2012 Walter Pachl
**********************************************************************/
Call decode 'ABC'
Call decode 'XY'
Exit

decode:
  Parse Arg c
  cb=c2b(c)
  If length(cb)=24 Then Do
    Parse Var cb,
     /*    1 - PG  */ Protective ground      +1,
     /* 3  2 - TD  */ Transmitted_data       +1,
     /* 2  3 - RD  */ Received_data          +1,
     /* 7  4 - RTS */ Request_to_send        +1,
     /* 8  5 - CTS */ Clear_to_send          +1,
     /* 6  6 - DSR */ Data_set_ready         +1,
     /* 5  7 - SG  */ Signal_ground          +1,
     /* 1  8 - CD  */ Carrier_detect         +1,
     /*    9 - +   */ plus_voltage           +1,
     /*   10 - -   */ minus_voltage          +1,
     /*   11 -     */ .                      +1,
     /*   12 - SCD */ Secondary_CD           +1,
     /*   13 - SCS */ Secondary_CTS          +1,
     /*   14 - STD */ Secondary_TD           +1,
     /*   15 - TC  */ Transmit_clock         +1,
     /*   16 - SRD */ Secondary_RD           +1,
     /*   17 - RC  */ Receiver_clock         +1,
     /*   18 -     */ .                      +1,
     /*   19 - SRS */ Secondary_RTS          +1,
     /* 4 20 - DTR */ Data_terminal_ready    +1,
     /*   21 - SQD */ Signal_quality_detector+1,
     /* 9 22 - RI  */ Ring_indicator         +1,
     /*   23 - DRS */ Data_rate_select       +1,
     /*   24 - XTC */ External_clock         +1
    Say '24 bins:' cb
    Say ' 1 - PG  Protective ground       ='Protective ground
    Say ' 2 - TD  Transmitted data        ='Transmitted_data
    Say ' 3 - RD  Received data           ='Received_data
    Say ' 4 - RTS Request to send         ='Request_to_send
    Say ' 5 - CTS Clear to send           ='Clear_to_send
    Say ' 6 - DSR Data set ready          ='Data_set_ready
    Say ' 7 - SG  Signal ground           ='Signal_ground
    Say ' 8 - CD  Carrier detect          ='Carrier_detect
    Say ' 9 - +   plus voltage            ='plus_voltage
    Say '10 - -   minus voltage           ='minus_voltage
    Say ' '
    Say '12 - SCD Secondary CD            ='Secondary_CD
    Say '13 - SCS Secondary CTS           ='Secondary_CTS
    Say '14 - STD Secondary TD            ='Secondary_TD
    Say '15 - TC  Transmit clock          ='Transmit_clock
    Say '16 - SRD Secondary RD            ='Secondary_RD
    Say '17 - RC  Receiver clock          ='Receiver_clock
    Say ' '
    Say '19 - SRS Secondary RTS           ='Secondary_RTS
    Say '20 - DTR Data terminal ready     ='Data_terminal_ready
    Say '21 - SQD Signal quality detector ='Signal_quality_detector
    Say '22 - RI  Ring indicator          ='Ring_indicator
    Say '23 - DRS Data rate select        ='Data_rate_select
    Say '24 - XTC External hlock          ='External_clock
    End
  Else Do
    Parse Var cb,
    /* 1  8 - CD  */ Carrier_detect         +1,
    /* 2  3 - RD  */ Received_data          +1,
    /* 3  2 - TD  */ Transmitted_data       +1,
    /* 4 20 - DTR */ Data_terminal_ready    +1,
    /* 5  7 - SG  */ Signal_ground          +1,
    /* 6  6 - DSR */ Data_set_ready         +1,
    /* 7  4 - RTS */ Request_to_send        +1,
    /* 8  5 - CTS */ Clear_to_send          +1,
    /* 9 22 - RI  */ Ring_indicator         +1
    Say ' '
    Say '9-bin:' left(cb,9)
    Say ' 1 CD   Carrier detect      ='Carrier_detect
    Say ' 2 RD   Received data       ='Received_data
    Say ' 3 TD   Transmitted data    ='Transmitted_data
    Say ' 4 DTR  Data terminal ready ='Data_terminal_ready
    Say ' 5 SG   Signal ground       ='Signal_ground
    Say ' 6 DSR  Data set ready      ='Data_set_ready
    Say ' 7 RTS  Request to send     ='Request_to_send
    Say ' 8 CTS  Clear to send       ='Clear_to_send
    Say ' 9 RI   Ring indicator      ='Ring_indicator
    End
  Return
c2b: Procedure
/* REXX ***************************************************************
* c2b Convert a character string to a bit string
* 03.08.2012 Walter Pachl
**********************************************************************/
Parse Arg c
x=c2x(c)
res=''
Do While x<>''
  Parse Var x hb +1 x
  Select
    When hb='0' Then bs='0000'
    When hb='1' Then bs='0001'
    When hb='2' Then bs='0010'
    When hb='3' Then bs='0011'
    When hb='4' Then bs='0100'
    When hb='5' Then bs='0101'
    When hb='6' Then bs='0110'
    When hb='7' Then bs='0111'
    When hb='8' Then bs='1000'
    When hb='9' Then bs='1001'
    When hb='A' Then bs='1010'
    When hb='B' Then bs='1011'
    When hb='C' Then bs='1100'
    When hb='D' Then bs='1101'
    When hb='E' Then bs='1110'
    When hb='F' Then bs='1111'
    End
  res=res||bs
  End
Return res

Output EBCDIC:

24 bins: 110000011100001011000011
 1 - PG  Protective ground       =1
 2 - TD  Transmitted data        =1
 3 - RD  Received data           =0
 4 - RTS Request to send         =0
 5 - CTS Clear to send           =0
 6 - DSR Data set ready          =0
 7 - SG  Signal ground           =0
 8 - CD  Carrier detect          =1
 9 - +   plus voltage            =1
10 - -   minus voltage           =1

12 - SCD Secondary CD            =0
13 - SCS Secondary CTS           =0
14 - STD Secondary TD            =0
15 - TC  Transmit clock          =1
16 - SRD Secondary RD            =0
17 - RC  Receiver clock          =1

19 - SRS Secondary RTS           =0
20 - DTR Data terminal ready     =0
21 - SQD Signal quality detector =0
22 - RI  Ring indicator          =0
23 - DRS Data rate select        =1
24 - XTC External hlock          =1

9-bin: 111001111
 1 CD   Carrier detect      =1
 2 RD   Received data       =1
 3 TD   Transmitted data    =1
 4 DTR  Data terminal ready =0
 5 SG   Signal ground       =0
 6 DSR  Data set ready      =1
 7 RTS  Request to send     =1
 8 CTS  Clear to send       =1
 9 RI   Ring indicator      =1

version 2[edit]

Checks could be added to verify the number of pins selected, and also verify if the data (pin readings) specified is valid.

/*REXX program  displays  which  pins  are active of a  9  or  24  pin  RS-232  plug.   */
call rs_232  24,  127                            /*the value for an RS-232  24 pin plug.*/
call rs_232  24, '020304x'                       /* "    "    "   "   "      "  "    "  */
call rs_232   9, '10100000b'                     /* "    "    "   "   "      9  "    "  */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
rs_232: arg ,x;    parse arg pins,ox             /*X  is  uppercased  when using  ARG.  */
        @.      = '??? unassigned pin'           /*assign a default for all the pins.   */
        @.24.1  = 'PG  protective ground'
        @.24.2  = 'TD  transmitted data'            ;     @.9.3 = @.24.2
        @.24.3  = 'RD  received data'               ;     @.9.2 = @.24.3
        @.24.4  = 'RTS request to send'             ;     @.9.7 = @.24.4
        @.24.5  = 'CTS clear to send'               ;     @.9.8 = @.24.5
        @.24.6  = 'DSR data set ready'              ;     @.9.6 = @.24.6
        @.24.7  = 'SG  signal ground'               ;     @.9.5 = @.24.7
        @.24.8  = 'CD  carrier detect'              ;     @.9.1 = @.24.8
        @.24.9  = '+   positive voltage'
        @.24.10 = '-   negative voltage'
        @.24.12 = 'SCD secondary CD'
        @.24.13 = 'SCS secondary CTS'
        @.24.14 = 'STD secondary td'
        @.24.15 = 'TC  transmit clock'
        @.24.16 = 'SRD secondary RD'
        @.24.17 = 'RC  receiver clock'
        @.24.19 = 'SRS secondary RTS'
        @.24.20 = 'DTR data terminal ready'         ;     @.9.4 = @.24.20
        @.24.21 = 'SQD signal quality detector'
        @.24.22 = 'RI  ring indicator'              ;     @.9.9 = @.24.22
        @.24.23 = 'DRS data rate select'
        @.24.24 = 'XTC external clock'

                 select
                 when right(x, 1)=='B'  then bits=    strip(x, 'T', "B")
                 when right(x, 1)=='X'  then bits=x2b(strip(x, 'T', "X"))
                 otherwise                   bits=x2b( d2x(x) )
                 end   /*select*/
        say
        bits=right(bits, pins, 0)                /*right justify pin readings (values). */
        say '───────── For a'    pins    "pin RS─232 plug, with a reading of: "   ox
        say
                 do j=1  for pins;     z=substr(bits, j, 1);         if z==0  then iterate
                 say right(j, 5)     'pin is "on": '     @.pins.j
                 end   /*j*/
        return

output   when using the default (internal) inputs:

───────── For a 24 pin RS─232 plug, with a reading of:  127

   18 pin is "on":  ??? unassigned pin
   19 pin is "on":  SRS secondary RTS
   20 pin is "on":  DTR data terminal ready
   21 pin is "on":  SQD signal quality detector
   22 pin is "on":  RI  ring indicator
   23 pin is "on":  DRS data rate select
   24 pin is "on":  XTC external clock

───────── For a 24 pin RS─232 plug, with a reading of:  020304x

    7 pin is "on":  SG  signal ground
   15 pin is "on":  TC  transmit clock
   16 pin is "on":  SRD secondary RD
   22 pin is "on":  RI  ring indicator

───────── For a 9 pin RS─232 plug, with a reading of:  10100000b

    2 pin is "on":  RD  received data
    4 pin is "on":  DTR data terminal ready

Ruby[edit]

Uses the BitStruct module, which is handy but awkward to instantiate objects.

require 'bit-struct'

class RS232_9 < BitStruct
  unsigned :cd,  1, "Carrier detect"       #1
  unsigned :rd,  1, "Received data"        #2
  unsigned :td,  1, "Transmitted data"     #3
  unsigned :dtr, 1, "Data terminal ready"  #4
  unsigned :sg,  1, "Signal ground"        #5
  unsigned :dsr, 1, "Data set ready"       #6
  unsigned :rts, 1, "Request to send"      #7
  unsigned :cts, 1, "Clear to send"        #8
  unsigned :ri,  1, "Ring indicator"       #9
  
  def self.new_with_int(value)
    data = {}
    fields.each_with_index {|f, i| data[f.name] = value[i]}
    new(data)
  end
end

num = rand(2**9 - 1)
puts "num = #{num}"

sample1 = RS232_9.new([("%09d" % num.to_s(2)).reverse].pack("B*"))
puts sample1.inspect_detailed

sample2 = RS232_9.new_with_int(num)
puts sample2.inspect_detailed

puts "CD is #{sample2.cd == 1 ? 'on' : 'off'}"
num = 37
RS232_9:
                Carrier detect = 1
                 Received data = 0
              Transmitted data = 1
           Data terminal ready = 0
                 Signal ground = 0
                Data set ready = 1
               Request to send = 0
                 Clear to send = 0
                Ring indicator = 0
RS232_9:
                Carrier detect = 1
                 Received data = 0
              Transmitted data = 1
           Data terminal ready = 0
                 Signal ground = 0
                Data set ready = 1
               Request to send = 0
                 Clear to send = 0
                Ring indicator = 0
CD is on

Scala[edit]

object Rs232Pins9 extends App {

  val (off: Boolean, on: Boolean) = (false, true)
  val plug = new Rs232Pins9(carrierDetect = on, receivedData = on) // set first two pins, say

  def toOnOff(b: Boolean) = if (b) "on" else "off"

  class Rs232Pins9(
                    var carrierDetect: Boolean = off,
                    var receivedData: Boolean = off,
                    var transmittedData: Boolean = off,
                    var dataTerminalReady: Boolean = off,
                    var signalGround: Boolean = off,
                    var dataSetReady: Boolean = off,
                    var requestToSend: Boolean = off,
                    var clearToSend: Boolean = off,
                    var ringIndicator: Boolean = off
                  ) {
    def setPin(n: Int, v: Boolean) {
      (n) match {
        case 1 => carrierDetect = v
        case 2 => receivedData = v
        case 3 => transmittedData = v
        case 4 => dataTerminalReady = v
        case 5 => signalGround = v
        case 6 => dataSetReady = v
        case 7 => requestToSend = v
        case 8 => clearToSend = v
        case 9 => ringIndicator = v
      }
    }
  }

  // println(toOnOff(plug.component2()))                          // print value of pin 2 by number
  plug.transmittedData = on // set pin 3 by name
  plug.setPin(4, on) // set pin 4 by number
  // println(toOnOff(plug.component3()))                          // print value of pin 3 by number
  println(toOnOff(plug.dataTerminalReady)) // print value of pin 4 by name
  println(toOnOff(plug.ringIndicator)) // print value of pin 9 by name
}

Tcl[edit]

This Tcl implementation represents the fields as bits in an integer. It provides two functions to get from symbolic pin names to the integer, and vice versa.

set rs232_bits {CD RD TD DTR SG DSR RTS CTS RI}

proc rs232_encode args {
    set res 0
    foreach arg $args {
        set pos [lsearch $::rs232_bits $arg]
        if {$pos >=0} {set res [expr {$res | 1<<$pos}]}
    }
    return $res
}
proc rs232_decode int {
    set res {}
    set i -1
    foreach bit $::rs232_bits {
        incr i
        if {$int & 1<<$i} {lappend res $bit}
    }
    return $res
}
#------------------------------ Test suite
foreach {test => expected} {
    {rs232_encode CD} -> 1
    {rs232_decode 1} -> CD
    {rs232_encode CD RD TD} -> 7
    {rs232_decode 7} -> {CD RD TD}
} {
    catch $test res
    if {$res ne $expected} {puts "$test -> $res, expected $expected"}
}

Wren[edit]

Library: Wren-seq
Library: Wren-fmt

In Wren instances of user defined data structures ('classes') are always allocated on the heap and (AFAIK) their fields are laid out contiguously and require 8 bytes each. Nums, Bools and Nulls are stored directly and fields of other types store a pointer to their actual storage location.

It is not possible to vary this memory layout though, if lack of memory is a problem, one may be able to use bit arithmetic to pack more values into a Num.

As far as this task is concerned, below is a possible implementation for a 9-pin RS-232 plug which allows access by pin name or number and provides a comprehensive print out of the current pin state.

import "/seq" for Lst
import "/fmt" for Fmt

var ON  = true
var OFF = false

// Converts "ON"/"OFF" string to true/false.
var AsBool = Fn.new { |s| s == "ON" }

class RS232_9 {
    static names { ["CD", "RD", "TD", "DTR", "SG", "DSR", "RTS", "CTS", "RI"] }

    construct new() { _settings = [OFF] * 9 } // all pins OFF

    // get pin setting as an ON/OFF string by pin name or number; returns null if invalid
    [p] {
        if (p is String) {
            var ix = Lst.indexOf(RS232_9.names, p)
            return (ix >= 0 && ix < 9) ? (_settings[ix] ? "ON" : "OFF") : null
        }
        if (p is Num) {
            return (p.isInteger && p >= 1 && p <= 9) ? (_settings[p-1] ? "ON" : "OFF") : null
        }
        return null
    }

    // set pin by pin name or number; does nothing if invalid
    [p] = (v) {
        if (v.type == String && (v == "ON" || v == "OFF")) v = AsBool.call(v)
        if (v.type != Bool) return
        if (p is String) {
            var ix = Lst.indexOf(RS232_9.names, p)
            if (ix >= 0 && ix < 9) _settings[ix] = v
        }
        if (p is Num && p.isInteger && p >= 1 && p <= 9) _settings[p-1] = v
    }

    // prints all pin settings
    toString { (1..9).map { |i| "%(i) %(Fmt.s(-3, RS232_9.names[i-1])) = %(this[i])" }.join("\n") }
}

var plug = RS232_9.new()
plug["CD"]  = ON      // set pin 1 by name
plug[3]     = ON      // set pin 3 by number
plug["DSR"] = "ON"    // set pin 6 by name and using a string
System.print(plug)    // print the state of the pins
Output:
1 CD  = ON
2 RD  = OFF
3 TD  = ON
4 DTR = OFF
5 SG  = OFF
6 DSR = ON
7 RTS = OFF
8 CTS = OFF
9 RI  = OFF

Z80 Assembly[edit]

Translation of: 6502 Assembly
softRS232_LO equ &C000 ;%87654321 (each bit represents the state of a numbered pin)
softRS232_HI equ &C001 ;%-------9

ld hl,softRS232_LO ;memory location of soft RS232 port
ld c,&00           ;&00 = the port that the RS232 is connected to. 
                   ;This is just an example, the actual port number depends on where the hardware is connected.

outi               ;send the value contained in softRS232_LO thru port &00
outi               ;send the value contained in softRS232_HI thru port &00