Can I return a struct from a function?

[valnaumov]

I am trying read some data from the file in a loop in a structured way to use for markup later.

struct SubsystemTableEntry {
    u16 numProperties;
    u32 ptr;
};

fn readSubsystemTable(u32 i) {
    // some argument asserts here
    // systemTableOffset is const
    SubsystemTableEntry systemTableEntry @ systemTableOffset + i * sizeof(SubsystemTableEntry);
    
    // some asserts here
    return systemTableEntry;
};

for (u32 i = 0, i < header.numSubsystems, i = i + 1) {
    u32 numProperties = readSubsystemTable(i).numProperties;
	
    for (u32 j = 0, j < numProperties, j = j + 1) {
		// mark up file regions here 
    }
}

But I get an error:

E: error: Expected ';' at end of statement, got Separator (.).
E:   -->   in <Source Code>:78:56
E: 78 | adSubsystemTable(subsystemIdx).numProperties;
E:                                    ^
E: error: Invalid function statement.
E:   -->   in <Source Code>:78:57
E: 78 | dSubsystemTable(subsystemIdx).numProperties;
E:                                    ^
E: error: Type numProperties has not been declared yet.
E:   -->   in <Source Code>:78:58
E: 78 | SubsystemTable(subsystemIdx).numProperties;
E:                                    ^^^^^^^^^^^^^

E: If this type is being declared further down in the code, consider forward declaring it with 'using numProperties;'.

Is it possible to return a struct from a function? Am I misusing operator @ on line 9? Should I use some function from std::mem instead?

[paxcut]

Yes to the first two questions. You can return structs, but you cannot place patterns inside a function. Patterns can only be placed in the global scope. Also loop statements are considered as function statements so you can't place patterns inside for loops.Instead what you probably want to do is create an array of patterns that reads the data as it grows.

[valnaumov]

Thank you for the prompt answer, @paxcut!

Patterns are what I define using @ symbol, right?

If I can't place it a loop, how do I solve the following problem. There's a PropertyTable that holds the metadata about properties: size, offset in the file, attributes, something else. Then after the table region there's a data region that holds the actual values of the properties. The size of the data per prop may vary, the structure too, probably. So I want to choose one struct or another to represent each property.

struct PropTableEntry {
   u8 size;
   u16 attributes;
   u32 dataOffset;
   etc...
}
// property metadata
PropertyTableEnty props[numProps] @ propTableOffset;

After this I could write something like:

struct Property {
   // decide here on the actual structure to map to the property data using conditionals. To do so I need to get the prop metadata from props[]. I need an index to refer to it
};

struct PropertiesData {
    Property propertyData[header.numProperties];
    // no_unique_address
};

// the actual property values/data
PropertiesData propertyData @ header.dataOffset

How do I access property metadata (in props[]) from Property structure?

Thanks in advance!

[paxcut]

To me patterns are synonym to Pattern language defined custom types pretty much. a pattern may or may not be placed (@ is the placing operator) and is merely a representation of some structurally defined data set. Patterns are usually associated with binary file types, so you can then speak of jpeg or pe patterns.

There are a number of ways that pl uses to allow using arrays in place of what traditionally is done inside a loop. Because patterns are mostly useful when placed in data, it makes more sense to think that repeated applications of a pattern has the effect of creating an array of patterns instead of the loop operation which just represents iteration.. The main idea is to create a pattern that processes each element of the array and then place an array of them in the data.

The most used one is the conditionally indexed array that has the form Type array[while(expression)] @ address; here you have functions like std::mem::eof() or "std::mem::size(()among others to help you find conditions to stop. You can also add flow control statements to the pattern itself (thinks like break , continue or return ) for finer tuning of the iteration process. A very useful function in this context isstd::mem::array_index()' that can be used inside the pattern being turned to an array to access the current array index that's being processed. Because the array elements depend on the data that's being read then each one can have its own size, its own set of variables (use conditionals statements inside the pattern to declare types) or any property you want to change really.

Variables defined in the global scope can be accessed inside other patterns and functions, but if it is of a placed variable you shouldn't write to it lest you want to change the file you are working on. So if you have a global variable that's an array of properties, you can refer to it by name and obtain any value stored in it. other variables can only be accessed within their scopes (you can also create patterns inside patterns). So you can have the Property pattern have the prop pattern as a member or you can define prop as a global and use it everywhere else.

Sorry for the long answer and I hope that it is useful in some way. Please ask again if I am not making any sense or you have further questions.

[paxcut]

/// Simple example code where the property is the number of chars in a string.
/// Metadata starts with the number of strings N as a 32 bit unsigned integer,
/// an 8 bit unsigned n to represent the size of the numbers holding the property,
/// followed by exactly N sets of n bytes and after that the strings themselves with
/// no 0 termination.
import std.io;
import std.core;
/// Define a pattern that represents
/// the array of properties

struct  StringSizes<T, auto N> {
    T size[N];
};

/// Pattern used to read the metadata

struct Header {
    u32 N;   /// number of strings
    u8 n;    /// 1 for bytes, 2 for shorts and 4 for ints
    u8 ActualSize=N;  /// for error handling
    if (n==1)          /// Read metadata 
        StringSizes<u8,N> sizes;
     else if (n==2)
        StringSizes<u16,N> sizes;
     else if (n==4)
        StringSizes<u32,N> sizes;
     else {
        std::print("Error: invalid input");
        ActualSize=0;
      }
};

/// Create a global variable 
/// that reads and holds the metadata

Header header @0;

///Define pattern that will read and hold one string

struct String {
    if (header.ActualSize != 0) {
    
        /// Use global variable header and from the current array 
        /// index access the proper size 
        
        u64 size = header.sizes.size[std::core::array_index()];
        
        /// Read the string.
        
        char string[size];
     }
};


/// The reads N strings of sizes determined at runtime
/// based on the underlying data. $ is the current cursor position
/// code was tested on input file with values:
//  02h 00h 00h 00h 01h 03h 05h 45h 66h 43h 75h 32h 65h 67h 43h

String string[header.N] @$;