File size

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

Verify the size of a file called     input.txt     for a file in the current working directory, and another one in the file system root.

11l

V size1 = fs:file_size(‘input.txt’)
V size2 = fs:file_size(‘/input.txt’)

8086 Assembly

This program runs under MS-DOS.

putch:	equ	2	; Print character
puts:	equ	9	; Print $-terminated string
setdta:	equ	1Ah	; Set DTA
stat:	equ	4Eh	; Get file info
	cpu	8086
	bits	16
	org	100h
section	.text
	mov	si,curf		; Print file size for 'INPUT.TXT'
	call	pfsize		; (in current directory),
	mov	si,rootf	; Then for '\INPUT.TXT' in root directory	
	;;;	Print file name and size for file in DS:SI
pfsize:	mov	ah,setdta	; Set disc transfer area pointer
	mov	dx,dta
	int	21h
	call	puts0		; Print the filename in SI
	mov	ah,puts		; Print colon and space
	mov	dx,colspc
	int	21h
	mov	ah,stat		; Find file info
	xor	cx,cx		; We want a normal file
	mov	dx,si		; Filename is in SI
	int	21h
	jnc	.ok		; Carry clear = found
	mov	ah,puts		; Carry set = not found = print 'not found'
	mov	dx,nofile
	int	21h
	ret
.ok:	les	bp,[dta+26]	; 32-bit file size in bytes at DTA+26
	mov	di,es		; DI:BP = 32-bit file size
	mov	bx,numbuf	; ASCII number buffer
	mov	cx,10		; Divisor (10)
.dgt:	xor	dx,dx		; 32-bit division (to get digits)
	mov	ax,di		; can be done with chained DIVs
	div	cx
	mov	di,ax
	mov	ax,bp
	div	cx
	mov	bp,ax
	add	dl,'0'		; DX is now remainder, i.e. digit
	dec	bx		; Move digit pointer backwards,
	mov	[bx],dl		; Store ASCII digit,
	or	ax,di		; If the new divisor is not zero,
	jnz	.dgt		; then there is another digit.
	mov	ah,puts		; If so, the number is done,
	mov	dx,bx		; and we can print it.
	int	21h
	ret
	;;;	Print 0-terminated string in SI
puts0:	push	si		; Save SI register
	mov	ah,putch	; Print char syscall
.loop:	lodsb			; Load character from SI
	test	al,al		; If zero,
	jz	.out		; then stop.
	mov	dl,al		; Tell DOS to print character
	int	21h
	jmp	.loop		; go get another.
.out:	pop	si		; Restore SI register
	ret
section	.data
rootf:	db	'\'		; \INPUT.TXT (for root) and
curf:	db	'INPUT.TXT',0	; INPUT.TXT (for current directory)
nofile:	db	'Not found.',13,10,'$'	; "Not found" message
	db	'0000000000'	; Number output buffer
numbuf:	db	' bytes',13,10,'$'
colspc:	db	': $'		; Colon and space
section	.bss
dta:	resb	512		; Disc transfer area

Output:

C:\>filesize
INPUT.TXT: Not found.
\INPUT.TXT: Not found.

C:\>echo Hello! > INPUT.TXT

C:\>filesize
INPUT.TXT: 8 bytes.
\INPUT.TXT: 8 bytes.

C:\>cd testdir

C:\TESTDIR>\filesize
INPUT.TXT: Not found.
\INPUT.TXT: 8 bytes

C:\TESTDIR>echo Goodbye! > INPUT.TXT

C:\TESTDIR>\filesize
INPUT.TXT: 10 bytes
\INPUT.TXT: 8 bytes

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux

/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program filelen64.s   */

/************************************/
/* Constantes                       */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc" 

.equ FSTAT,  0x50

/************************************/
/* structure de type   stat  : file infos   */
/************************************/
    .struct  0
Stat_dev_t:               /* ID of device containing file */
    .struct Stat_dev_t + 8
Stat_ino_t:              /* inode */
    .struct Stat_ino_t + 8
Stat_mode_t:              /* File type and mode */
    .struct Stat_mode_t + 4   
Stat_nlink_t:               /* Number of hard links */
    .struct Stat_nlink_t + 4    
Stat_uid_t:               /* User ID of owner */
    .struct Stat_uid_t + 4
Stat_gid_t:                 /* Group ID of owner */
    .struct Stat_gid_t + 4    
Stat_rdev_t:                /* Device ID (if special file) */
    .struct Stat_rdev_t + 8
Stat_size_deb:           /* la taille est sur 8 octets si gros fichiers */
     .struct Stat_size_deb + 8 
Stat_size_t:                /* Total size, in bytes */
    .struct Stat_size_t + 8    
Stat_blksize_t:                /* Block size for filesystem I/O */
    .struct Stat_blksize_t + 8     
Stat_blkcnt_t:               /* Number of 512B blocks allocated */
    .struct Stat_blkcnt_t + 8    
Stat_atime:               /*   date et heure fichier */
    .struct Stat_atime + 8     
Stat_mtime:               /*   date et heure modif fichier */
    .struct Stat_atime + 8 
Stat_ctime:               /*   date et heure creation fichier */
    .struct Stat_atime + 8     
Stat_End:  

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:       .asciz " File size = "
szCarriageReturn:   .asciz "\n"
szMessErrOpen:      .asciz "Error open file\n"
szMessErrStat:      .asciz "Error stats file\n"
szFileName:         .asciz "input.txt"
szFileName1:        .asciz "../../../input.txt"

/*********************************/
/* UnInitialized data            */
/*********************************/
.bss  
sZoneConv:           .skip 24
sBuffer:             .skip Stat_End
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:
    ldr x0,qAdrszFileName       // file name
    bl filesize
    cmp x0,#0
    blt 100f
    ldr x1,qAdrsZoneConv       
    bl conversion10             // call décimal conversion
    mov x0,#4
    ldr x1,qAdrszFileName
    ldr x2,qAdrszMessResult
    ldr x3,qAdrsZoneConv        // insert conversion in message
    ldr x4,qAdrszCarriageReturn
    stp x4,x4,[sp,-16]!         // save  registers 
    bl displayStrings           // display message
    add sp,sp,#16                   // 1 parameter on stack 
    
    ldr x0,qAdrszFileName1       // file name
    bl filesize
    cmp x0,#0
    blt 100f
    ldr x1,qAdrsZoneConv       
    bl conversion10             // call décimal conversion
    ldr x0,qAdrsZoneConv
    mov x0,#4
    ldr x1,qAdrszFileName1
    ldr x2,qAdrszMessResult
    ldr x3,qAdrsZoneConv        // insert conversion in message
    ldr x4,qAdrszCarriageReturn
    stp x4,x4,[sp,-16]!         // save  registers 
    bl displayStrings           // display message
    add sp,sp,#16                  // 1 parameter on stack 
    
100:                            // standard end of the program 
    mov x0, #0                  // return code
    mov x8,EXIT 
    svc #0                      // perform the system call
qAdrszCarriageReturn:    .quad szCarriageReturn
qAdrsZoneConv:           .quad sZoneConv  
qAdrszMessResult:        .quad szMessResult
qAdrszFileName:          .quad szFileName 
qAdrszFileName1:         .quad szFileName1  
qAdrsBuffer:             .quad sBuffer
qAdrszMessErrOpen:       .quad szMessErrOpen
qAdrszMessErrStat:       .quad szMessErrStat
/***************************************************/
/*   display multi strings                    */
/***************************************************/
/* x0  contains number strings address */
filesize:                       // INFO:  filesize
    stp x1,lr,[sp,-16]!         // save  registers 
    stp x2,x3,[sp,-16]!         // save  registers 
    stp x4,x5,[sp,-16]!         // save  registers 
    stp x6,x7,[sp,-16]!         // save  registers 
    stp x8,x9,[sp,-16]!         // save  registers 
    mov x1,x0
    mov x0,#AT_FDCWD
    mov x2,#O_RDWR              //  flags
    mov x3,#0                   // mode
    mov x8,#OPEN
    svc 0 
    cmp x0,#0                   // error ?
    ble 99f
    mov x8,x0                   // Fd save
    ldr x1,qAdrsBuffer          // buffer address 
    mov x8,#FSTAT
    svc 0 
    cmp x0,#0
    blt 98f
    ldr x1,qAdrsBuffer          // buffer address 
    ldr x4,[x1,#Stat_size_t]    // file size
    mov x0,x8
    mov x8,CLOSE 
    mov x0,x4                   // return size
    b 100f
98:
    ldr x0,qAdrszMessErrStat
    bl affichageMess
    mov x0,#-1
    b 100f
99:
    ldr x0,qAdrszMessErrOpen
    bl affichageMess
    mov x0,#-1
100:
    ldp x8,x9,[sp],16        // restaur  registers 
    ldp x6,x7,[sp],16        // restaur  registers 
    ldp x4,x5,[sp],16        // restaur  registers 
    ldp x2,x3,[sp],16        // restaur  registers 
    ldp x1,lr,[sp],16            // restaur  registers
    ret 
/***************************************************/
/*   display multi strings                    */
/***************************************************/
/* x0  contains number strings address */
/* x1 address string1 */
/* x2 address string2 */
/* x3 address string3 */
/* other address on the stack */
/* thinck to add  number other address * 4 to add to the stack */
displayStrings:            // INFO:  displayStrings
    stp x1,lr,[sp,-16]!          // save  registers 
    stp x2,x3,[sp,-16]!          // save  registers 
    stp x4,x5,[sp,-16]!          // save  registers 
    add fp,sp,#48          // save paraméters address (6 registers saved * 4 bytes)
    mov x4,x0              // save strings number
    cmp x4,#0              // 0 string -> end
    ble 100f
    mov x0,x1              // string 1
    bl affichageMess
    cmp x4,#1              // number > 1
    ble 100f
    mov x0,x2
    bl affichageMess
    cmp x4,#2
    ble 100f
    mov x0,x3
    bl affichageMess
    cmp x4,#3
    ble 100f
    mov x3,#3
    sub x2,x4,#4
1:                            // loop extract address string on stack
    ldr x0,[fp,x2,lsl #3]
    bl affichageMess
    subs x2,x2,#1
    bge 1b
100:
    ldp x4,x5,[sp],16        // restaur  registers 
    ldp x2,x3,[sp],16        // restaur  registers 
    ldp x1,lr,[sp],16            // restaur  registers
    ret 
/***************************************************/
/*      ROUTINES INCLUDE                           */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

Output:

~/.../rosetta/asm3 $ filelen64
input.txt File size = 13
../../../input.txt File size = 6

Action!

DOS 2.5

DOS 2.5 returns file size in number of sectors. It is required to read the whole file to calculate its size in bytes.

Library: Action! Tool Kit

INCLUDE "D2:IO.ACT" ;from the Action! Tool Kit

PROC Dir(CHAR ARRAY filter)
  BYTE dev=[1]
  CHAR ARRAY line(255)

  Close(dev)
  Open(dev,filter,6)
  DO
    InputSD(dev,line)
    PrintE(line)
    IF line(0)=0 THEN
      EXIT
    FI
  OD
  Close(dev)
RETURN

CARD FUNC FileSize(CHAR ARRAY src,dst)
  DEFINE BUF_LEN="100"
  BYTE dev=[1]
  BYTE ARRAY buff(BUF_LEN)
  CARD len,size

  size=0
  Close(dev)
  Open(dev,src,4)
  DO
    len=Bget(dev,buff,BUF_LEN)
    size==+len
  UNTIL len#BUF_LEN
  OD
  Close(dev)
RETURN (size)

PROC Main()
  CHAR ARRAY filter="D:*.*", fname="D:INPUT.TXT"
  CARD size

  Put(125) PutE() ;clear screen

  PrintF("Dir ""%S""%E",filter)
  Dir(filter)

  size=FileSize(fname)
  PrintF("Size of ""%S"" is %U bytes%E",fname,size)
RETURN

Output:

Dir "D:*.*"
  DOS     SYS 037
  DUP     SYS 042
  INPUT   TXT 011
617 FREE SECTORS

Size of "D:INPUT.TXT" is 1274 bytes

Sparta DOS X

The Sparta DOS X system stores the size of the file in the directory. The readout of the values is performed with the XIO 39 operation. In the ICAX3, ICAX4, ICAX5 registers values are returned in 24-byte format. Calculation according to the formula: ICAX3 + ICAX4 * 256 + ICAX5 * 65536.

Library: Action! Tool Kit

INCLUDE"REAL.ACT" ;from the Action! Tool Kit

proc MAIN()
 byte array astring
 byte IOCB1=$350,ICAX3=IOCB1+12,ICAX4=IOCB1+13,ICAX5=IOCB1+14
 real A,B,C,FLEN

 open(1,"D:REAL.ACT",4,0) xio(1,0,39,"D:REAL.ACT") close(1)

 IntToReal(ICAX3,FLEN)
 IntToReal(ICAX4,A) astring="256"   ValR(astring,B) RealMult(A,B,C) RealAdd(FLEN,C,FLEN)
 IntToReal(ICAX5,A) astring="65536" ValR(astring,B) RealMult(A,B,C) RealAdd(FLEN,C,FLEN)
 print("Size of REAL.ACT is ") printRD(DEVICE,FLEN) printe(" bytes")
return

Output:

Size of D:REAL.ACT is 4995 bytes

Ada

with Ada.Directories;  use Ada.Directories;
with Ada.Text_IO;      use Ada.Text_IO;

procedure Test_File_Size is
begin
   Put_Line (File_Size'Image (Size ("input.txt")) & " bytes");
   Put_Line (File_Size'Image (Size ("/input.txt")) & " bytes");
end Test_File_Size;

Note that reference to the root directory, if there is any, is OS specific.

Aime

o_(stat("input.txt", ST_SIZE), "\n");
o_("/Cygwin.ico".stat(ST_SIZE), "\n");

ALGOL 68

There is no build in way to find the size of an arbitrary file, especially of the file is a special channel, e.g. a tape device.

Conceptually the procedure

PROC set = (REF FILE file,  INT page, line, character)VOID: ~

could be used to do a binary search find the last page's page number. And if it is known that every page has the same number of lines, and every line has the same number of char[s], and the character set is not compressible, then the size could be quickly calculated. Otherwise every page, and every line would have to be tallied.

It is probably much easier to use some an operating system library. This library is not part of the standard ALGOL 68 language definition.

ARM Assembly

Works with: as version Raspberry Pi
or android 32 bits with application Termux

/* ARM assembly Raspberry PI or android with termux */
/*  program filelen.s   */

 /* REMARK 1 : this program use routines in a include file 
   see task Include a file language arm assembly 
   for the routine affichageMess conversion10 
   see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes                       */
/************************************/
.include "../constantes.inc"

.equ OPEN,      5 
.equ NEWFSTAT,  0xc5

.equ O_RDWR,   0x0002          @ open for reading and writing

/************************************/
/* structure de type   stat  : file infos   */
/************************************/
    .struct  0
Stat_dev_t:               /* ID of device containing file */
    .struct Stat_dev_t + 8
Stat_ino_t:              /* inode */
    .struct Stat_ino_t + 8
Stat_mode_t:              /* File type and mode */
    .struct Stat_mode_t + 4   
Stat_nlink_t:               /* Number of hard links */
    .struct Stat_nlink_t + 4    
Stat_uid_t:               /* User ID of owner */
    .struct Stat_uid_t + 4
Stat_gid_t:                 /* Group ID of owner */
    .struct Stat_gid_t + 4     
Stat_rdev_t:                /* Device ID (if special file) */
    .struct Stat_rdev_t + 8
Stat_size_deb:           /* la taille est sur 8 octets si gros fichiers */
     .struct Stat_size_deb + 8 
Stat_size_t:                /* Total size, in bytes */
    .struct Stat_size_t + 4     
Stat_blksize_t:                /* Block size for filesystem I/O */
    .struct Stat_blksize_t + 4     
Stat_blkcnt_t:               /* Number of 512B blocks allocated */
    .struct Stat_blkcnt_t + 4     
Stat_atime:               /*   date et heure fichier */
    .struct Stat_atime + 8     
Stat_mtime:               /*   date et heure modif fichier */
    .struct Stat_atime + 8 
Stat_ctime:               /*   date et heure creation fichier */
    .struct Stat_atime + 8     
Stat_End:  

/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:       .asciz " File size = "
szCarriageReturn:   .asciz "\n"
szMessErrOpen:      .asciz "Error open file\n"
szMessErrStat:      .asciz "Error stats file\n"
szFileName:         .asciz "input.txt"
szFileName1:        .asciz "../../../input.txt"
.align 2

/*********************************/
/* UnInitialized data            */
/*********************************/
.bss  
sZoneConv:           .skip 24
sBuffer:             .skip Stat_End
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:
    ldr r0,iAdrszFileName       @ file name
    bl filesize
    cmp r0,#0
    blt 100f
    ldr r1,iAdrsZoneConv       
    bl conversion10             @ call décimal conversion
    mov r0,#4
    ldr r1,iAdrszFileName
    ldr r2,iAdrszMessResult
    ldr r3,iAdrsZoneConv        @ insert conversion in message
    ldr r4,iAdrszCarriageReturn
    push {r4}
    bl displayStrings           @ display message
    add sp,#4                   @ 1 parameter on stack 
    
    ldr r0,iAdrszFileName1       @ file name
    bl filesize
    cmp r0,#0
    blt 100f
    ldr r1,iAdrsZoneConv       
    bl conversion10             @ call décimal conversion
    mov r0,#4
    ldr r1,iAdrszFileName1
    ldr r2,iAdrszMessResult
    ldr r3,iAdrsZoneConv        @ insert conversion in message
    ldr r4,iAdrszCarriageReturn
    push {r4}
    bl displayStrings           @ display message
    add sp,#4                   @ 1 parameter on stack 
    
100:                            @ standard end of the program 
    mov r0, #0                  @ return code
    mov r7, #EXIT               @ request to exit program
    svc #0                      @ perform the system call
iAdrszCarriageReturn:    .int szCarriageReturn
iAdrsZoneConv:           .int sZoneConv  
iAdrszMessResult:        .int szMessResult
iAdrszFileName:          .int szFileName 
iAdrszFileName1:         .int szFileName1  
iAdrsBuffer:             .int sBuffer
iAdrszMessErrOpen:       .int szMessErrOpen
iAdrszMessErrStat:       .int szMessErrStat
/***************************************************/
/*   display multi strings                    */
/***************************************************/
/* r0  contains number strings address */
filesize:                       @ INFO:  filesize
    push {r1-r8,fp,lr}          @ save des registres
    mov r1,#O_RDWR              @  flags
    mov r2,#0                   @ mode
    mov r7,#OPEN
    svc 0 
    cmp r0,#0                   @ error ?
    ble 99f
    mov r8,r0                   @ Fd save
    ldr r1,iAdrsBuffer          @ buffer address 
    mov r7,#NEWFSTAT
    svc 0 
    cmp r0,#0
    blt 98f
    ldr r0,iAdrsBuffer
    ldr r1,iAdrsBuffer          @ buffer address 
    ldr r4,[r1,#Stat_size_t]    @ file size
    mov r0,r8
    mov r7,#CLOSE
    mov r0,r4                   @ return size
    b 100f
98:
    ldr r0,iAdrszMessErrStat
    bl affichageMess
    mov r0,#-1
    b 100f
99:
    ldr r0,iAdrszMessErrOpen
    bl affichageMess
    mov r0,#-1
100:
    pop {r1-r8,fp,pc}
/***************************************************/
/*   display multi strings                    */
/***************************************************/
/* r0  contains number strings address */
/* r1 address string1 */
/* r2 address string2 */
/* r3 address string3 */
/* other address on the stack */
/* thinck to add  number other address * 4 to add to the stack */
displayStrings:            @ INFO:  displayStrings
    push {r1-r4,fp,lr}     @ save des registres
    add fp,sp,#24          @ save paraméters address (6 registers saved * 4 bytes)
    mov r4,r0              @ save strings number
    cmp r4,#0              @ 0 string -> end
    ble 100f
    mov r0,r1              @ string 1
    bl affichageMess
    cmp r4,#1              @ number > 1
    ble 100f
    mov r0,r2
    bl affichageMess
    cmp r4,#2
    ble 100f
    mov r0,r3
    bl affichageMess
    cmp r4,#3
    ble 100f
    mov r3,#3
    sub r2,r4,#4
1:                            @ loop extract address string on stack
    ldr r0,[fp,r2,lsl #2]
    bl affichageMess
    subs r2,#1
    bge 1b
100:
    pop {r1-r4,fp,pc}
/***************************************************/
/*      ROUTINES INCLUDE                           */
/***************************************************/
.include "../affichage.inc"

Output:

input.txt File size = 8
../../../input.txt File size = 3

Arturo

print volume "input.txt"
print volume "/input.txt"

AutoHotkey

FileGetSize, FileSize, input.txt  ; Retrieve the size in bytes.
MsgBox, Size of input.txt is %FileSize% bytes
FileGetSize, FileSize, \input.txt, K  ; Retrieve the size in Kbytes.
MsgBox, Size of \input.txt is %FileSize% Kbytes

AWK

Works with: gawk

@load "filefuncs"
function filesize(name         ,fd) {
    if ( stat(name, fd) == -1) 
      return -1  # doesn't exist
    else
      return fd["size"]
}
BEGIN {
    print filesize("input.txt")
    print filesize("/input.txt")
}

Some awk's don't have direct access to the filesystem, but can execute system-commands like dir (DOS/Windows) and ls

BEGIN {

         # Windows
          printf("input.txt\t%s\n", system2var("for %I in (input.txt) do @echo %~zI"))
          printf("\input.txt\t%s\n", system2var("for %I in (\input.txt) do @echo %~zI"))

         # Non-Windows
          printf("input.txt\t%s\n", getline2var("stat --printf=\"%s\" input.txt"))
          printf("/input.txt\t%s\n", getline2var("stat --printf=\"%s\" /input.txt"))
}

# Windows system() method
function system2var(command    ,tempfile, cmd, out, rec, data, i) {
         tempfile = "C:\\TEMP\\TMP.TMP"
         cmd = command " > " tempfile
         system(cmd)
         close(cmd)
         while (getline rec < tempfile > 0) {
             if ( ++i == 1 )
                 data = rec
             else
                 data = data "\n" rec
         }
         return(data)
}

# Non-windows getline method
function getline2var(command        ,fish, scale, ship) {
         command = command " 2>/dev/null"
         while ( (command | getline fish) > 0 ) {
             if ( ++scale == 1 )
                 ship = fish
             else
                 ship = ship "\n" fish
         }
         close(command)
         return ship
}

See also UNIX_Shell]

Axe

If GetCalc("appvINPUT")→I
 Disp {I-2}ʳ▶Dec,i
Else
 Disp "NOT FOUND",i
End

BASIC

BaCon

' file size
' Return the entire message, FILELEN returns a NUMBER
FUNCTION printlen$(STRING name$)
    IF FILEEXISTS(name$) THEN
        RETURN name$ & ": " & STR$(FILELEN(name$))
    ELSE
        RETURN "file " & name$ & " not found"
    END IF
END FUNCTION

PRINT printlen$("input.txt")
PRINT printlen$("/input.txt")

Output:

prompt$ bacon filelen.bac
Converting 'filelen.bac'... done, 12 lines were processed in 0.004 seconds.
Compiling 'filelen.bac'... cc  -c filelen.bac.c
cc -o filelen filelen.bac.o -lbacon -lm
Done, program 'filelen' ready.
prompt$ ./filelen
input.txt: 15
file /input.txt not found

Batch File

Outputs file size of the first parameter (you can drag and drop a file in aswell).

@echo off
if not exist "%~1" exit /b 1 & rem If file doesn't exist exit with error code of 1.
for /f %%i in (%~1) do echo %~zi
pause>nul

BBC BASIC

      file% = OPENIN(@dir$+"input.txt")
      IF file% THEN
        PRINT "File size = " ; EXT#file%
        CLOSE #file%
      ENDIF
      
      file% = OPENIN("\input.txt")
      IF file% THEN
        PRINT "File size = " ; EXT#file%
        CLOSE #file%
      ENDIF

Bracmat

This solution assumes that the file can be opened for reading. The fil function is the Bracmat interface to the underlying C functions fopen, fclose, fseek, ftell, fread, fgetc, fwrite, fputc and feof. More than one file can be opened at the same time. Focus is shifted from one open file to another by mentioning the file name as the first argument.

(getFileSize=
  size
.     fil$(!arg,rb)     {read in binary mode}
    & fil$(,END)        {seek to end of file}
    & fil$(,TEL):?size  {tell where we are}
    & fil$(,SET,-1)     {seeking to an impossible position closes the file, and fails}
  | !size               {return the size}
);

getFileSize$"valid.bra"
113622

getFileSize$"c:\\boot.ini"
211

C

#include <stdlib.h>
#include <stdio.h>

long getFileSize(const char *filename)
{
  long result;
  FILE *fh = fopen(filename, "rb");
  fseek(fh, 0, SEEK_END);
  result = ftell(fh);
  fclose(fh);
  return result;
}

int main(void)
{
  printf("%ld\n", getFileSize("input.txt"));
  printf("%ld\n", getFileSize("/input.txt"));
  return 0;
}

Works with: POSIX

#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>

int main(void)
{
  struct stat foo;
  stat("input.txt", &foo);
  printf("%ld\n", foo.st_size);
  stat("/input.txt", &foo);
  printf("%ld\n", foo.st_size);
  return 0;
}

C#

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(new FileInfo("/input.txt").Length);
        Console.WriteLine(new FileInfo("input.txt").Length);
    }
}

C++

#include <iostream>
#include <fstream>

std::ios::off_type getFileSize(const char *filename) {
  std::ifstream f(filename);
  std::ios::pos_type begin = f.tellg();
  f.seekg(0, std::ios::end);
  std::ios::pos_type end = f.tellg();
  return end - begin;
}

int main() {
  std::cout << getFileSize("input.txt") << std::endl;
  std::cout << getFileSize("/input.txt") << std::endl;
  return 0;
}

optimized

#include <iostream>
#include <fstream>

int main()
{
	std::cout << std::ifstream("input.txt", std::ios::binary | std::ios::ate).tellg() << "\n"
		  << std::ifstream("/input.txt", std::ios::binary | std::ios::ate).tellg() << "\n";
}

C++ 17

#include <filesystem>
#include <iostream>

void print_file_size(const char* filename) {
    try {
        auto size = std::filesystem::file_size(filename);
        std::cout << "Size of file " << filename << " is " << size << " bytes.\n";
    } catch (const std::exception& ex) {
        std::cerr << ex.what() << '\n';
    }
}

int main() {
    print_file_size("input.txt");
    print_file_size("/input.txt");
}

Output:

Size of file input.txt is 506 bytes.
filesystem error: in file_size: No such file or directory [/input.txt]

Clean

There is not function to get the file size, therefore we seek to the end and query the file pointer position.

import StdEnv

fileSize fileName world
    # (ok, file, world) = fopen fileName FReadData world
    | not ok = abort "Cannot open file"
    # (ok, file) = fseek file 0 FSeekEnd
    | not ok = abort "Cannot seek file"
    # (size, file) = fposition file
      (_, world) = fclose file world
    = (size, world)

Start world = fileSize "input.txt" world

Clojure

(require '[clojure.java.io :as io])
(defn show-size [filename]
  (println filename "size:" (.length (io/file filename))))

(show-size "input.txt")
(show-size "/input.txt")

COBOL

       identification division.
       program-id. FileInfo.

       data division.
       working-storage section.
       01  file-name              pic x(256).
       01  file-size-edited       pic zzz,zzz,zzz.
       01  file-details.
           05 file-size           pic x(8) comp-x.
           05 file-date.
              10 file-day         pic x comp-x.
              10 file-month       pic x comp-x.
              10 file-year        pic xx comp-x.
           05 file-time.
              10 file-hour        pic x comp-x.
              10 file-minute      pic x comp-x.
              10 file-second      pic x comp-x.
              10 file-hundredths  pic x comp-x.

       procedure division.
       main.
           move "input.txt" to file-name
           perform file-info
           
           move "\input.txt" to file-name
           perform file-info

           stop run
           .

       file-info.
           call "CBL_CHECK_FILE_EXIST" 
              using file-name, file-details
              returning return-code
           if return-code = 0
              move file-size to file-size-edited
              display function trim(file-name) " "
                      function trim(file-size-edited) " Bytes"
           else
              display function trim(file-name) " not found!"
           end-if
           .

ColdFusion

<cfscript>
  localFile = getFileInfo(expandpath("input.txt"));
  rootFile = getFileInfo("/input.txt");
</cfscript>

<cfoutput>
  Size of input.txt is #localFile.size# bytes.
  Size of /input.txt is #rootFile.size# bytes.
</cfoutput>

Common Lisp

(with-open-file (stream (make-pathname :name "input.txt")
                 :direction :input
                 :if-does-not-exist nil)
  (print (if stream (file-length stream) 0)))
  
(with-open-file (stream (make-pathname :directory '(:absolute "") :name "input.txt")
                 :direction :input
                 :if-does-not-exist nil)
  (print (if stream (file-length stream) 0)))

 (osicat-posix:stat-size (osicat-posix:stat #P"input.txt"))

D

import std.file, std.stdio, std.path, std.file, std.stream,
       std.mmfile;

void main() {
    immutable fileName = "file_size.exe";

    try {
        writefln("File '%s' has size:", fileName);

        writefln("%10d bytes by std.file.getSize (function)",
                 std.file.getSize(fileName));

        writefln("%10d bytes by std.stream (class)",
                 new std.stream.File(fileName).size);

        // mmfile can treat the file as an array in memory.
        writefln("%10d bytes by std.mmfile (class)",
                 new std.mmfile.MmFile(fileName).length);
    } catch (Exception e) {
        e.msg.writefln;
    }
}

Output:

File 'file_size.exe' has size:
   1066164 bytes by std.file.getSize (function)
   1066164 bytes by std.stream (class)
   1066164 bytes by std.mmfile (class)

Delphi

program SizeOfFile;

{$APPTYPE CONSOLE}

uses SysUtils;

function CheckFileSize(const aFilename: string): Integer;
var
  lFile: file of Byte;
begin
  AssignFile(lFile, aFilename);
  FileMode := 0; {Access file in read only mode}
  Reset(lFile);
  Result := FileSize(lFile);
  CloseFile(lFile);
end;

begin
  Writeln('input.txt ', CheckFileSize('input.txt'));
  Writeln('\input.txt ', CheckFileSize('\input.txt'));
end.

E

for file in [<file:input.txt>, <file:///input.txt>] {
  println(`The size of $file is ${file.length()} bytes.`)
}

Eiffel

class
    APPLICATION
create
    make
feature {NONE} -- Initialization
    make
            -- Run application.
        do
            create input_file.make_open_read ("input.txt")
            print(input_file.count)
            print("%N")
            input_file.close
            create environment
            input_file.make_open_read(environment.root_directory_name + "input.txt")
            print(input_file.count)
            input_file.close
        end
feature -- Access
    input_file: PLAIN_TEXT_FILE
    environment:EXECUTION_ENVIRONMENT
end

Elena

ELENA 4.x :

import system'io;
import extensions;
 
public program()
{
    console.printLine(File.assign("input.txt").Length);
 
    console.printLine(File.assign("\input.txt").Length)
}

Elixir

IO.puts File.stat!("input.txt").size
IO.puts File.stat!("/input.txt").size

Emacs Lisp

This shows nil if no such file since file-attributes returns nil in that case.

(message "sizes are %s and %s"
         (nth 7 (file-attributes "input.txt"))
         (nth 7 (file-attributes "/input.txt")))

Erlang

-module(file_size).
-export([file_size/0]).

-include_lib("kernel/include/file.hrl").

file_size() ->
    print_file_size("input.txt"),
    print_file_size("/input.txt").

print_file_size(Filename) ->
    case file:read_file_info(Filename) of
	{ok, FileInfo} ->
	    io:format("~s ~p~n", [Filename, FileInfo#file_info.size]);
	{error, _} ->
	    io:format("~s could not be opened~n",[Filename])
    end.

Euphoria

include file.e

function file_size(sequence file_name)
    object x
    x = dir(file_name)
    if sequence(x) and length(x) = 1 then
        return x[1][D_SIZE]
    else
        return -1 -- the file does not exist
    end if
end function

procedure test(sequence file_name)
    integer size
    size = file_size(file_name)
    if size < 0 then
        printf(1,"%s file does not exist.\n",{file_name})
    else
        printf(1,"%s size is %d.\n",{file_name,size})
    end if
end procedure

test("input.txt") -- in the current working directory
test("/input.txt") -- in the file system root

F#

open NUnit.Framework
open FsUnit

[<Test>]
let ``Validate that the size of the two files is the same`` () =
  let local = System.IO.FileInfo(__SOURCE_DIRECTORY__ + "\input.txt")
  let root = System.IO.FileInfo(System.IO.Directory.GetDirectoryRoot(__SOURCE_DIRECTORY__) + "input.txt")
  local.Length = root.Length |> should be True

Factor

"input.txt" file-info size>> .
    1321
"file-does-not-exist.txt" file-info size>>
 "Unix system call ``stat'' failed:"...

FBSL

FileLen returns -1 if the file is not found. FileLen will also accept a file handle and give the file length of the open file.

#APPTYPE CONSOLE

print FileLen("sync.log")
print FileLen("\sync.log")
PAUSE

Forth

: .filesize ( addr len -- ) 2dup type ."  is "
  r/o open-file throw
  dup file-size throw  <# #s #> type ."  bytes long." cr
  close-file throw ;

 s" input.txt" .filesize
s" /input.txt" .filesize

Fortran

Since Fortran 95 the size of standard external files may be determined simply by using INQUIRE(SIZE=...). The following previous example pertains to FORTRAN 77 and is now superceded.

    use :: iso_fortran_env, only : FILE_STORAGE_SIZE
    implicit none
    character(len=*),parameter :: filename(*)=[character(len=256) :: 'input.txt', '/input.txt']
    integer                    :: file_size, i
    do i=1,size(filename)
       INQUIRE(FILE=filename(i), SIZE=file_size)  ! return -1 if cannot determine file size
       write(*,*)'size of file '//trim(filename(i))//' is ',file_size * FILE_STORAGE_SIZE /8,' bytes'
    enddo
    end

The original example, now obsolete ...

Alas, although there is a statement INQUIRE(FILE="Input.txt",EXIST = ISTHERE, RECL = RL, etc.) whereby a logical variable ISTHERE has a value (output: assigned left-to-right) according to whether a named file (input: assignment right-to-left) exists or not, and the parameter RECL returns the maximum allowed record length for the file, there is no parameter that reports how many records there are in the file so that the file size remains unknowable. Further, the value returned by RECL is not necessarily related to the file itself, but is likely to be a standard value such as 132, a default used when deciding on the line wrap length with free-format output as in WRITE (6,*) stuff but not necessarily being a limit on the length of a line written or read.

Further, in the ASCII world, text files are often implemented as variable-length records with special characters inline as record boundaries, usually one of CR, CRLF, LFCR, or LF. Without knowing which is in use, the storage taken up by them would be unknown. Other file systems may offer different types of disc files with fixed-size records or variable length records with a record length counter, but this is not standard across all computers.

In other words, Fortran does not specify a linkage to the filesystem whereby these details could be revealed, and not all filesystems maintain them anyway.

But if one wrote Fortran on a B6700 system, its F77 compiler offered additional attributes that could be returned via an INQUIRE statement: MAXRECSIZE really was the length of the longest record in the disc file (whether fixed record lengths or variable record lengths), BLOCKSIZE reported the number of records per block of disc space, AREASIZE the size of a disc space allocation area, and AREAS their number, while KIND reveals the code number of the type of file (not via a .txt suffix or whatever). Armed with these values, the file size could be determined in bits, bytes, words (six characters/word), records, blocks and areas.

These facilities were not carried forward into standardised Fortran 90, etc. So, one is stuck with devising a routine that reads all the records of a disc file, counting their length. This is straightforward, but tedious, as in the following fragment:

   20     READ (INF,21, END = 30) L	!R E A D  A  R E C O R D - but only its length.
   21     FORMAT(Q)			!This obviously indicates the record's length.
          NRECS = NRECS + 1	!CALL LONGCOUNT(NRECS,1)	!C O U N T  A  R E C O R D.
          NNBYTES = NNBYTES + L	!CALL LONGCOUNT(NNBYTES,L)	!Not counting any CRLF (or whatever) gibberish.
          IF (L.LT.RMIN) THEN		!Righto, now for the record lengths.
            RMIN = L			!This one is shorter.
            RMINR = NRECS		!Where it's at.
          ELSE IF (L.GT.RMAX) THEN	!Perhaps instead it is longer?
            RMAX = L			!Longer.
            RMAXR = NRECS		!Where it's at.
          END IF			!So much for the lengths.
          GO TO 20			!All I wanted to know...

The LONGCOUNT routine uses two 32-bit integers (the first parameter being a two-element array) to deliver a much larger capacity, given modern file size opportunities, but this is unnecessary if INTEGER*8 variables are available. The count will not include any contribution from record splitters such as CR, etc. A file more properly thought of as containing binary data (say, integer or floating-point values) will by chance have a CR or LF bit pattern here and there, and they will be taken as marking record splits when reading a file as being FORMATTED, which is the default setting.

FreeBASIC

' FB 1.05.0 Win64

#include "file.bi"

Print FileLen("input.txt"), FileLen(Environ("SystemRoot") + "\input.txt")
Sleep

Frink

println[newJava["java.io.File", "input.txt"].length[]]
println[newJava["java.io.File", "/input.txt"].length[]]

FutureBasic

local fn DoIt
  CFURLRef desktopURL = fn FileManagerURLForDirectory( NSDesktopDirectory, NSUserDomainMask )
  CFURLRef        url = fn URLByAppendingPathComponent( desktopURL, @"test_file.txt" )
  CFDictionaryRef attributes = fn FileManagerAttributesOfItemAtURL( url )
  printf @"%@", fn DictionaryObjectForKey( attributes, NSFileSize )
end fn

fn DoIt

HandleEvents

Gambas

Public Sub Main()
Dim stInfo As Stat = Stat(User.home &/ "input.txt")
Dim stInfo1 As Stat = Stat("/input.txt")

Print User.Home &/ "input.txt = " & stInfo.Size & " bytes"
Print "/input.txt = " & stInfo1.Size & " bytes"

End

Output:

/home/charlie/input.txt = 121 bytes
/input.txt = 32 bytes

Go

package main

import "fmt"
import "os"

func printFileSize(f string) {
    if stat, err := os.Stat(f); err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(stat.Size())
    }
}

func main() {
    printFileSize("input.txt")
    printFileSize("/input.txt")
}

Groovy

println new File('index.txt').length();
println new File('/index.txt').length();

Haskell

import System.IO

printFileSize filename = withFile filename ReadMode hFileSize >>= print

main = mapM_ printFileSize ["input.txt", "/input.txt"]

or

import System.Posix.File

printFileSize filename = do stat <- getFileStatus filename
                            print (fileSize stat)

main = mapM_ printFileSize ["input.txt", "/input.txt"]

HicEst

READ(FILE="input.txt", LENgth=bytes) ! bytes = -1 if not existent
READ(FILE="C:\input.txt", LENgth=bytes) ! bytes = -1 if not existent

Icon and Unicon

Icon doesn't support 'stat'; however, information can be obtained by use of the system function to access command line.

every dir := !["./","/"] do {
   write("Size of ",f := dir || "input.txt"," = ",stat(f).size)  |stop("failure for to stat ",f) 
   }

Note: Icon and Unicon accept both / and \ for directory separators.

J

require 'files'
fsize 'input.txt';'/input.txt'

Jakt

fn file_size(filename: String) throws -> i64 {
    mut result = 0
    mut file = File::open_for_reading(filename)
    mut buffer = [0u8; 1024] // Size of buffer is arbitrary
    while true {
        let read_bytes = file.read(buffer)
        if read_bytes == 0 {
            break
        }
        result += read_bytes as! i64
    }
    return result
}


fn main() {
    println("{}", file_size(filename: "input.txt"))
    println("{}", file_size(filename: "/input.txt"))
}

Java

import java.io.File;

public static void main(String[] args) {
    File fileA = new File("file.txt");
    System.out.printf("%,d B%n", fileA.length());
    File fileB = new File("/file.txt");
    System.out.printf("%,d B%n", fileB.length());
}

108 B
108 B

JavaScript

Works with: JScript

var fso = new ActiveXObject("Scripting.FileSystemObject");
fso.GetFile('input.txt').Size;
fso.GetFile('c:/input.txt').Size;

The following works in all browsers, including IE10.

var file = document.getElementById("fileInput").files.item(0); //a file input element
if (file) {
	var reader = new FileReader();
	reader.readAsText(file, "UTF-8");
	reader.onload = loadedFile;
	reader.onerror = errorHandler;
}
function loadedFile(event) {
	var fileString = event.target.result;
	alert(fileString.length);
}
function errorHandler(event) {
	alert(event);
}

Joy

DEFINE filesize == "r" fopen 0 2 fseek pop ftell swap fclose.

"input.txt" filesize.
"/input.txt" filesize.

jq

jq -Rs length input.txt

jq -Rs length /input.txt

The -R option causes the file to be read as text, and the -s option causes it to be read as a single string.

Julia

println(filesize("input.txt"))
println(filesize("/input.txt"))

K

_size "input.txt"
_size "/input.txt"

Kotlin

// version 1.0.6

import java.io.File

fun main(args: Array<String>) {
    val paths = arrayOf("input.txt", "c:\\input.txt")
    for (path in paths) 
        println("Length of $path is ${File(path).length()} bytes")
}

Lang

Library: lang-io-module

# Load the IO module
# Replace "<pathToIO.lm>" with the location where the io.lm Lang module was installed to without "<" and ">"
ln.loadModule(<pathToIO.lm>)

$file1 = [[io]]::fp.openFile(input.txt)
fn.println([[io]]::fp.getSize($file1))
[[io]]::fp.closeFile($file1) # Remember to close files

$file2 = [[io]]::fp.openFile(/input.txt)
fn.println([[io]]::fp.getSize($file2))
[[io]]::fp.closeFile($file2)

Lasso

// local to current directory
local(f = file('input.txt'))
handle => { #f->close }
#f->size

// file at file system root
local(f = file('//input.txt'))
handle => { #f->close }
#f->size

Liberty BASIC

'input.txt in current directory
OPEN DefaultDir$ + "/input.txt" FOR input AS #m
PRINT "File size: "; lof(#m)
CLOSE #m

'input.txt in root
OPEN "c:/input.txt" FOR input AS #m
PRINT "File size: "; lof(#m)
CLOSE #m

Lingo

----------------------------------------
-- Returns file size
-- @param {string} filename
-- @return {integer}
----------------------------------------
on getFileSize (filename)
  fp = xtra("fileIO").new()
  fp.openFile(filename, 1)
  if fp.status() then return 0
  len = fp.getLength()
  fp.closeFile()
  return len
end

LiveCode

// root folder
set the defaultfolder to "/"
repeat for each line fline in (the detailed files)
    if item 1 of fline is "input.txt" then
        put item 2 of fline --bytes
        exit repeat
    end if
end repeat

// current working dir of stack
put the effective filename of this stack into tPath
set the itemDelimiter to slash
delete last item of tPath
set the defaultfolder to tPath
repeat for each line fline in (the detailed files)
    if item 1 of fline is "input.txt" then
        put item 2 of fline 
        exit repeat
    end if
end repeat

Lua

function GetFileSize( filename )
    local fp = io.open( filename )
    if fp == nil then 
 	return nil 
    end
    local filesize = fp:seek( "end" )
    fp:close()
    return filesize
end

M2000 Interpreter

Version 12 can convert numbers to string if a string exist in expression. Functions or arithmetic expressions must be in parenthesis (see filelen()). Older versions has to use ; (for print only):

print filename+" has size ";filelen(filename);" bytes"

Module ShowFileSize(filename as string) {
	if exist(filename) then
		print filename+" has size "+(filelen(filename))+" bytes"
	else
		print filename+ " not exist"
	end if
}
ShowFileSize "checkthis.txt"
ShowFileSize "c:\ok.txt"

Maple

FileTools:-Size( "input.txt" )

FileTools:-Size( "/input.txt" )

Mathematica / Wolfram Language

FileByteCount["input.txt"]
FileByteCount[FileNameJoin[{$RootDirectory, "input.txt"}]]

MATLAB / Octave

d1 = dir('input.txt');
d2 = dir('/input.txt');
fprintf('Size of input.txt is %d bytes\n', d1.bytes)
fprintf('Size of /input.txt is %d bytes\n', d2.bytes)

MAXScript

-- Returns filesize in bytes or 0 if the file is missing
getFileSize "index.txt"
getFileSize "\index.txt"

Mirah

import java.io.File

puts File.new('file-size.mirah').length()
puts File.new("./#{File.separator}file-size.mirah").length()

mIRC Scripting Language

echo -ag $file(input.txt).size bytes
echo -ag $file(C:\input.txt).size bytes

Modula-3

MODULE FSize EXPORTS Main;

IMPORT IO, Fmt, FS, File, OSError;

VAR fstat: File.Status;

BEGIN
  TRY
    fstat := FS.Status("input.txt");
    IO.Put("Size of input.txt: " & Fmt.LongInt(fstat.size) & "\n");
    fstat := FS.Status("/input.txt");
    IO.Put("Size of /input.txt: " & Fmt.LongInt(fstat.size) & "\n");
  EXCEPT
  | OSError.E => IO.Put("ERROR: Could not get file status.\n");
  END;
END FSize.

Nanoquery

import Nanoquery.IO
println new(File, "input.txt").length()
println new(File, "/input.txt").length()

NetRexx

/* NetRexx */
options replace format comments java symbols binary

runSample(arg)
return

-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method fileSize(fn) public static returns double
  ff = File(fn)
  fSize = ff.length()
  return fSize

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static
  parse arg files
  if files = '' then files = 'input.txt F docs D /input.txt F /docs D'
  loop while files.length > 0
    parse files fn ft files
    select case(ft.upper())
      when 'F' then do
        ft = 'File'
        end
      when 'D' then do
        ft = 'Directory'
        end
      otherwise do
        ft = 'File'
        end
      end
    sz = fileSize(fn)
    say ft ''''fn'''' sz 'bytes.'
    end

  return

Output:

J:\>nrc fsz
java -cp "c:\netRexx\lib\NetRexxR.jar;c:\netRexx\lib\NetRexxC.jar;.;C:\Program Files\BSF4ooRexx\bsf4ooRexx-v452-20150825-bin.jar;;c:\netrexx\lib\NetRexxF.jar;." -Dnrx.compiler=ecj org.netrexx.process.NetRexxC  fsz
NetRexx portable processor 3.04 GA build 4-20150630-1657
Copyright (c) RexxLA, 2011,2015.   All rights reserved.
Parts Copyright (c) IBM Corporation, 1995,2008.
Program fsz.nrx
    function fileSize(Rexx)
    function runSample(Rexx)
Compilation of 'fsz.nrx' successful

J:\>java fsz test.txt
File 'test.txt' 8 bytes.

NewLISP

(println (first (file-info "input.txt")))
(println (first (file-info "/input.txt")))

Nim

import os
echo getFileSize "input.txt"
echo getFileSize "/input.txt"

Nu

Works with: Nushell version 0.97.1

(ls -D 'input.txt').0.size

(ls -D '/input.txt').0.size

Objeck

use IO;
...
File("input.txt")->Size()->PrintLine();
File("c:\input.txt")->Size()->PrintLine();

Objective-C

NSFileManager *fm = [NSFileManager defaultManager];

// Pre-OS X 10.5
NSLog(@"%llu", [[fm fileAttributesAtPath:@"input.txt" traverseLink:YES] fileSize]);

// OS X 10.5+
NSLog(@"%llu", [[fm attributesOfItemAtPath:@"input.txt" error:NULL] fileSize]);

OCaml

let printFileSize filename =
  let ic = open_in filename in
  Printf.printf "%d\n" (in_channel_length ic);
  close_in ic ;;

printFileSize "input.txt" ;;
printFileSize "/input.txt" ;;

For files greater than max_int, one can use the module Stdlib.LargeFile:

let printLargeFileSize filename =
  let ic = open_in filename in
  Printf.printf "%Ld\n" (LargeFile.in_channel_length ic);
  close_in ic ;;

Alternatively:

#load "unix.cma" ;;
open Unix ;;
Printf.printf "%d\n" (stat "input.txt").st_size ;;
Printf.printf "%d\n" (stat "/input.txt").st_size ;;

The module Unix has also a LargeFile sub-module.

Oforth

File new("input.txt") size println
File new("/input.txt") size println

ooRexx

Parse Version v
Say v
fid='test.txt'
x=sysfiletree(fid,a.)
Say a.0
Say a.1
Say left(copies('123456789.',10),length(a.1))
Parse Var a.1 20 size .
Say 'file size:' size
s=charin(fid,,1000)
Say length(s)
Say 'file' fid
'type' fid

Output:

J:\>rexx sft
REXX-ooRexx_4.2.0(MT)_64-bit 6.04 22 Feb 2014
1
 7/26/16   3:28p           8  A----  J:\test.txt
123456789.123456789.123456789.123456789.12345678
file size: 8
8
file test.txt
12
34

Oz

declare
  [Path] = {Module.link ['x-oz://system/os/Path.ozf']}
in
  {Show {Path.size "input.txt"}}
  {Show {Path.size "/input.txt"}}

Pascal

See Delphi

Here we use .NET System.IO FileInfo type

PascalABC.NET

uses System.IO;

begin
  FileInfo.Create('input.txt').Length.Println;
  FileInfo.Create('/input.txt').Length.Println;
end.

Perl

my $size1 = -s 'input.txt';
my $size2 = -s '/input.txt';

Or, to be 100% cross-platform:

use File::Spec::Functions qw(catfile rootdir);
my $size1 = -s 'input.txt';
my $size2 = -s catfile rootdir, 'input.txt';

Alternative way to get the size:

my $size1 = (stat 'input.txt')[7];  # builtin stat() returns an array with file size at index 7
my $size2 = (stat '/input.txt')[7];

Phix

Library: Phix/basics

function file_size(sequence file_name)
object d = dir(file_name)
    if atom(d) or length(d)!=1 then return -1 end if
    return d[1][D_SIZE]
end function
 
procedure test(sequence file_name)
integer size = file_size(file_name)
    if size<0 then
        printf(1,"%s file does not exist.\n",{file_name})
    else
        printf(1,"%s size is %d.\n",{file_name,size})
    end if
end procedure
 
test("input.txt") -- in the current working directory
test("/input.txt") -- in the file system root

PHP

<?php
echo filesize('input.txt'), "\n";
echo filesize('/input.txt'), "\n";
?>

PicoLisp

(println (car (info "input.txt")))
(println (car (info "/input.txt")))

Pike

import Stdio;
 
int main(){
   write(file_size("input.txt") + "\n");
   write(file_size("/input.txt") + "\n");
}

PL/I

/* To obtain file size of files in root as well as from current directory. */

test: proc options (main);
   declare ch character (1);
   declare i fixed binary (31);
   declare in1 file record;

   /* Open a file in the root directory. */
   open file (in1) title ('//asd.log,type(fixed),recsize(1)');
   on endfile (in1) go to next1;
   do i = 0 by 1;
      read file (in1) into (ch);
   end;
next1:
   put skip list ('file size in root directory =' || trim(i));
   close file (in1);

   /* Open a file in the current dorectory. */
   open file (in1) title ('/asd.txt,type(fixed),recsize(1)');
   on endfile (in1) go to next2;
   do i = 0 by 1;
      read file (in1) into (ch);
   end;
next2:
   put skip list ('local file size=' || trim(i));
end test;

I used differently-named files to prove that local and root directory
files were accessed.
This program ran with Windows PL/I.

Pop11

;;; prints file size in bytes
sysfilesize('input.txt') =>
sysfilesize('/input.txt') =>

PostScript

status returns status information about a file if given a file name. This includes the size in pages (implementation-dependent), the size in bytes, creation and modification time and a final true. The values not needed here are simply poped off the stack.

(input.txt  ) print
(input.txt) status pop pop pop = pop
(/input.txt ) print
(/input.txt) status pop pop pop = pop

PowerShell

Get-ChildItem input.txt | Select-Object Name,Length
Get-ChildItem \input.txt | Select-Object Name,Length

PureBasic

Debug FileSize("input.txt")
Debug FileSize("/input.txt")

Python

import os

size = os.path.getsize('input.txt')
size = os.path.getsize('/input.txt')

R

Works with: R version 2.8.1

R has a function file.info() in the base package that performs this function. Note that regardless of the OS, R uses forward slashes for the directories.

sizeinwd <- file.info('input.txt')[["size"]]
sizeinroot <- file.info('/input.txt')[["size"]]

Racket

#lang racket
(file-size "input.txt")
(file-size "/input.txt")

Raku

(formerly Perl 6)

Works with: Rakudo version 2015.12

say 'input.txt'.IO.s;
say '/input.txt'.IO.s;

Cross-platform version of the second one:

say $*SPEC.rootdir.IO.child("input.txt").s;

RapidQ

File I/O is one of the things where RapidQ differs from standard Basic. RapidQ uses file streams.

Method 1: display file size using file streams

$INCLUDE "rapidq.inc"

DIM file AS QFileStream

FUNCTION fileSize(name$) AS Integer
    file.Open(name$, fmOpenRead)
    Result = file.Size
    file.Close
END FUNCTION

PRINT "Size of input.txt is "; fileSize("input.txt")
PRINT "Size of \input.txt is "; fileSize("\input.txt")

Method 2: using DIR$

FileName$ = DIR$("input.txt", 0)
PRINT "Size of input.txt is "; FileRec.Size
FileName$ = DIR$("\input.txt", 0)
PRINT "Size of \input.txt is "; FileRec.Size

Raven

'input.txt'  status.size
'/input.txt' status.size

REBOL

size? %info.txt
size? %/info.txt
size? ftp://username:password@ftp.site.com/info.txt
size? http://rosettacode.org

Red

>> size? %input.txt
== 39244
>> size? %/c/input.txt
== 39244

Retro

The simple way is to open and read the size. This may crash if the file does not exist.

with files'
"input.txt" :R open &size sip close drop putn
"/input.txt" :R open &size sip close drop putn

For added stability, check that the returned file handle is not zero:

with files'
"input.txt" :R open over 0 <> [ &size sip close drop ] ifTrue

Or, if you need to do this more often, setup a function that'll also display an error message if the file does not exist:

with files'
: getFileSize ( $-n )
  :R open 0 over =
  [ "File does Not Exist\n" puts ]
  [ &size sip close drop ] if ;

"input.txt" getFileSize putn
"/input.txt" getFileSize putn

REXX

MS DOS version 1

This REXX example was executed on a Windows/XP and also a Windows 7 system (in a DOS window),   and
it reports the file's size (in bytes) for both of the required files.

Various REXXes were used for testing:   Regina,   PERSONAL REXX,   PC/REXX,   and   R4.

Note that some operating systems don't have a concept of a   current directory   or a   file system root.

/*REXX program determines a file's size (by reading all the data) in current dir & root.*/
parse arg iFID .                                 /*allow the user specify the  file ID. */
if iFID=='' | iFID==","  then iFID='input.txt'   /*Not specified?  Then use the default.*/
say 'size of     'iFID   "="   fSize(iFID)         'bytes'      /*the current directory.*/
say 'size of \..\'iFID   "="   fSize('\..\'iFID)   'bytes'      /* "    root      "     */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
fSize: parse arg f;   $=0;   do while chars(f)\==0;    $ = $ + length( charin( f, , 1e4) )
                             end   /*while*/;          call lineout f      /*close file.*/
       return $

output   when using the default input:

size of     input.txt = 40 bytes
size of \..\input.txt = 40 bytes

MS DOS version 2

/*REXX pgm to verify a file's size */
parse arg iFID .                       /*let user specify the file ID.  */
if iFID==''  then iFID="FILESIZ.DAT"   /*Not specified? Then use default*/
say 'size of' iFID':'
Say chars(ifid) '(CR LF included)'
Call lineout ifid /* close the file */
say filesize(ifid) '(net data)'
Call lineout ifid
exit

filesize:  parse arg f;
  sz=0;
  Do while lines(f)\==0
    sz=sz+length(linein(f))
    End
  return sz

Output:

size of FILESIZ.DAT:
4 (CR LF included)
2 (net data)

CMS version

Note that CMS hasn't a concept of a root.
Also note that the CMS system doesn't normally support the use of periods (.);   it uses blanks instead.

/*REXX program determines a file's size (by reading all the data)  on the default mDisk.*/
parse arg iFID                                   /*allow the user specify the  file ID. */
if iFID=='' | iFID==","  then iFID= 'INPUT TXT'  /*Not specified?  Then use the default.*/
say 'size of'     iFID     "="     fSize(iFID)     'bytes'       /*on the default mDisk.*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
fSize: parse arg f;    $= 0;      do while lines(f)\==0;        $= $ + length( linein(f) )
                                  end   /*while*/
       return $

Ring

See len(read('input.txt')) + nl
see len(read('/input.txt')) + nl

Ruby

size = File.size('input.txt')
size = File.size('/input.txt')

Run BASIC

print fileSize(DefaultDir$,"input.txt")  ' current default directory
print fileSize("","input.txt")       ' root directory

function fileSize(dir$,file$)
open dir$;"\";file$ FOR input as #f
fileSize = lof(#f)                   ' Length Of File
close #f
end function

Rust

use std::{env, fs, process};
use std::io::{self, Write};
use std::fmt::Display;

fn main() {
    let file_name = env::args().nth(1).unwrap_or_else(|| exit_err("No file name supplied", 1));
    let metadata = fs::metadata(file_name).unwrap_or_else(|e| exit_err(e, 2));

    println!("Size of file.txt is {} bytes", metadata.len());
}

#[inline]
fn exit_err<T: Display>(msg: T, code: i32) -> ! {
    writeln!(&mut io::stderr(), "Error: {}", msg).expect("Could not write to stdout");
    process::exit(code)
}

}

S-BASIC

The CP/M operating system -- S-BASIC's native environment -- reports file size as the number of 128-byte records. CP/M also has no notion of a "root" directory, user area 0 on drive A (the default on boot-up) being the closest analog. Although S-BASIC has a built-in SIZE function, it returns the number of blocks (allocation groups) occupied by the file -- which varies with the disk format -- and even then gives the wrong answer if a directory entry controls more than one 16K logical extent.

rem  Set the logged drive ('A' to 'P')
procedure setdrive (drive = char)
   var hl, de, bc, a_psw = integer
   rem -- make sure drive letter is upper case!
   if drive >= 'a' then drive = drive - 32
   hl = 0
   de = drive - 65
   bc = 0EH
   a_psw = 0
   call (5H,hl,de,bc,a_psw)
end

rem  Set the CP/M user area (0 to 15)
procedure setuser (user = integer)
   var hl, bc, a_psw = integer
   hl = 0
   bc = 20H
   a_psw = 0
   call (5H,hl,user,bc,a_psw)
end

comment
   Return size of named file as number of 128-byte records;
   assumes file name is upper case. If the file does not
   exist, the size will be reported as 0.
end
function fsize(filename = string:20) = integer
    var hl, de, bc, a_psw, p = integer
    based fname = string:20
    based sz = integer
    dim byte workfcb(36)
    location array de = workfcb
    base fname at de
    base sz at de + 33
    fname = fcb$(filename)
    rem  See if drive was specified and set FCB accordingly
    p = instr(1,filename,":")
    if p = 0 then
    	workfcb(0) = 0
    else
      workfcb(0) = asc(mid(filename,p-1,1)) - 64
    bc = 23H			  rem  BDOS filesize function
    call (5,hl,de,bc,a_psw)     rem  result stored in sz
end = sz

rem  Exercise the function

var filename = string:20
filename = "INPUT.TXT"  
rem  First check current drive and user
print filename;" occupies";fsize(filename)*128;" bytes"
rem  Then check startup directory (A0:)
setdrive 'A'
setuser 0
print "A0:INPUT.TXT occupies";fsize(filename)*128;" bytes"

end

Output:

Although both instances of INPUT.TXT consist of a single line ("The quick brown fox jumps over the lazy red dog") they will each be reported as occupying a 128-byte record.

INPUT.TXT occupies 128 bytes
A0:INPUT.TXT occupies 128 bytes

Scala

Library: Scala

import java.io.File

object FileSize extends App {
  val name = "pg1661.txt"

  println(s"$name  : ${new File(name).length()} bytes")
  println(s"/$name : ${new File(s"${File.separator}$name").length()} bytes")
}

Scheme

(define (file-size filename)
  (call-with-input-file filename (lambda (port)
    (let loop ((c (read-char port))
               (count 0))
      (if (eof-object? c) 
          count
          (loop (read-char port) (+ 1 count)))))))

(file-size "input.txt")
(file-size "/input.txt")

Seed7

$ include "seed7_05.s7i";

const proc: main is func
  begin
    writeln(fileSize("input.txt"));
    writeln(fileSize("/input.txt"));
  end func;

Sidef

say (Dir.cwd  + %f'input.txt' -> size);
say (Dir.root + %f'input.txt' -> size);

Slate

(File newNamed: 'input.txt') fileInfo fileSize.
(File newNamed: '/input.txt') fileInfo fileSize.

Smalltalk

Works with: GNU Smalltalk

(File name: 'input.txt') size printNl.
(File name: '/input.txt') size printNl.

Works with: Smalltalk/X

Works with: VisualWorks Smalltalk

'input.txt' asFilename fileSize
'/input.txt' asFilename fileSize

Standard ML

val size = OS.FileSys.fileSize "input.txt" ;;
val size = OS.FileSys.fileSize "/input.txt" ;

Stata

To get the size in byte of an arbitrary file, use file seek. Just replace input.txt with \input.txt if the file resides in the root directory of the current disk.

file open f using input.txt, read binary
file seek f eof
file seek f query
display r(loc)
file close f

However, what is usually interesting is the size of a datatset. Use describe, either on the currently loaded dataset, or on a dataset on disk. The describe command will print the file size, but it's possible to use stored results as well.

describe using test.dta
display r(N)*r(width)

Tcl

file size input.txt
file size /input.txt

Toka

A trivial method follows:

" input.txt"  "R" file.open dup file.size . file.close
" /input.txt" "R" file.open dup file.size . file.close

A better method would be to define a new function that actually checks whether the file exists:

[ "R" file.open
  dup 0 <> [ dup file.size . file.close ] ifTrue
  drop
] is display-size

" input.txt"  display-size
" /input.txt" display-size

TorqueScript

--Ipquarx June 19th, 10:00 AM

Since TorqueScript cannot set the current working directory, the second part of the task cannot be completed.

TGE Version (Works with all versions containing the basic file i/o):

Works with: TGE

%File = new FileObject();
%File.openForRead("input.txt");

while(!%File.isEOF())
{
	%Length += strLen(%File.readLine());
}

%File.close();
%File.delete();

T3D Version (Only works with T3D):

Works with: T3D

fileSize("input.txt");

TUSCRIPT

$$ MODE TUSCRIPT
-- size of file input.txt
file="input.txt"
ERROR/STOP OPEN (file,READ,-std-)
file_size=BYTES ("input.txt")
ERROR/STOP CLOSE (file)

-- size of file x:/input.txt
ERROR/STOP OPEN (file,READ,x)
file_size=BYTES (file)
ERROR/STOP CLOSE (file)

UNIX Shell

An interactive user would run ls -l input.txt /input.txt to see the file sizes. This task is more difficult for a shell script, that must extract each size from command output.

Using ls

ls most likely gets the length from the file's inode.

size1=$(ls -l input.txt | tr -s ' ' | cut -d ' ' -f 5)
size2=$(ls -l /input.txt | tr -s ' ' | cut -d ' ' -f 5)

ls -l reports the size in 5th field, with spaces between fields. tr squeezes spaces (because cut needs one single space between fields), and cut extracts 5th field.

echo "# ls:" 
ls  -la  input.txt

echo "# stat:" 
stat input.txt

echo "# Size:" 
size1=$(ls -l input.txt | tr -s ' ' | cut -d ' ' -f 5)
size2=$(wc -c < input.txt | tr -d ' ')
echo $size1, $size2

Output:

Test run at compileonline.com

# ls:
-rw-r--r-- 1 apache apache 126 Nov  5 19:02 input.txt
# stat:
  File: `input.txt'
  Size: 126       	Blocks: 8          IO Block: 4096   regular file
Device: 700h/1792d	Inode: 2195776     Links: 1
Access: (0644/-rw-r--r--)  Uid: (   48/  apache)   Gid: (   48/  apache)
Access: 2014-11-05 19:02:25.000000000 -0600
Modify: 2014-11-05 19:02:25.000000000 -0600
Change: 2014-11-05 19:02:25.000000000 -0600
# Size:
126, 126

Using wc

wc may actually read the whole file and count the bytes. Some implementations, like wc.c from GNU coreutils, can optimize wc -c by getting the length from the file's inode.

size1=$(wc -c < input.txt | tr -d ' ')
size2=$(wc -c < /input.txt | tr -d ' ')

The peculiar use of wc -c < file, not wc -c file, is to prevent printing the file's name. Then wc only reports the size. Some versions of wc print spaces before the number; tr deletes all these spaces.

Using BSD stat

BSD has stat(1), a nonstandard command. With stat, a shell script can easily get the file size.

Works with: NetBSD version 1.6

Works with: FreeBSD version 4.10

Works with: OpenBSD version 3.8

size1=$(stat -f %z input.txt)
size2=$(stat -f %z /input.txt)

Z Shell

Works with: zsh

# from module 'zsh/stat', load builtin 'zstat'
zmodload -F zsh/stat b:zstat

size1=$(zstat +size input.txt)
size2=$(zstat +size /input.txt)

Sh builtins only

Tested on Alpine Busybox v1.35.0, passes shellcheck 0.8.0.

#!/bin/sh
unset PATH # No cheating!

countbytes(){
	size=0

	# Read the lines in the file
	while read -r;do
		size=$((size+${#REPLY}+1)) # +1 to account for the newline
	done < "$1"
	size=$((size+${#REPLY})) # Account for partial lines

	echo "$size $1"
}

countbytes input.txt
countbytes /input.txt

Ursa

decl file f

f.open "input.txt"
out (size f) endl console
f.close

f.open "/input.txt"
out (size f) endl console
f.close

VBScript

Works with: Windows Script Host version *

With CreateObject("Scripting.FileSystemObject")
	WScript.Echo .GetFile("input.txt").Size
	WScript.Echo .GetFile("\input.txt").Size
End With

Vedit macro language

Num_Type(File_Size("input.txt"))
Num_Type(File_Size("/input.txt"))

Visual Basic

Works with: Visual Basic version 6

Option Explicit

----

Sub DisplayFileSize(ByVal Path As String, ByVal Filename As String)
Dim i As Long
  If InStr(Len(Path), Path, "\") = 0 Then
    Path = Path & "\"
  End If
  On Error Resume Next 'otherwise runtime error if file does not exist
  i = FileLen(Path & Filename)
  If Err.Number = 0 Then
    Debug.Print "file size: " & CStr(i) & " Bytes"
  Else
    Debug.Print "error: " & Err.Description
  End If
End Sub

----

Sub Main()
  DisplayFileSize CurDir(), "input.txt"
  DisplayFileSize CurDir(), "innputt.txt"
  DisplayFileSize Environ$("SystemRoot"), "input.txt"
End Sub

Output:

file size: 37 Bytes
error: file not found
file size: 37 Bytes

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

Dim local As New IO.FileInfo("input.txt")
Console.WriteLine(local.Length)

Dim root As New IO.FileInfo("\input.txt")
Console.WriteLine(root.Length)

V (Vlang)

import os

fn main() {
	paths := ["input.txt", "./input.txt", "non_existing_file.txt"]
	for path in paths {
		if os.is_file(path) == true {println("The size of '${path}' is ${os.file_size(path)} bytes")}
		else {println("Not found: ${path}")}
	}
}

Output:

The size of 'input.txt' is 22 bytes
The size of './input.txt' is 22 bytes
Not found: non_existing_file.txt

Wren

A file called "input.txt" has already been created which contains the string "abcdefghijklmnopqrstuvwxyz".

To check the size of a file in the root, just change "input.txt" to "/input.txt" in the following script.

import "io" for File

var name = "input.txt"
System.print("'%(name)' has a a size of %(File.size(name)) bytes")

Output:

'input.txt' has a a size of 26 bytes

X86 Assembly

; x86_64 linux nasm

section .data
localFileName: db "input.txt", 0
rootFileName: db "/initrd.img", 0

section .text

global _start

_start:

  ; open file in current dir
  mov rax, 2
  mov rdi, localFileName
  xor rsi, rsi
  mov rdx, 0
  syscall
  push rax
  
  mov rdi, rax ; file descriptior
  mov rsi, 0 ; offset
  mov rdx, 2 ; whence
  mov rax, 8 ; sys_lseek
  syscall

  ; compare result to actual size
  cmp rax, 11
  jne fail
  
  ; close the file
  pop rdi
  mov rax, 3
  syscall

  ; open file in root dir
  mov rax, 2
  mov rdi, rootFileName
  xor rsi, rsi
  mov rdx, 0
  syscall
  push rax

  mov rdi, rax ; file descriptior
  mov rsi, 0 ; offset
  mov rdx, 2 ; whence
  mov rax, 8 ; sys_lseek
  syscall

  ; compare result to actual size
  cmp rax, 37722243
  jne fail

  ; close the file
  pop rdi
  mov rax, 3
  syscall

  ; test successful
  mov rax, 60
  mov rdi, 0
  syscall

  ; test failed
  fail:
    mov rax, 60
    mov rdi, 1
    syscall

XPL0

proc ShowSize(FileName);
char FileName; int Size, C;
[Trap(false);           \disable abort on error
FSet(FOpen(FileName, 0), ^i);
Size:= 0;
repeat  C:= ChIn(3);    \reads 2 EOFs before
        Size:= Size+1;  \ read beyond end-of-file
until   GetErr;         \ is detected
IntOut(0, Size-2);
CrLf(0);
];

[ShowSize("input.txt");
 ShowSize("/input.txt"); \root under Linux
]

zkl

File.info("input.txt").println();
File.info("/input.txt").println();

-->T(size,creation time,last mod time,isDir,mode), from stat(2)

Output:

L(391,1393658766,1393658766,False,33156)
Exception thrown: NameError(File.info(/input.txt): Could not open)