Host introspection: Difference between revisions

{{task|Programming environment operations}}

{{omit from|Brlcad}}

{{omit from|E}}

 

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

 

{{out|Sample output on a Pentium machine}}

{{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;

{{out}} (Intel i686):

<pre>

 

=={{header|Applesoft BASIC}}==

2 DATA6,24,251,144,2,251,56

3 DATA216,105,0,133,251,96

10 IF M THEN PRINT M$

11 PRINT "ENDIANNESS: ";

 

=={{header|Babel}}==

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

 

=={{header|BBC BASIC}}==

!P% = -1

I% = 0 : REPEAT I% += 1 : UNTIL P%?I%=0

!P% = 1

IF P%?0 = 1 THEN PRINT "Little-endian"

The 'word size' is reported as the number of bytes accessed by the ! indirection operator, which is 4 in all current versions of BBC BASIC.

 

=={{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|Caché ObjectScript}}==

 

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

import std.stdio, std.system;

 

writeln("Word size = ", size_t.sizeof * 8, " bits.");

writeln(endian == Endian.littleEndian ? "Little" : "Big", " endian.");

{{out}}

<pre>Word size = 64 bits.

 

=={{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:

 

In the case of endianness, Erlang's bit syntax by default has a 'native' option which lets you use what is supported natively.

However, one could write one by using bit syntax, setting endianness and then comparing to the native format:

 

<<1,0,0,0>>

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

<<0,0,0,1>>

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

 

And so the following function would output endianness:

 

 

=={{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 (

}

}

{{out}}

<pre>

</pre>

Alternative technique:

 

import (

fmt.Println(f.FileHeader.ByteOrder)

f.Close()

{{out}}

<pre>

=={{header|Groovy}}==

Solution follows [[Java]]:

 

{{out}}

 

=={{header|Haskell}}==

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

 

putStrLn $ "Endianness: " ++ show endian

where

 

=={{header|Icon}} and {{header|Unicon}}==

 

write(if 0 = ishift(1,-1) then "little" else "big"," endian")

if match("flags",line := !open("/proc/cpuinfo")) then # Unix-like only

write(if find(" lm ",line) then 64 else 32," bits per word")

else write("Cannot determine word size.")

 

Sample run:

=={{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.

 

 

 

{{out}} x86

32 bits

</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;

 

{{out}}

endian = little</pre>

 

 

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

 

IMPORT IO, Fmt, Word, Swap;

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

END;

 

{{out}} (on an x86):

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|Nim}}==

 

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

Endianness:

case NS_BigEndian:

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

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

break;

 

Architecture:

(works on Mac OS X 10.6+)

case NSBundleExecutableArchitectureI386:

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

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

break;

 

=={{header|OCaml}}==

 

 

{{works with|OCaml|4.00+}}

 

On OCaml 3 and below, there are tricks to get endianness. For example in Linux or Unix variants,

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

{{out}}

<pre>

=={{header|Perl}}==

Most basic example:

{{out}}

<pre>

 

More verbose example:

use Config;

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

default { $end = 'mixed' }

}

{{out}}

<pre>

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

{{out}}

<pre>64 bits

 

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

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

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

end details;

{{out}}

<pre>

 

=={{header|PowerShell}}==

Write-Host -NoNewLine "Endianness: "

if ([BitConverter]::IsLittleEndian) {

} else {

Write-Host Big-Endian

Note that endianness is essentially a moot point with PowerShell,

as there is only a Windows implementation currently

 

=={{header|PureBasic}}==

#LittleEndian

#BigEndian

PrintN("and you use Big Endian.")

EndSelect

 

=={{header|Python}}==

>>> sys.byteorder

little

>>> socket.gethostname()

 

=={{header|R}}==

Word size

Endianness

 

=={{header|Racket}}==

#lang racket/base

 

(printf "Word size: ~a\n" (system-type 'word))

(printf "Endianness: ~a\n" (if (system-big-endian?) 'big 'little))

 

=={{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.

<br>However, there is a STORAGE built-in function that allows a program to look at (local) storage, and if there is an

<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|Scala}}==

 

object ShowByteOrder extends App {

println(s"Word size: ${System.getProperty("sun.arch.data.model")}")

println(s"Endianness: ${System.getProperty("sun.cpu.endian")}")

 

=={{header|Scheme}}==

(begin

(display "Endianness: ")

(display "Word Size: ")

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

{{out}}

Endianness: little-endian

The example below assumes that the word size is the size of a pointer.

 

include "cc_conf.s7i";

 

writeln("Big endian");

end if;

 

{{out}}

 

=={{header|Slate}}==

{{out}}

<pre>

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

 

 

=={{header|XPL0}}==

endian.

 

int A, B;

char C;

Text(0, " endian

");

 

{{out}}

Little endian

</pre>