[MSX-C] Q&A official thread

Strange. Can you share the code?

This is the .h file and the list.c file.
They compile without problem (cf -> cg -k -> m80 ). When you link with l80 and include list/s there will be no error, but the code won't work anyway. I included a simple welcome function lstWelcome(), that will not execute.

/* list.h */

typedef struct {
            char name;
            struct tNode *next;
            struct tNode *prev;
} tNode;

extern VOID updNode();
extern unsigned cntNode();
extern tNode *gtNode();
extern tNode *addNode ();
extern tNode *gForward();
extern tNode *gBack();
extern tNode *remNode();
extern lstWelcome();

List code, the empty includes happen because the forum doesn't handle bigger and smaller signs.

#include 
#include 
#include "list.h"

#define Jiffy 	(unsigned *)0xFC9E

#pragma nonrec



/*
 VOID sleep( time )
unsigned time;
{
    unsigned old,lus;
    for (lus = 0; lus < time ; lus++ ) {
        old = (*(Jiffy));
        while ( old == (*(Jiffy)) ) { }
    }
}
*/

VOID updNode(start, val)
tNode *start;
char val;
{
    tNode *tmp=start;
    tmp->name=val;
}

unsigned cntNode( start )
tNode *start;
{
    tNode *tmp=start;
    unsigned count=1;
    while ( tmp->next) {
        count++;
        tmp = (tNode*)tmp->next;
    }
    return(count);
}

tNode *gtNode(start, val)
tNode *start;
unsigned val;
{
    tNode *tmp=start;
    unsigned loop;
    for (loop=0;loopnext != 0 ) {
            tmp=(tNode *)tmp->next;
        } else {
            return(NULL);
        }
        return tmp;
}

/*
VOID wait()
{
		while ( !kbhit());
        kilbuf();
}
*/

/* add a value. If next is NULL then we are at the tail, otherwise insert */
tNode *addNode (walker, waarde)
    char waarde;
    tNode *walker;
{
    tNode *temp, *temp2, *twalker;
    /* name == NULL && next == NULL*/
    twalker = walker;
    if (twalker->next == NULL) {
        /* is there a character */
        if (twalker->name ) {
            temp = twalker;
            twalker->next=(struct tNode *) alloc (sizeof(tNode));
            twalker = (tNode *)twalker->next;
            twalker->prev = (struct tNode *)temp;
        } else {
            twalker->prev = NULL;
        }
        twalker->name=waarde;
        twalker->next=NULL;
        return(twalker);
    } else
    {
        /* name !=0 && next != 0 */
        temp = twalker;
        temp2 = (tNode *)twalker->next; /* save next enty */
        temp = (tNode *)alloc(sizeof(tNode)); /* create new entry */
        temp->name=waarde; /* add value to next entry */
        temp->next=(struct tNode *)temp2; /* add next entry to new value */
        temp->prev=(struct tNode *)walker;
        walker->next=(struct tNode *)temp; /* connect new to old chain */
        temp2->prev = (struct tNode *)temp; /* connect next element to new element*/
        return(twalker);
    }
}


tNode *gForward( walker)
tNode *walker;
{
    if (walker->next ) {
        return((tNode *)walker->next);
    } else
        return((tNode *)walker);
}

tNode *gBack( walker )
tNode *walker;
{
    if (walker->prev) {
        return((tNode *)walker->prev);
    } else
        return(walker);
}


tNode *remNode(walker,flag)
tNode *walker;
char flag;
{
    /* flag == 0 [BS]
       flag == 1 [DEL] */
    tNode *temp; 
    /* are we at the start */
    /* check NULL !walker->prev*/
    /* only DEL works on first entry */
    if ( !walker->prev ) {
            if (flag) {
                temp = (tNode *)walker->next;
                temp->prev=NULL;
                free(walker);
                return(temp);
                /* root needs to be updated, check by prev==NULL*/ 
            } else {
                return(walker);
            }
    }
    /* are we in between */
    /* [DEL] then delete, [BS] move 1 left */
    if ((walker->prev) && (!flag)) {
        walker=(tNode *)walker->prev;
    } else
    {
        if (!flag) return(walker);
    }
    /* A->B->C */
    if (walker->next) {
        temp = (tNode *)walker->prev; /* store previous node */    
        temp->next = (struct tNode *)walker->next; /* previous node points to new next */
        temp = (tNode *)walker->next; /* store next node */
        temp->prev = (struct tNode *)walker->prev; /* next prev points to new previous */
        free(walker); /* remove current issue */
        walker=(tNode *)temp->prev;
        return(temp);
    } else {
        /* are we at the end */
        if ( temp ) {
            temp->next = NULL;
            free(walker);
            return(temp);
        }
    }
}

VOID lstWelcome()
{
printf("hello\n");
}
/*
main()
{ 
    tNode *old,*temp;
    tNode *root;

    temp=(tNode *)alloc(sizeof(tNode));
    root = temp;
    temp->next=NULL;
    temp->prev=NULL;
    temp->name=NULL;
    setbuf(stdout, NULL);
    temp = addNode(temp,'c');
    temp = addNode(temp,'o');
    temp = addNode(temp,'m');
    temp = addNode(temp,'p');
    temp = addNode(temp,'u');
    temp = addNode(temp,'t');
    temp = addNode(temp,'e');
    printf("current entry:%c\n",temp->name);
        printf("current address:%u\n",temp);
    printf("root address:%u\n",root);
    temp=remNode(temp,(char)0);
        if (!temp->prev) root=temp;
    printf("current entry after delete: %c\n",temp->name);

    temp = root;
    printf("start character:%c\n",temp->name);
    old=temp;
    while ((temp = gForward(temp)) != old) { 
        printf("%c",temp->name);
        old=temp;
    }
    printf("number of characers:%u\n",cntNode(root));
    temp=gtNode(root,0);
    printf("root character is:%c",temp->name);
    temp = remNode(temp,(char)1);
    if ( !temp->prev ) root=temp;
    printf("current character after del is:%c",temp->name);
}
*/

I solved my own issue.

A new question: how to work with long. A long for the FIB has been defined as

typedef unsigned LONG[2];

and MSX-DOS2 correctly dumps the file size in these 4 bytes. The question: does anyone have an algorithm to create the right file size from that. MSX C only handles 16 bits, so the high 2 bytes are displayed as separate numbers. A file of 130 Kb, has bit 1 set in the hight bytes. So the high part is two, which is correct for the unsigned but not the size.

Thanks for your answer. My question wasn't clear. How do I display the value of a LONG in MSX C?
MSX C can display unsigned but not bigger than 16 bits. The files can be bigger than 16 bits, so MSX C can't display long values. The only work around I can think of is using the math pack which requires me to convert the long (2 x unsigned) to 4 x char. I hope there is a better way, than calling some basic routine and doing all kind of conversions. I decided to take a look at SDCC here, because that has native long support.

SDCC is not my favourite because SDCC has a broken linker that includes all code from a library, even when unused, creating bloated binaries so I hope there is a smart way in MSX C.

In fact SDCC only link used modules in a library. The problem is SDCC consider 1 module is 1 file, so to make the most efficient library we should have to split functions file by file. BTW this is how the default SDCC library is done so only used functions are linked.

I'm pretty sure we can found a work-around to have more than 1 module per file but I had no time to check this yet.