"Itoa" - expected identifier MPLAB XC8 compiler error

keshav98765 · Oct 19, 2020

Hi, I am working on SD Card interface with PIC18F4520 microcontroller. I am using Fatfs library.
The code is:

C:

#include <xc.h>
#include <string.h>
#include <stdio.h>
#include "fatfs.h"
#include "sdcard.h"
#include "uart.h"
#include <stdlib.h>


// holds partition 1 PBR address
unsigned long part1_addr;
// number of bytes per sector
unsigned char sector_size;
// number of sectors per cluster
unsigned char sectors_cluster;
// number of reserved sectors
unsigned char sectors_reserved;
// number of FAT copies
unsigned char FAT_copies;
// number of possible root entries
unsigned char root_entries;
// number of sectors per FAT
unsigned char sectors_FAT;

// FAT addresses
unsigned long FAT_address[2];
// root directory table start address
unsigned long rootdir_start;
// data region start address
unsigned long datareg_start;

// file specific variables
// starting cluster number of file
unsigned int cluster_number;
// starting sector of cluster address
unsigned long start_sector_address;
// sector address of current sector
unsigned long current_sector_address;
// current sector number
unsigned char current_sector = 0;
// entry address in root directory table
unsigned int entry_addr;
// number of byte in sector
unsigned int byte_number = 0;
// file length
unsigned long file_length = 0;

char address_buffer[10];

void mount_disk(void){
    // read sector 0 (MBR) from card
    SDcard_read_block(0x00000000);
    // calculate address of partition 1 PBR (first sector)
    // read parition 1 LBA from MBR
    // LBA 4 bytes at address 0x01be offset 0x08
    // Little Endian
    part1_addr = (unsigned long)SDRdata[0x01C6];
    part1_addr |= ((unsigned long)SDRdata[0x01C7]<<8);
    part1_addr |= ((unsigned long)SDRdata[0x01C8]<<16);
    part1_addr |= ((unsigned long)SDRdata[0x01C9]<<24);
    // multiply LBA by sector size to
    // get address of first sector of first partition
    part1_addr *= 0x00000200;

    // read first sector (PBR) of
    // partition 1
    SDcard_read_block(part1_addr);
    
    // read out sector size in bytes
    sector_size = SDRdata[0x000B];
    sector_size |= SDRdata[0x000C]<<8;
    // read out sectors per cluster
    sectors_cluster = SDRdata[0x000D];
    // read out number of reserved sectors
    sectors_reserved = SDRdata[0x000E];
    sectors_reserved |= SDRdata[0x000F]<<8;
    // read out number of FATs
    FAT_copies = SDRdata[0x0010];
    // read out number of maximum root entries possible
    root_entries = SDRdata[0x0011];
    root_entries |= SDRdata[0x0012]<<8;
    // read out single FAT size in sectors
    sectors_FAT = SDRdata[0x0016];
    sectors_FAT |= SDRdata[0x0017]<<8;
    
    // calculate addresses of both FAT copies
    FAT_address[0] = part1_addr + (sectors_reserved * sector_size);
    FAT_address[1] = FAT_address[0] + ((unsigned long)sectors_FAT * (unsigned long)sector_size);

    // calculate root directory table start address
    rootdir_start = FAT_address[1] + ((unsigned long)sectors_FAT * (unsigned long)sector_size);

    // calculate start address of data region
    datareg_start = rootdir_start + ((unsigned long)root_entries * 32);
}

void file_create(const char* filename){
    // read first sector of FAT1
    SDcard_read_block(FAT_address[0]);

    // find first unallocated cluster
    uart_puts("Searching first unallocated cluster...");
    for(cluster_number = 0; cluster_number < 0xFFFF; cluster_number++){
        if( (SDRdata[cluster_number*2] == 0) && (SDRdata[(cluster_number*2)+1] == 0) ) break;
    }
    uart_puts("done!\n");

    // allocate cluster in FAT
    // copy read sector
    for(unsigned int i = 0; i < 512; i++){
        SDWdata[i] = SDRdata[i];
    }
    SDWdata[cluster_number*2] = 0xFF;
    SDWdata[(cluster_number*2)+1] = 0xFF;
    // write new FAT to both fat copies
    SDcard_write_block(FAT_address[0]);
    SDcard_write_block(FAT_address[1]);
    // calculate address of first sector in cluster
    start_sector_address = datareg_start + (((unsigned long)(cluster_number-2)) * (unsigned long)sectors_cluster * (unsigned long)sector_size);
    current_sector = 0;

    extern char *itoa(address_buffer, cluster_number, 10);
    uart_puts("Cluster number: ");
    uart_puts(address_buffer);
    uart_putc('\n');

    extern char *ltoa(address_buffer, start_sector_address, 16);
    uart_puts("Sector 0 address: ");
    uart_puts(address_buffer);
    uart_putc('\n');

    // read first sector of root directory table
    SDcard_read_block(rootdir_start);

    // search first unallocated entry
    uart_puts("Searching first unallocated root table entry...");
    for(entry_addr = 0; entry_addr < 0x0200; entry_addr += 32){
        if( (SDRdata[entry_addr] == 0xE5) || (SDRdata[entry_addr] == 0x00) ) break;
    }
    uart_puts("done!\n");

    extern char *ltoa(address_buffer, entry_addr, 16);
    uart_puts("Entry number: ");
    uart_puts(address_buffer);
    uart_putc('\n');

    // copy read table block to SDWdata
    for(unsigned int i = 0; i < 512; i++){
        SDWdata[i] = SDRdata[i];
    }

    // create file with filename
    unsigned char offset = 0;
    while(*filename){
        if(*filename != '.'){ // use '.' in filename as delimiter
            SDWdata[entry_addr+offset] = *filename;
            filename++;
            offset++;
        }
        else{
            filename++; // skip ''.' in filename
        }
    }

    // add attribute byte
    // archive flag set
    SDWdata[entry_addr+0x0B] = 0x20;

    // set reserved byte to 0
    SDWdata[entry_addr+0x0C] = 0x00;

    // set millisecond stamp
    SDWdata[entry_addr+0x0D] = 0x00;

    // set creation time
    // time 12:00:00
    SDWdata[entry_addr+0x0E] = 0x00;
    SDWdata[entry_addr+0x0F] = 0x60;

    // set creation data
    // date January 1, 2000
    SDWdata[entry_addr+0x10] = 0x21;
    SDWdata[entry_addr+0x11] = 0x24;

    // set last access date
    SDWdata[entry_addr+0x12] = 0x21;
    SDWdata[entry_addr+0x13] = 0x24;

    // reserved for FAT32
    SDWdata[entry_addr+0x14] = 0x00;
    SDWdata[entry_addr+0x15] = 0x00;

    // last write time
    SDWdata[entry_addr+0x16] = 0x00;
    SDWdata[entry_addr+0x17] = 0x60;

    // last write date
    SDWdata[entry_addr+0x18] = 0x21;
    SDWdata[entry_addr+0x19] = 0x24;

    // enter file starting cluster
    SDWdata[entry_addr+0x1A] = cluster_number & 0xFF;
    SDWdata[entry_addr+0x1B] = (cluster_number>>8) & 0xFF;

    // set initial file size to 0 bytes
    SDWdata[entry_addr+0x1C] = 0x00;
    SDWdata[entry_addr+0x1D] = 0x00;
    SDWdata[entry_addr+0x1E] = 0x00;
    SDWdata[entry_addr+0x1F] = 0x00;

    // write data block
    SDcard_write_block(rootdir_start);
}

void sector_open(void){
    // read sector of cluster
    current_sector_address = start_sector_address + ((unsigned long)current_sector * (unsigned long)sector_size);
    SDcard_read_block(current_sector_address);

    extern char *ltoa(address_buffer, current_sector_address, 16);
    uart_puts("Address of current sector: ");
    uart_puts(address_buffer);
    uart_putc('\n');

    // copy read sector to SDWdata
    for(unsigned int i = 0; i < 512; i++){
        SDWdata[i] = SDRdata[i];
    }
}

void sector_close(void){
    // write sector to card
    SDcard_write_block(current_sector_address);
}

void file_append(const char* string){
    // offset from beginning of write
    // (byte number)
    while(*string){
        if(byte_number < 512){
            SDWdata[byte_number] = *string;
            string++;
            byte_number++;
            // increase file length
            file_length++;
        }
        else{
            // save current sector
            sector_close();
            // reset byte counter
            byte_number = 0;
            // next sector is needed, load next sector
            current_sector++;
            sector_open();
        }
    }
}

void file_update_size(void){
    // read first sector of root directory table
    SDcard_read_block(rootdir_start);
    // copy read sector to SDWdata
    for(unsigned int i = 0; i < 512; i++){
        SDWdata[i] = SDRdata[i];
    }

    extern char *ltoa(address_buffer, file_length, 16);
    uart_puts("File size: ");
    uart_puts(address_buffer);
    uart_putc('\n');

    // set file size
    SDWdata[entry_addr+0x1C] = file_length & 0xFF;
    SDWdata[entry_addr+0x1D] = (file_length>>8) & 0xFF;
    SDWdata[entry_addr+0x1E] = (file_length>>16) & 0xFF;
    SDWdata[entry_addr+0x1F] = (file_length>>24) & 0xFF;
    // write first sector of root directory table
    SDcard_write_block(rootdir_start);
}

And I am getting error as:

C:

fatfs.c:122:55: error: expected identifier
    extern char *itoa(address_buffer, cluster_number, 10);
                                                      ^
fatfs.c:127:61: error: expected identifier
    extern char *ltoa(address_buffer, start_sector_address, 16);
                                                            ^
fatfs.c:142:51: error: expected identifier
    extern char *ltoa(address_buffer, entry_addr, 16);
                                                  ^
fatfs.c:220:63: error: expected identifier
    extern char *ltoa(address_buffer, current_sector_address, 16);
                                                              ^
fatfs.c:267:52: error: expected identifier
    extern char *ltoa(address_buffer, file_length, 16);
                                                   ^
5 errors generated.

Please Help.

KlausST · Oct 19, 2020

Hi,

Did you read documentation of itoa and ltoa?

Klaus

keshav98765 · Oct 19, 2020

KlausST said:
Hi,

Did you read documentation of itoa and ltoa?

Klaus

Yes, It is included in stdlib.h

Code:

/*    Standard utility functions */
#ifndef _STDLIB_H_
#define _STDLIB_H_

#include <__size_t.h>
#include <__null.h>
typedef unsigned short    wchar_t;    /* wide char type */

#define    RAND_MAX    32767        /* max value returned by rand() */
#define    EXIT_SUCCESS    0
#define    EXIT_FAILURE    1

#ifndef    _DIVTYPES
#if    (defined(_MPC_) && !defined(__DSPICC__)) || defined(i8051) || defined(__18CXX)
typedef struct {
    int    rem;    /* remainder */        /* PIC version returns remainder here */
    int    quot;    /* quotient */
} div_t;                /* div() return type */
typedef struct {
    unsigned    rem;    /* remainder */        /* PIC version returns remainder here */
    unsigned    quot;    /* quotient */
} udiv_t;                /* div() return type */
typedef struct {
    long     quot;    /* quotient */
    long     rem;    /* remainder */
} ldiv_t;                /* ldiv() return type */
typedef struct {
    unsigned long     quot;    /* quotient */
    unsigned long     rem;    /* remainder */
} uldiv_t;                /* ldiv() return type */
#else
typedef struct {
    int    quot;    /* quotient */
    int    rem;    /* remainder */
} div_t;                /* div() return type */
typedef struct {
    unsigned    quot;    /* quotient */
    unsigned    rem;    /* remainder */
} udiv_t;                /* div() return type */
typedef struct {
    long     quot;    /* quotient */
    long     rem;    /* remainder */
} ldiv_t;                /* ldiv() return type */
typedef struct {
    unsigned long     quot;    /* quotient */
    unsigned long     rem;    /* remainder */
} uldiv_t;                /* ldiv() return type */
#endif    /* _MPC_ */

#define    _DIVTYPES
#endif

extern double        atof(const char *);
extern double        strtod(const char *, const char **);
extern int            atoi(const char *);
extern unsigned        xtoi(const char *);
extern long            atol(const char *);
extern long            strtol(const char *, char **, int);
#define    strtoul(a,b,c)    ((unsigned long)strtol((a),(b),(c)))
extern int            rand(void);
extern void            srand(unsigned int);
extern void *        calloc(size_t, size_t);
extern div_t        div(int numer, int denom);
extern udiv_t        udiv(unsigned numer, unsigned denom);
extern ldiv_t        ldiv(long numer, long denom);
extern uldiv_t        uldiv(unsigned long numer,unsigned  long denom);
extern unsigned long    _lrotl(unsigned long value, unsigned int shift);
extern unsigned long    _lrotr(unsigned long value, unsigned int shift);
extern unsigned int    _rotl(unsigned int value, unsigned int shift);
extern unsigned int    _rotr(unsigned int value, unsigned int shift);

#define    max(a,b)    (((a) > (b)) ? (a) : (b))
#define    min(a,b)    (((a) < (b)) ? (a) : (b))

extern void *        malloc(size_t);
extern void        free(void *);
extern void *        realloc(void *, size_t);

#if    defined(__XC8)
/* abort and exit are defined as a macro included in xc8debug.h */
#include <xc8debug.h>
#else
extern void    abort(void);
extern void    exit(int);
#endif
extern int    atexit(void (*)(void));
extern char *    getenv(const char *);
extern char **    environ;
extern int    system(char *);
extern void    qsort(void *, size_t, size_t, int (*)(const void *, const void *));
extern void *    bsearch(const void *, void *, size_t, size_t, int(*)(const void *, const void *));
extern int    abs(int);
extern long    labs(long);

extern char *    itoa(char * buf, int val, int base);
extern char *    utoa(char * buf, unsigned val, int base);
#ifdef __18CXX
extern char *    ltoa(long val, char * buf);
extern char *    ultoa(unsigned long val, char * buf);
#else
extern char *    ltoa(char * buf, long val, int base);
extern char *    ultoa(char * buf, unsigned long val, int base);
#endif
extern char *    ftoa(float f, int * status);

#ifdef __18CXX
#define atob(a)        ((signed char)atoi(a))
#define atoul(a)    ((unsigned long)atol(a))
#define btoa(a,b)    itoa((signed char)(a),b)
#endif

#endif // _STDLIB_H_

KlausST · Oct 19, 2020

Hi,

so there are two definitions of the functions depending on the used processor.
Only one is valid for you.

from your post#3:

Code:

#ifdef __18CXX
extern char *    ltoa(long val, char * buf);
extern char *    ultoa(unsigned long val, char * buf);
#else
extern char *    ltoa(char * buf, long val, int base);
extern char *    ultoa(char * buf, unsigned long val, int base);
#endif

either the upper or the lower one.
Which one is valid for you?

Klaus

keshav98765 · Oct 19, 2020

@KlausST Hi, I tried both, both it didnt work for me. Somehow, I found some thread https://www.microchip.com/forums/m1074168.aspx I would like to understand what is C99 and what is C90 mean here. As, I can find its relatable. Thanks

KlausST · Oct 19, 2020

Hi,

keshav98765 said:
I would like to understand what is C99 and what is C90 mean here. As, I can find its relatable. Thanks

How much effort did you put in to find an answer?

C99 - Wikipedia

en.wikipedia.org

****

keshav98765 said:
I tried both, both it didnt work for me.

Then show both and show the according error messages.
Otherwise we have to solve riddles...

Klaus

keshav98765 · Oct 20, 2020

keshav98765 said:
@KlausST Hi, I tried both, both it didnt work for me. Somehow, I found some thread https://www.microchip.com/forums/m1074168.aspx I would like to understand what is C99 and what is C90 mean here. As, I can find its relatable. Thanks

Thank you so much @KlausST You always help me. C90 solve my issue. Thanks again.

Welcome to EDAboard.com

"Itoa" - expected identifier MPLAB XC8 compiler error

keshav98765

Newbie level 4

KlausST

Advanced Member level 7

keshav98765

Newbie level 4

KlausST

Advanced Member level 7

keshav98765

Newbie level 4

KlausST

Advanced Member level 7

C99 - Wikipedia

keshav98765

Newbie level 4

Similar threads

Part and Inventory Search

Welcome to EDABoard.com

Sponsor

Connect with us

Online statistics

Forum statistics