Host introspection: Difference between revisions
m (corrected categorization of task) |
(Added R code) |
||
Line 205: | Line 205: | ||
'PADDY3118-RESTING' |
'PADDY3118-RESTING' |
||
>>> </lang> |
>>> </lang> |
||
=={{header|R}}== |
|||
Word size |
|||
<lang R> |
|||
8 * .Machine$sizeof.long # e.g. 32 |
|||
# or |
|||
object.size(0L) # e.g. 32 bytes |
|||
</lang> |
|||
Endianness |
|||
<lang R> |
|||
.Platform$endian # e.g. "little" |
|||
</lang> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
Revision as of 15:44, 5 August 2009
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
<lang 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; </lang> 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: "dl$,max abs bit+1)); printf(($"bits per char: "z-dl$,bits per char)); printf(($"bits per int: "z-dl$,bits per int)); printf(($"chars 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: 2 bits per char: 8 bits per int: 32 chars per int: 4 bits width: 32 int byte order: ABCD, Hex:44434241
On older CPUs the results would vary:
ALGOL 68R | ALGOL 68RS | |
~ bits per char: 6 bits per int: 24 chars per int: 4 |
ICL 2900 bits per char: 8 bits per int: 32 chars per int: 4 |
Multics bits per char: 6 bits per int: 36 chars per int: 6 |
C
<lang c>#include <stdio.h>
- include <stddef.h> /* for size_t */
- 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;
}</lang>
On POSIX-compatible systems, the following also tests the endianness (this makes use of the fact that network order is big endian): <lang c>
- include <stdio.h>
- include <arpa/inet.h>
int main() {
if (htonl(1) == 1) printf("big endian\n"); else printf("little endian\n");
} </lang>
D
<lang d> import std.stdio, std.system;
void main() {
writefln("word size = ", size_t.sizeof * 8); writefln(endian == Endian.LittleEndian ? "little" : "big", " endian");
} </lang>
Factor
USING: alien.c-types io layouts ; "Word size: " write cell 8 * . "Endianness: " write little-endian? "little" "big" ? print
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@.
Fortran
INTEGER, PARAMETER :: i8 = SELECTED_INT_KIND(2) INTEGER, PARAMETER :: i16 = SELECTED_INT_KIND(4) INTEGER(i8) :: a(2) INTEGER(i16) :: b WRITE(*,*) bit_size(1) ! number of bits in the default integer type ! which may (or may not!) equal the word size b = Z'1234' ! Hexadecimal assignment a = (TRANSFER(b, a)) ! Split a 16 bit number into two 8 bit numbers IF (a(1) == Z'12') THEN ! where did the most significant 8 bits end up WRITE(*,*) "Big Endian" ELSE WRITE(*,*) "Little Endian" END IF
Haskell
import Data.Bits main = print $ bitSize (undefined :: Int) -- print word size
Dunno about endianness
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
<lang java>System.out.println("word size: "+System.getProperty("sun.arch.data.model")); System.out.println("endianness: "+System.getProperty("sun.cpu.endian"));</lang>
Modula-3
<lang modula3>MODULE Host EXPORTS Main;
IMPORT IO, Fmt, Word, Swap;
BEGIN
IO.Put("Word Size: " & Fmt.Int(Word.Size) & "\n"); IF Swap.endian = Swap.Endian.Big THEN IO.Put("Endianness: Big\n"); ELSE IO.Put("Endianness: Little\n"); END;
END Host.</lang>
Output (on an x86):
Word Size: 32 Endianness: Little
OCaml
<lang ocaml>Printf.printf "%d\n" Sys.word_size; (* Print word size *) Printf.printf "%s\n" Sys.os_type; (* Print operating system *)</lang> Dunno about endianness
Python
<lang python>>>> import sys, math >>> int(round(math.log(sys.maxint,2)+1)) # this only works in Python 2.x 32 >>> import struct >>> struct.calcsize('i') * 8 32 >>> sys.byteorder little >>> import socket >>> socket.gethostname() 'PADDY3118-RESTING' >>> </lang>
R
Word size <lang R> 8 * .Machine$sizeof.long # e.g. 32
- or
object.size(0L) # e.g. 32 bytes </lang> Endianness <lang R> .Platform$endian # e.g. "little" </lang>
Ruby
irb(main):001:0> 42.size * 8 => 32 irb(main):002:0> if [1].pack('i')[0] != 0 irb(main):003:1> 'little endian' irb(main):004:1> else irb(main):005:1* 'big endian' irb(main):006:1> end => "little endian"
Scheme
<lang scheme>(define host-info
(begin (display "Endianness: ") (display (machine-byte-order)) (newline) (display "Word Size: ") (display (if (fixnum? (expt 2 33)) 64 32)) (newline)))</lang>
Output:
Endianness: little-endian Word Size: 32
Slate
<lang slate> inform: 'Endianness: ' ; Platform current endianness. inform: 'Word Size: ' ; (Platform current bytesPerWord * 8) printString. </lang> Output:
Endianness: LittleEndian Word Size: 32
Tcl
This is very straightforward in Tcl. The global array tcl_platform
contains these values. In an interactive tclsh
:
<lang tcl>% parray tcl_platform
tcl_platform(byteOrder) = littleEndian
tcl_platform(machine) = intel
tcl_platform(os) = Windows NT
tcl_platform(osVersion) = 5.1
tcl_platform(platform) = windows
tcl_platform(pointerSize) = 4
tcl_platform(threaded) = 1
tcl_platform(user) = glennj
tcl_platform(wordSize) = 4</lang>