Memory layout of a data structure: Difference between revisions

24 - XTC External clock

25 -

 

=={{header|Ada}}==

type Rs_232_Layout is record

Carrier_Detect : Bit;

Clear_To_Send at 0 range 7..7;

Ring_Indicator at 0 range 8..8;

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

INT ofs = bits width - 9;

INT

 

rs232 bits := bits pack((FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE));

Output:

<pre>

=={{header|C}}/{{header|C++}}==

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.

{

unsigned carrier_detect : 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.

 

Implementation uses tango's BitArray structure.

{{libheader|tango}}

 

import tango.core.BitArray;

 

return 0;

 

Output:

===Phobos version===

Not tested.

 

struct RS232_data {

}

 

 

=={{header|Forth}}==

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.

 

 

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

 

3fd constant com1-ctrl

decimal

wait-rx

2/

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.

=={{header|Fortran}}==

===Modern===

LOGICAL CARRIER_DETECT !1

LOGICAL RECEIVED_DATA !2

LOGICAL CLEAR_TO_SEND !8

LOGICAL RING_INDICATOR !9

But it would be nearly pointless to do so.

 

=={{header|Free Pascal}}==

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

type

{$packEnum 2}{$scopedEnums off}

writeLn(binStr(signalMemoryStructure, bitSizeOf(signal)));

end;

{{Out}}

<pre>0000000000010000</pre>

 

=={{header|FreeBASIC}}==

 

' using bit fields

 

Print SizeOf(RS232_Pin9) '' 2 bytes

 

=={{header|Go}}==

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.

 

import "fmt"

p := RI9 | TD9 | CD9

fmt.Printf("Type=%T value=%#04x\n", p, p)

{{out}}

<pre>

=={{header|J}}==

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:

RD Received data

TD Transmitted data

CTS Clear to send

RI Ring indicator

 

=={{header|Julia}}==

</pre>

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

mutable struct NinePinSerialPort

pins::BitArray

println("CTS pin of port, which is pin $CTS, is now $(port[CTS])")

println("port is now: $port")

{{output}}

<pre>

 

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:

 

const val OFF = false

println(toOnOff(plug.dataTerminalReady)) // print value of pin 4 by name

println(toOnOff(plug.ringIndicator)) // print value of pin 9 by name

 

{{out}}

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.

 

'received_data' , logical(1), ...

'transmitted_data', logical(1),...

[1]

[1]

 

=={{header|Mercury}}==

 

=== rs232.m ===

:- module rs232.

 

 

:- end_module rs232.

 

=== rs232_main.m ===

 

:- interface.

 

:- end_module rs232_main.

 

==== Usage and output ====

 

=={{header|Nim}}==

rs232Data = enum

carrierDetect,

let readValue: uint16 = 123

bv = cast[set[rs232Data]](readValue) # Conversion of a read value to bitvector

Output:

<pre>273

=={{header|OCaml}}==

'''Library:''' [http://code.google.com/p/ocaml-extlib/ extlib]

class rs232_data = object

val d = BitSet.create 9

method set_ring_indicator b = (if b then BitSet.set else BitSet.unset) d 8

end

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

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

 

 

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

 

=={{header|Phix}}==

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

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.

'[http://software-lab.de/doc/refX.html#x| x|]',

or tested with '[http://software-lab.de/doc/refB.html#bit? bit?]'.

(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)

 

=={{header|PL/I}}==

declare 1 RS232_layout,

2 Carrier_Detect Bit(1),

2 Clear_To_Send Bit(1),

2 Ring_Indicator Bit(1);

 

=={{header|Python}}==

The ctypes module allows for the creation of Structures that can map between the structures of C and python datatypes. Within Structures, [http://docs.python.org/library/ctypes.html#bit-fields-in-structures-and-unions bit fields] can be created.

 

 

rs232_9pin = "_0 CD RD TD DTR SG DSR RTS CTS RI".split()

class RS232_25pin(Structure):

 

=={{header|Racket}}==

 

#lang racket

 

((ctype-scheme->c _rs232) '(SG TD RI)) ; -> 276

((ctype-c->scheme _rs232) 276) ; -> '(TD SG RI)

 

=={{header|Raku}}==

(formerly Perl 6)

The following is specced to work, but implementation of shaped arrays is not quite complete.

carrier_detect

received_data

my bit @signal[T_RS232];

 

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.)

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.

 

=={{header|REXX}}==

===version 1===

* Decode Memory structure of RS-232 Plug Definition

* Not sure if I understood it completely :-) Open for corrections

res=res||bs

End

Output EBCDIC:

<pre>

===version 2===

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

call rs_232 24, 127 /*the value for an RS-232 24 pin plug.*/

call rs_232 24, '020304x' /* " " " " " " " " */

say right(j, 5) 'pin is "on": ' @.pins.j

end /*j*/

'''output''' &nbsp; when using the default (internal) inputs:

<pre>

=={{header|Ruby}}==

Uses the [http://redshift.sourceforge.net/bit-struct/ BitStruct] module, which is handy but awkward to instantiate objects.

 

class RS232_9 < BitStruct

puts sample2.inspect_detailed

 

 

<pre>num = 37

 

=={{header|Scala}}==

 

val (off: Boolean, on: Boolean) = (false, true)

println(toOnOff(plug.dataTerminalReady)) // print value of pin 4 by name

println(toOnOff(plug.ringIndicator)) // print value of pin 9 by name

 

=={{header|Tcl}}==

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.

 

proc rs232_encode args {

catch $test res

if {$res ne $expected} {puts "$test -> $res, expected $expected"}

 

=={{header|Wren}}==

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.

 

 

var ON = true

plug[3] = ON // set pin 3 by number

plug["DSR"] = "ON" // set pin 6 by name and using a string

 

{{out}}

9 RI = OFF

</pre>

 

{{omit from|ACL2}}