Host introspection: Difference between revisions

 

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|F_Sharp|F#}}==

A lot of research before I finally came up with an answer to this that isn't dependent on the machine it was compiled on. Works on Win32 machines only (obviously, due to the interop). I think that strictly speaking, I should be double checking the OS version before making the call to wow64Process, but I'm not worrying about it.

open System.Runtime.InteropServices

open System.Diagnostics

f64Bit

let IsLittleEndian() = BitConverter.IsLittleEndian

 

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

 

' uses intrinsic defines, set by the compiler

#EndIf

 

 

{{out}}

 

=={{header|Frink}}==

println["Word size: " + callJava["java.lang.System", "getProperty", "sun.arch.data.model"]]

println["Endianness: " + callJava["java.lang.System", "getProperty", "sun.cpu.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.)

That said, this does not deal with endianness. For the most part, J programs do not need to know their own endianness. When converting to and from binary format you can specify "native", "little endian" and "big endian", and it's rare that you have an interface which would need anything else. That said, you can inspect the binary representation of a simple constant:

 

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.

 

 

=={{header|Julia}}==

<code>Julia</code> creates <code>ENDIAN_BOM</code> a 32 bit unsigned integer out of an array of 4 8 bit unsigned integers to serve as an endianness marker.

print("This host's word size is ", WORD_SIZE, ".")

if ENDIAN_BOM == 0x04030201

println("ENDIAN_BOM = ", ENDIAN_BOM, ", which is confusing")

end

 

{{out}}

=={{header|Kotlin}}==

The following is not guaranteed to work on all JVMs but is working fine on my x64 Windows 10 machine:

 

fun main(args: Array<String>) {

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

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

 

{{out}}

Endianness: little-endian

</pre>

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

\\ Always run in Little-endian, 32 bits (in Wow64 in 64 bit os)

}

Checkit

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

{{out}} x86

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

octave:129> endian

endian = little</pre>

 

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

 

IMPORT IO, Fmt, Word, Swap;

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

END;

 

{{out}} (on an x86):

C support file, host-introspection.c

 

/* From Rosetta Code, C entry, with Neko marshalling */

 

}

/* Expose symbol to Neko loader */

 

Neko caller, host-introspection.neko

 

Host introspection, in Neko

*/

 

var wordsize = $loader.loadprim("native@wordsize", 0)

 

{{out}}

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

In Nim, "int" type has the size of the word. So, to find the word size in bits, just multiply the "int" size in bytes by eight.

 

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

=={{header|Phix}}==

Note that machine_word() and machine_bits() test the interpreter or compiled executable, rather than the OS or hardware.<br>

{{out}}

<pre>

Endianness: little-endian

Word size: 8 bytes/64 bits

</pre>

 

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

>>> platform.architecture()

('64bit', 'ELF')

>>> socket.gethostname()

'yourhostname'

 

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

(formerly Perl 6)

Endian detection translated from C. {{works with|Rakudo|2018.03}}

say $*VM.config<ptr_size>;

my $bytes = nativecast(CArray[uint8], CArray[uint16].new(1));

{{out}}

<pre>8

Note: Rakudo 2018.12 is introducing the endian-sensitive<code>read-int16</code> method,

which makes endian detection a little easier:

 

In Rakudo 2019.01 the dynamic KERNEL variable was fleshed out with a bunch of accessors, among them:

{{out}}

<pre>linux, 64, x86_64, LittleEndian</pre>

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.

 

=={{header|Rust}}==

enum Endianness {

Big, Little,

println!("Word size: {} bytes", std::mem::size_of::<usize>());

println!("Endianness: {:?}", Endianness::target());

 

{{out}}

 

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

 

No match, so big endian.

 

=={{header|Wren}}==

{{trans|C}}

As this information cannot be reliably obtained via Wren CLI, we instead embed a Wren script in a C application and ask the host program to get it for us.

 

class C {

 

System.print("word size = %(C.wordSize) bits")

<br>

We now embed this Wren script in the following C program, compile and run it.

#include <stdio.h>

#include <string.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

endian.

 

int A, B;

char C;

Text(0, " endian

");

 

{{out}}

Little endian

</pre>