Host introspection: Difference between revisions

{{task|Programming environment operations}}

Print the [[wp:Word_size#Word_size_choice|word size]] and [[wp:Endianness|endianness]] of the host machine.

 

See also: [[Variable size/Get]]

=={{header|Ada}}==

with System; use System;

 

Put_Line ("Word size" & Integer'Image (Word_Size));

Put_Line ("Endianness " & Bit_Order'Image (Default_Bit_Order));

<pre>

Word size 32

Endianness LOW_ORDER_FIRST

</pre>

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

{{works with|ALGOL 68|Revision 1 - no extensions to language used}}

{{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]}}

{{wont work 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] - due to extensive use of FORMATted transput}}

INT bits per char = ENTIER (ln(max abs char+1)/ln(max abs bit+1));

INT bits per int = ENTIER (1+ln(max int+1.0)/ln(max abs bit+1));

int byte order +:= REPR(abcdi OVER (max abs bit+1) ** shift MOD (max abs char+1))

OD;

<pre>

states per bit: 2

|}

 

=={{header|Babel}}==

{ "Word size: " << msize 3 shl %d << " bits" cr <<

 

=={{header|C}}==

#include <stddef.h> /* for size_t */

#include <limits.h> /* for CHAR_BIT */

printf("big endian\n");

return 0;

 

On POSIX-compatible systems, the following also tests the endianness (this makes use of the fact that network order is big endian):

#include <arpa/inet.h>

 

else

printf("little endian\n");

 

=={{header|C sharp}}==

{

Console.WriteLine("Word size = {0} bytes,",sizeof(int));

else

Console.WriteLine("Big-endian.");

 

=={{header|Clojure}}==

 

=={{header|Common Lisp}}==

 

The [http://www.lispworks.com/documentation/HyperSpec/Body/c_enviro.htm Environment] has some implementation-specific functions that might provide a good hint, e.g.,

 

The [http://www.cliki.net/features *features*] list also provides useful information, e.g., some compilers declare :LITTLE-ENDIAN there.

 

=={{header|D}}==

 

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln('word size: ', SizeOf(Integer));

Writeln('endianness: little endian'); // Windows is always little endian

 

=={{header|Erlang}}==

To find the word size:

 

 

<<1,0,0,0>>

2> <<1:4/big-unit:8>>

<<0,0,0,1>>

3> <<1:4/little-unit:8>>.

 

 

 

=={{header|Factor}}==

"Word size: " write cell 8 * .

 

=={{header|Forth}}==

cr 1 cells . ." address units per cell"

s" ADDRESS-UNIT-BITS" environment? if cr . ." bits per address unit" then

This relies on '''c@''' being a byte fetch (4 chars = 1 cells). Although it is on most architectures, ANS Forth only guarantees that 1 chars <= 1 cells. Some Forths like OpenFirmware have explicitly sized fetches, like b@.

 

=={{header|Fortran}}==

character(len=1) :: c(20)

equivalence (c, i)

ELSE

WRITE(*,*) "Little Endian"

 

 

 

=={{header|Go}}==

 

import (

)

 

func main() {

<pre>

little endian

</pre>

Alternative technique:

 

import (

fmt.Println(f.FileHeader.ByteOrder)

f.Close()

<pre>

LittleEndian

=={{header|Groovy}}==

Solution follows [[Java]]:

 

<pre>word size: 64

endianness: little</pre>

 

=={{header|Haskell}}==

import ADNS.Endian -- http://hackage.haskell.org/package/hsdns

 

putStrLn $ "Endianness: " ++ show endian

where

 

=={{header|J}}==

 

 

This returns <code>32</code> in 32 bit J.

 

Note that this mechanism is testing the interpreter, and not the OS or Hardware. (Though, of course, you cannot run a 64 bit interpreter on a machine that does not support it.)

 

 

64

 

=={{header|Java}}==

{{works with|Java|1.4}}

 

 

public class ShowByteOrder {

System.out.println(ByteOrder.nativeOrder());

}

 

Some JVMs also have system properties for the word size and byte order.

 

 

 

<pre>

</pre>

 

 

 

=={{header|MATLAB}} / {{header|Octave}}==

The concept of "word size" is not meaningful in Matlab and Octave, uint64 is also available on 32bit-platforms, and there are no pointers. Endianity can be tested with the function below:

 

fid=tmpfile();

fwrite(fid,1:8,'uint8');

else endian='little';

end;

 

<pre> octave:128> computer

x86_64-unknown-linux-gnu

endian = little</pre>

 

 

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt, Word, Swap;

IO.Put("Endianness: Little\n");

END;

 

<pre>

Word Size: 32

Endianness: Little

</pre>

 

=={{header|NetRexx}}==

{{trans|Java}}

NetRexx can access this information from the [[Java]] virtual machine in the same way as the [[#Java|Java]] sample above.

options replace format comments java crossref savelog symbols nobinary

 

say ' word size:' wordSize

say 'endianness:' endian

 

=={{header|Objective-C}}==

Endianness:

case NS_BigEndian:

NSLog(@"%@", @"Big Endian");

NSLog(@"%@", @"endianness unknown");

break;

 

Architecture:

case NSBundleExecutableArchitectureI386:

NSLog(@"%@", @"i386 32-bit");

NSLog(@"%@", @"Unknown");

break;

 

=={{header|OCaml}}==

 

 

one may use the [http://unixhelp.ed.ac.uk/CGI/man-cgi?uname uname] shell command :

 

let arg = if arg = "" then "-" else arg in

let ic = Unix.open_process_in ("uname -" ^ arg) in

 

# uname "sm";;

 

In most cases, endianness can be infered from informations given by uname.

One may also read files in the /proc directory in order to get informations about the host, only under linux :

 

If the loop is implemented by a recursive auxiliary function, the try...with breaks

tail recursion if not written carefully *)

"VmallocChunk: 109320 kB"; "HugePages_Total: 0";

"HugePages_Free: 0"; "HugePages_Rsvd: 0";

 

Same methods can be used to get the results of commands lshw, dmidecode...

 

=={{header|Pascal}}==

begin

writeln('Pointer size: ', SizeOf(Pointer), ' byte, i.e. ', SizeOf(Pointer)*8, ' bit.');

else

writeln('This host is little endian.');

<pre>

>: ./HostIntrospection

=={{header|Perl}}==

Most basic example:

<pre>

UV size: 4, byte order: 1234

 

More verbose example:

use Config;

my ($size, $order, $end) = @Config{qw(uvsize byteorder)};

default { $end = 'mixed' }

}

<pre>

UV size: 4, byte order: 1234 (little-endian)

UV size: 8, byte order: 87654321 (big-endian)

</pre>

{{out}}

 

=={{header|PicoLisp}}==

other contributions to this task) only tells how the binary was

compiled/assembled/linked, not necessarily the nature of the underlying system.

(rd 4) # Skip "7F" and 'E', 'L' and 'F'

(prinl

(1 "Little endian")

(2 "Big endian")

<pre>64 bits

Little endian</pre>

 

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

details: procedure options (main); /* 6 July 2012 */

declare x float, i fixed binary initial (1);

end details;

<pre>

word size= 32

 

=={{header|PowerShell}}==

Write-Host -NoNewLine "Endianness: "

if ([BitConverter]::IsLittleEndian) {

} else {

Write-Host Big-Endian

=={{header|PureBasic}}==

#LittleEndian

#BigEndian

PrintN("and you use Big Endian.")

EndSelect

 

=={{header|Python}}==

>>> sys.byteorder

little

>>> socket.gethostname()

 

=={{header|R}}==

Word size

Endianness

 

=={{header|Retro}}==

Word Size

 

 

Returns the number of bits per cell. This is normally 32, though may be smaller or larger on embedded systems and under special cases.

Endianness

 

 

Returns 0 for little endian, and 1 for big endian.

=={{header|REXX}}==

Since all variables in the REXX language are stored as characters, the wordsize is immaterial (REXX supports variable precision for numbers).

<br>The REXX language was designed for scripting and interfacing with the operating system.

<br>indicator stored anywhere in the virtual address space, it can be examined.

 

parse source opSys howInvoked pathName

 

/*where opSys will indicate which operating system REXX is running under, and */

 

=={{header|Ruby}}==

# Fixnum#size returns bytes (1 byte = 8 bits).

word_size = 42.size * 8

bytes = [1].pack('S').unpack('C*')

byte_order = (bytes[0] == 0 ? 'big' : 'little') + ' endian'

 

With [[MRI]], <code>ri Fixnum</code> states, "A Fixnum holds Integer values that can be represented in a native machine word (minus 1 bit)." This bases our claim that a Fixnum occupies one machine word.

 

Some other implementations of Ruby are different. With [[JRuby]], a Fixnum is always 64 bits, because it is a Java <code>long</code> [http://www.jruby.org/git?p=jruby.git;a=blob;f=src/org/jruby/RubyFixnum.java;h=ba8d076d58d28c30ecd8e378e6e2482486dba22d;hb=HEAD#l91 (1)]. JRuby uses the correct native byte order by calling java.nio.ByteOrder.nativeOrder() [http://www.jruby.org/git?p=jruby.git;a=blob;f=src/org/jruby/platform/Platform.java;h=d84b0b55b1aca381b2101297185d3b7f872c8cfd;hb=HEAD#l110 (2)].

 

=={{header|Scheme}}==

(begin

(display "Endianness: ")

(display "Word Size: ")

(display (if (fixnum? (expt 2 33)) 64 32))

 

<pre>

</pre>

 

=={{header|Slate}}==

<pre>

Endianness: LittleEndian

=={{header|Tcl}}==

This is very straightforward in Tcl. The global array <code>tcl_platform</code> contains these values. In an interactive <code>tclsh</code>:

tcl_platform(byteOrder) = littleEndian

tcl_platform(machine) = intel

tcl_platform(threaded) = 1

tcl_platform(user) = glennj

 

=={{header|TI-89 BASIC}}==