Host introspection

Host introspection
You are encouraged to solve this task according to the task description, using any language you may know.

Print the word size and endianness of the host machine.

Ada

<ada> with Ada.Text_IO; use Ada.Text_IO; with System; use System;

procedure Host_Introspection is begin

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

end Host_Introspection; </ada> Sample output on a Pentium machine:

Word size 32
Endianness LOW_ORDER_FIRST

ALGOL 68

INT max abs bit = ABS(BIN 1 SHL 1)-1;
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));

printf(($"states per bit: "z-dl$,max abs bit));
printf(($"bits per char: "z-dl$,bits per char));
printf(($"bits per int: "z-dl$,bits per int));
printf(($"char per int: "z-dl$,bits per int OVER bits per char));

printf(($"bits width: "z-dl$, bits width));

STRING abcds = "ABCD";
FILE abcdf;
INT abcdi;

INT errno := open(abcdf, "abcd.dat",stand back channel);
put(abcdf,abcds); # output alphabetically #
reset(abcdf);
get bin(abcdf,abcdi); # input in word byte order #
STRING int byte order := "";
FOR shift FROM 0 BY bits per char TO bits per int - bits per char DO
  int byte order +:= REPR(abcdi OVER (max abs bit+1) ** shift MOD (max abs char+1))
OD;
printf(($"int byte order: "g,", Hex:",16r8dl$,int byte order, BIN abcdi))

Output (Intel i686):

states per bit:   1
bits per char:   8
bits per int:  32
char per int:   4
bits width:  32
int byte order: ABCD, Hex:44434241

On older CPUs the results would vary:

ALGOL 68RS - ICL 2900 bits per char: 8 bits per int: 32 char per int: 4

ALGOL 68RS - Multics bits per char: 6 bits per int: 36 char per int: 6

ALGOL 68R bits per char: 6 bits per int: 24 char per int: 4

C

<c>#include <stdio.h>

1. include <stddef.h> /* for size_t */
2. include <limits.h> /* for CHAR_BIT */

int main() {

   int one = 1;
   printf("word size = %d\n", CHAR_BIT * sizeof(size_t)); /* best bet: size_t typically is exactly one word */
   if (*(char *)&one) /* if the least significant bit is located in the lowest-address byte */
       printf("little endian\n");
   else
       printf("big endian\n");
   return 0;

}</c>

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

1. include <stdio.h>
2. include <arpa/inet.h>

int main() {

 if (htonl(1) == 1)
   printf("big endian\n");
 else
   printf("little endian\n");

} </c>

D

<d> import std.stdio, std.system;

void main() {

 writefln("word size = ", size_t.sizeof * 8);
 writefln(endian == Endian.LittleEndian ? "little" : "big", " endian");

} </d>

Forth

: endian
  cr 1 cells . ." address units per cell"
  s" ADDRESS-UNIT-BITS" environment? if cr . ." bits per address unit" then
  cr 1 here ! here c@ if ." little" else ." big" then ."  endian" ;

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

J

Method A:

   ":&> (|: 32 64 ;"0 big`little) {"_1~ 2 2 #: 16b_e0 + a. i. 0 { 3!:1 ''  
32
little

Method B:

   ((4*#) ,:&": little`big {::~ '7'={.) {: 3!:3 ] 33 b.~_1
32
little

Java

<java>System.out.println("word size: "+System.getProperty("sun.arch.data.model")); System.out.println("endianness: "+System.getProperty("sun.cpu.endian"));</java>

OCaml

<ocaml>Printf.printf "%d\n" Sys.word_size; (* Print word size *) Printf.printf "%s\n" Sys.os_type; (* Print operating system *)</ocaml> Dunno about endianness

Python

<python>>>> import sys, math >>> int(round(math.log(sys.maxint,2)+1)) 32 >>> sys.byteorder little >>> import socket >>> socket.gethostname() 'PADDY3118-RESTING' >>> </python>