{"id":6029,"date":"2023-09-16T00:01:45","date_gmt":"2023-09-16T07:01:45","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=6029"},"modified":"2023-09-23T08:29:20","modified_gmt":"2023-09-23T15:29:20","slug":"enabling-random-memory-file-access","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=6029","title":{"rendered":"Enabling Random Memory-File Access"},"content":{"rendered":"

The two types of file access are sequential and random. Sequential access means the file’s data is read from beginning to end, one byte after the other. Random access isn’t random in the sense that it’s haphazard. No, random access means you can read data from any position in the file: beginning, middle, or end.
\n
\nFor example, if you know the data chunk you want is at offset 100 bytes from the start of the file, you can position a file pointer (I don’t like using the term “pointer”) at offset 100 and start reading. The fseek() function<\/a> is responsible for this manipulation.<\/p>\n

Continuing with my memory-file implementation in last week’s Lesson<\/a>, I sought to write a mem_seek()<\/em> function to parallel fseek()<\/em>. This function moves a position indicator in the memory-file to enable random memory-file access:<\/p>\n

\r\n\/* move the memory offset index\r\n   input- memory file handle, offset, whence\r\n   output- current offset or -1\r\n   whence:  SEEK_SET (start)\r\n               SEEK_CUR (current)\r\n            SEEK_END (end)\r\n *\/<\/span>\r\nint mem_seek(struct mem_file *m, long position, int whence)\r\n{\r\n    \/* return -1 on various errors *\/<\/span>\r\n    if( m->address==NULL )\r\n        return(-1);\r\n\r\n    \/* adjust m->offset value *\/<\/span>\r\n    if( whence==SEEK_SET )\r\n    {\r\n        if( position<0 )\r\n            return(-1);\r\n        \/* no negative offsets! *\/<\/span>\r\n        if( position>m->size )\r\n            return(-1);\r\n        \/* set offset from the start *\/<\/span>\r\n        m->offset = position;\r\n        return(m->offset);\r\n    }\r\n    else if( whence==SEEK_CUR )\r\n    {\r\n        if( m->offset+position<0 || m->offset+position > m->size )\r\n            return(-1);\r\n        m->offset+=position;\r\n        return(m->offset);\r\n    }\r\n    else if( whence==SEEK_END )\r\n    {\r\n        if( position<0 || m->size-position<0 )\r\n            return(-1);\r\n        m->offset = m->size-position;\r\n        return(m->offset);\r\n    }\r\n    else\r\n        return(-1);\r\n}<\/pre>\n
The three operations are based on the three defined constants shared with the fseek()<\/em> function:<\/p>\n
SEEK_SET<\/code> to move the pointer offset from the memory-file’s start
\nSEEK_CUR<\/code> to move the pointer offset from the current position
\nSEEK_END<\/code> to move the pointer offset from the end of the memory-file<\/p>\n
The offset values for SEEK_SET<\/code> and SEEK_END<\/code> must be positive. These are offsets from the start and end of the file and calculated that way in the code.<\/p>\n
For the SEEK_CUR<\/code> argument the position change can be positive or negative. Math in the code works to prevent an overflow, where the position indicator leaps below zero or beyond the end of the file, m->size<\/code>. I’m unsure how the fseek()<\/em> function is coded, but these are the rules I implemented.<\/p>\n
To test my mem_seek()<\/em> function, I modified the main()<\/em> function to write the 26 letters of the alphabet to a memory file. These letters are then read back using specific options in the mem_seek()<\/em> function:<\/p>\n
\r\n\/* test the memory file functions *\/<\/span>\r\nint main()\r\n{\r\n    static char name1[] = \"memory file\";\r\n    struct mem_file *mfp1;\r\n    int a,r;\r\n\r\n    mfp1 = mem_open(name1);\r\n    if( mfp1==NULL )\r\n    {\r\n        fprintf(stderr,\"Unable to create %s\\n\",name1);\r\n        exit(1);\r\n    }\r\n    printf(\"Memory file '%s' created\\n\",name1);\r\n\r\n    \/* write the alphabet to the memory-file *\/<\/span>\r\n    for( a='A'; a<='Z'; a++ )\r\n        mem_putc(a,mfp1);\r\n\r\n    \/* read back in the entire alphabet *\/<\/span>\r\n    printf(\"Reading the entire file: \");\r\n    r = mem_seek(mfp1,0,SEEK_SET);\r\n    if( r==-1)\r\n    {\r\n        fprintf(stderr,\"Position error\\n\");\r\n        exit(1);\r\n    }\r\n    for( a=0; a<26; a++ )\r\n        putchar( mem_getc(mfp1) );\r\n    putchar('\\n');\r\n\r\n    \/* read the last ten characters *\/<\/span>\r\n    printf(\"Reading the last ten characters: \");\r\n    r = mem_seek(mfp1,10,SEEK_END);\r\n    if( r==-1)\r\n    {\r\n        fprintf(stderr,\"Position error\\n\");\r\n        exit(1);\r\n    }\r\n    for( a=0; a<10; a++ )\r\n        putchar( mem_getc(mfp1) );\r\n    putchar('\\n');\r\n\r\n    \/* read the middle ten characters *\/<\/span>\r\n    printf(\"Reading the middle ten characters: \");\r\n        \/* position is at the end of the file *\/<\/span>\r\n    r = mem_seek(mfp1,-18,SEEK_CUR);\r\n    if( r==-1)\r\n    {\r\n        fprintf(stderr,\"Position error\\n\");\r\n        exit(1);\r\n    }\r\n    for( a=0; a<10; a++ )\r\n        putchar( mem_getc(mfp1) );\r\n    putchar('\\n');\r\n\r\n    mem_close(mfp1);\r\n    printf(\"Memory file '%s' closed\\n\",name1);\r\n\r\n    return(0);\r\n}<\/pre>\n
The bulk of the main()<\/em> function deals with error-checking, to ensure that when I’m moving the file position pointer that I’m not accessing unallocated memory. The program reads all characters in the memory-file, then the last ten, finally the middle ten. Here is a sample run:<\/p>\n
Memory file 'memory file' created
\nReading the entire file: ABCDEFGHIJKLMNOPQRSTUVWXYZ
\nReading the last ten characters: QRSTUVWXYZ
\nReading the middle ten characters: IJKLMNOPQR
\nMemory file 'memory file' closed<\/code><\/p>\n
For next week’s Lesson<\/a>, I present how to split up this code into multiple modules for easier implementation of new features.<\/p>\n","protected":false},"excerpt":{"rendered":"
Reading and writing to a file isn’t always sequential. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-6029","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6029","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=6029"}],"version-history":[{"count":5,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6029\/revisions"}],"predecessor-version":[{"id":6049,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6029\/revisions\/6049"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=6029"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=6029"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=6029"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
The full code is 205 lines long, which is too much to list in this post. Click here<\/a> to view the full code on Github.<\/p>\n