I must not understand retrning a value from a function! os.file_size. Resolved

[David-Worboys]

OK,

I have done some V and it works great in general but this has me stumped....in one V file I have this function

// Returns the size of a file.
fn (fu File_Utils) file_size(file_name string) u64 {
	assert file_name.trim_space() != ''

	path := os.dir(file_name)
	file_prefix := os.file_name(file_name).split('.')[0]
	file_suffix := os.file_name(file_name).split('.')[1]

	println('fs >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
	println("$file_name ${os.file_size(file_name)}")
	println('fs >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')

	if fu.file_exists(path, file_prefix, file_suffix) && os.is_readable(file_name) {		
		return  os.file_size(file_name)
	}

	return -1
}

In another V file I call it like so: Note this is stripped down!

// Returns the meta-data properties of the jpeg
fn (mut jm Jpeg_Metadata) get_properties(file_name string) Properties {
	assert file_name.trim_space() != ''
	println('=======')
	mut block_start := 0
	mut block_end := 0
	mut data_buffer := ''.bytes()
	mut file_result := File_Result{}
	mut file_utils := File_Utils{}
	mut iptc_handler := Iptc{}
	mut offset := 0
	mut properties := Properties{}
	mut segment := ''.bytes()
	mut size_block := ''.bytes()
	mut xmp_xml := ''
	mut extended_xmp_xml := ''
		
	file_signature := File_Signature.jpeg

	img_file_size := os.file_size(file_name)//file_utils.file_size(file_name) //Debug test
	aimg_file_size := file_utils.file_size(file_name)

	segment, file_result = file_utils.read_file(file_name, File_Mode.read_binary, offset,
		file_signature.max_signature_length(), true)

	if file_result.error_code == File_Error.ok {
		if file_utils.file_signature(segment) == File_Signature.jpeg {
			println('File is $file_name  Size is $aimg_file_size : ${img_file_size}')
}

Now in my test harness I call it like so:

fn main() {		
	test_path := '/home/david/Pictures/test/'

	file_utils := File_Utils{}
	mut jpeg_handler := Jpeg_Metadata{}

	files := file_utils.file_list(test_path, ['jpg', 'JPEG', 'jpeg']).files

	for file in files { // If file_list is used here then the loop is slow				
		jpeg_handler.get_properties(os.join_path_single(test_path, file))
	}
}

And I expected the file size to be printed correctly but I get:

File is /home/david/Pictures/test/IPTC-PhotometadataRef-Std2017.1.jpg Size is 18446744073709551615 : 91435

aimg_file_size = 18446744073709551615 (incorrect with the file_utils.file_size call in get properties )
img_file_size = 91435 (correct with the os.file_size call in get_properties )

Note on the last call of the loop it produces the correct value!

File is /home/david/Pictures/test/20200208_114235.jpg Size is 3867705 : 3867705

The println call in file_utils.file_size prints the correct size as expected.

Am I doing something obviously wrong? Or is this confusing and I have to bail this down to a small test program to seek help? It looks like an uninitialized variable or address value to me...

V doctor output - Before you start laughing I am on vacation using an ancient computer! And I have a feeling this works correctly on the modern computer at home...

OS: linux, Linux Mint 21
Processor: 2 cpus, 64bit, little endian, Intel(R) Core(TM)2 Duo CPU     E8300  @ 2.83GHz
CC version: cc (Ubuntu 11.2.0-19ubuntu1) 11.2.0

getwd: /home/david/V Projects/VMetamech-main/metamech
vmodules: /home/david/.vmodules
vroot: /home/david/Downloads/v
vexe: /home/david/Downloads/v/v
vexe mtime: 2022-09-04 10:44:28
is vroot writable: true
is vmodules writable: true
V full version: V 0.3.1 d3307fd.0d0c2b2

Git version: git version 2.34.1
Git vroot status: weekly.2022.35-23-g0d0c2b27 (3 commit(s) behind V master)
.git/config present: true
thirdparty/tcc status: thirdparty-linux-amd64 827f7452

[JalonSolov]

We would need to see a complete working example to check into this. os.file_size appears to work fine with a very simple test. Save the following as foo.v:

import os

println(os.file_size('foo.v'))

Then check the size with ls:

$ ls -l foo.v
-rw-r--r-- 1 jamie jamie 42 Sep  4 11:44 foo.v
$

Then run the code:

$ v run foo.v
42
$

... which is the exact correct size.

[David-Worboys]

I agree os.file_size returns the right value. It is when it is wrapped in my file utils file_size wrapper (see below and the println there always shows the correct value). It is only when my file utils file_size wrapper is called in a loop that I get the issue.

I will try and build a small test program later today and see if I can get the issues to occur as well there.

// Returns the size of a file.
fn (fu File_Utils) file_size(file_name string) u64 {
	assert file_name.trim_space() != ''

	path := os.dir(file_name)
	file_prefix := os.file_name(file_name).split('.')[0]
	file_suffix := os.file_name(file_name).split('.')[1]

	println('fs >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
	println("$file_name ${os.file_size(file_name)}")
	println('fs >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')

	if fu.file_exists(path, file_prefix, file_suffix) && os.is_readable(file_name) {		
		return  os.file_size(file_name)
	}

	return -1
}

[David-Worboys]

Ok this example shows the error:

Output is

---------- IPTC-PhotometadataRef-Std2017.1.jpg
   >>>>>>>>>> Size As Reported In file_size 91435 
   ******** Size As Reported In  main Loop 18446744073709551615
----------

---------- IPTC-PhotometadataRef-Std2021.1.jpg
   >>>>>>>>>> Size As Reported In file_size 134078 
   ******** Size As Reported In  main Loop 18446744073709551615
----------

---------- 20200208_114235.jpg
   >>>>>>>>>> Size As Reported In file_size 3867705 
   ******** Size As Reported In  main Loop 3867705
----------

And the example code that causes the problem - copy into a file, change test_path to point at a folder with files, compile and run. The issue is then displayed as the file sizes are printed.

import os

// Path Error container
enum File_Error {
	ok
	exception
	not_exist
	not_implemented
	not_readable
	not_writeable
}

// Contains the result of file operations
struct File_Result {
	files         []string
	path          string
	error_code    File_Error
	error_message string
}

fn file_list(path string, extensions []string) File_Result {
	assert path.trim_space() != ''

	mut file_path := ''
	mut files := []string{}
	mut file_list := []string{}

	if os.exists(path) && os.is_readable(path) {
		if os.is_file(path) {
			file_path = os.dir(path)
		} else {
			file_path = path
		}

		files = os.ls(file_path) or {
			return File_Result{
				path: file_path
				error_code: File_Error.exception
				error_message: File_Error.exception.str()
			}
		}

		for file in files {
			if os.is_file(os.join_path_single(file_path, file)) {
				extension := os.file_ext(file)
				if extension.len_utf8() > 0 && extension[1..] in extensions {
					file_list << file
				}
			}
		}

		return File_Result{
			files: file_list
			path: file_path
			error_code: File_Error.ok
			error_message: File_Error.ok.str()
		}
	} else if !os.exists(path) {
		return File_Result{
			path: path
			error_code: File_Error.not_exist
			error_message: File_Error.not_exist.str()
		}
	} else if !os.is_readable(path) {
		return File_Result{
			path: path
			error_code: File_Error.not_readable
			error_message: File_Error.not_readable.str()
		}
	}

	return File_Result{
		path: path
		error_code: File_Error.exception
		error_message: File_Error.exception.str()
	}
}

// Checks if a file exists
fn file_exists(path string, file string, suffix string) bool {
	assert path.trim_space() != ''
	assert file.trim_space() != ''
	assert suffix.trim_space() != ''

	mut file_path := ''

	if suffix.starts_with('.') {
		file_path = os.join_path_single(path, file + suffix)
	} else {
		file_path = os.join_path_single(path, file + '.' + suffix)
	}

	if os.exists(file_path) {
		return true
	}

	return false
}

// Returns the size of a file.
fn file_size(file_name string) u64 {
	assert file_name.trim_space() != ''

	path := os.dir(file_name)
	file_prefix := os.file_name(file_name).split('.')[0]
	file_suffix := os.file_name(file_name).split('.')[1]

	println('   >>>>>>>>>> Size As Reported In file_size ${os.file_size(file_name)} ')

	if file_exists(path, file_prefix, file_suffix) && os.is_readable(file_name) {
		return os.file_size(file_name)
	}

	return -1
}

fn main() {
	test_path := '/home/david/Pictures/test/' // Substitute for your folder with files

	files := file_list(test_path, ['jpg', 'JPEG', 'jpeg']).files

	for file in files { // If file_list is used here then the loop is slow				
		println('---------- $file')
		x := file_size(os.join_path_single(test_path, file))
		println('   ******** Size As Reported In  main Loop $x')
		println('----------\n')
	}
}

[splace]

works for me.

i notice file_size returns u64, but with an error tries return -1?

[spytheman]

yes, 18446744073709551615 is ffffffffffffffff, which is -1 .

[spytheman]

I think that returning negative numbers in functions, that have unsigned return types, should be a checker error, just like this is a checker error:

    mut u := u64(0)
    u = -1

[spytheman]

I've filed a new issue about it: #15789 .

[spytheman]

Try using i64 as a return type @David-Worboys , instead of u64. Another alternative is ?u64, and then return none, instead of return -1.

[David-Worboys]

Good spot splace and spytheman that issue needs raising! Obvious oversight on my behalf but it still does not completely fix the error

I changed file size to

// Returns the size of a file.
fn file_size(file_name string) i64 {
	assert file_name.trim_space() != ''

	path := os.dir(file_name)
	file_prefix := os.file_name(file_name).split('.')[0]
	file_suffix := os.file_name(file_name).split('.')[1]

	println('   >>>>>>>>>> Size As Reported In file_size ${i64(os.file_size(file_name))} ')

	if file_exists(path, file_prefix, file_suffix) && os.is_readable(file_name) {
		return i64(os.file_size(file_name))
	}

	return -1
}

And get this result:

---------- IPTC-PhotometadataRef-Std2017.1.jpg
   >>>>>>>>>> Size As Reported In file_size 91435 
   ******** Size As Reported In  main Loop -1
----------

---------- IPTC-PhotometadataRef-Std2021.1.jpg
   >>>>>>>>>> Size As Reported In file_size 134078 
   ******** Size As Reported In  main Loop -1
----------

---------- 20200208_114235.jpg
   >>>>>>>>>> Size As Reported In file_size 3867705 
   ******** Size As Reported In  main Loop 3867705
----------

Given I have written a stack of V lately and it has been working I was tending to the view that calling println in the loop was in error. And this test run still suggests this to me as I am not seeing an obvious error in my code.

[carltonf]

	file_prefix := os.file_name(file_name).split('.')[0]
	file_suffix := os.file_name(file_name).split('.')[1]

seems to assume the file name only contains a single dot, which is not the case for files like IPTC-PhotometadataRef-Std2021.1.jpg

[David-Worboys]

Thank you Carl for catching my obvious dumb mistake - dunce cap for me please, perhaps I should return my Masters in comp sci!

Code below works and produces correct output - println is innocent!

// Checks if a file exists
fn file_exists(path string, file string, suffix string) bool {
	assert path.trim_space() != ''
	assert file.trim_space() != ''

	mut file_path := ''

	if suffix.trim_space() == '' {
		file_path = os.join_path_single(path, file)
	} else if suffix.starts_with('.') {
		file_path = os.join_path_single(path, file + suffix)
	} else {
		file_path = os.join_path_single(path, file + '.' + suffix)
	}

	if os.exists(file_path) {
		return true
	}

	return false
}

// Returns the size of a file.
fn file_size(file_name string) i64 {
	assert file_name.trim_space() != ''
	path := os.dir(file_name)

	mut file_prefix := ''
    mut	file_suffix := ''

	if file_name.contains('.') { // Assume we have file extension

		file_eles := os.file_name(file_name).split('.')

		file_prefix = file_eles[..file_eles.len - 1].join('.') //rebuild file name in case of multiple periods
		file_suffix = file_eles.last() // Extension is last element delimited by period
	} else {
		file_prefix = file_name
		file_suffix = ''
	}

	if file_exists(path, file_prefix, file_suffix) && os.is_readable(file_name) {
		println('   >>>>>>>>>> Size As Reported In file_size ${i64(os.file_size(file_name))} ')
		return i64(os.file_size(file_name))
	}

	return -1
}

Result with fixed code

---------- IPTC-PhotometadataRef-Std2017.1.jpg
   >>>>>>>>>> Size As Reported In file_size 91435 
   ******** Size As Reported In  main Loop 91435
----------

---------- IPTC-PhotometadataRef-Std2021.1.jpg
   >>>>>>>>>> Size As Reported In file_size 134078 
   ******** Size As Reported In  main Loop 134078
----------

---------- 20200208_114235.jpg
   >>>>>>>>>> Size As Reported In file_size 3867705 
   ******** Size As Reported In  main Loop 3867705
----------

[Delta456]

Looks fine to me