однонаправленные списки в C

[Edemchik]

Задача такова: Для набора действительных чисел, представленных в виде списка, построить два списка: положительных и отрицательных чисел.
компилятор указывает на ошибку в цикле на строку: nd->key=(i+1);
Подскажите, пожалуйста, в чем ошибка?

#include <stdlib.h>
#include <time.h>
#include "slist.h"
#define n 20
int main()
{
         PSLIST *lst,*lst1,*lst2;
         PSNODE *nd,*tmp;
         int i;
         init_slist(&lst);
         srand(time(0));
         for(i=0;i<n;i++)
         {
                nd=(PSNODE)malloc(sizeof(SNODE));
                nd->key=(i+1);
                if(i % 2==0) nd->info=(rand()%n+1);
                else nd->info=-(rand()%n+1);
                append(&lst,nd);
         }
         print_slist(&lst);
         init_slist(&lst1);
         init_slist(&lst2);
         nd->lst->head;
         while(nd!=NULL)
         {
                tmp=nd;
                if(tmp->info>0) append(&lst1,tmp);
                else  append(&lst2,tmp);
                nd=nd->next;
         }
         print_slist(&lst1);
         print_slist(&lst2);
         return 0;
}

[Edemchik]

файл slist.c:

#include <stdio.h>
#include <stdlib.h>
#include "slist.h"
void init_slist(PSLIST);
{
        lst->head=lst->tail=NULL;
        lst->size=SLISTSIZE;
        lst->count=0;
}
bool is_slist_empty(STACK st);
{
        return (lst->count==0);
}
bool is_slist_overflow(STACK st);
{
        return (lst->count==lst->size);
}
void print_slist(PSLIST lst);
{
        PNODE temp;
        temp=lst->head;
        while(temp!=NULL)
        {
                printf("(%d<->%d)->",temp->key,temp->info);
        }
        printf("\n");
}
void append(PSLIST lst,PSNODE nd)
{
        if(!is_slist_overflow(lst))
        {
                if(!is_slist_empty(lst))
                {
                        lst->head=lst->tail=nd;
                        nd->next=NULL;
                        lst->count=1;
                }
                else
                {
                        lst->tail->next=nd;
                        lst->tail=nd;
                        lst->count++;
                }
        }
}
void prepend(PSLIST lst,PSNODE nd)
{
        if(!is_slist_overflow(lst))
        {
                if(!is_slist_empty(lst))
                {
                        lst->head=lst->tail=nd;
                        nd->next=NULL;
                        nd->count=1;
                }
                else
                {
                        nd->next=lst->head;
                        lst->head=nd;
                        lst->count++;
                }
        }
}
PSNODE get_from_head(PSLIST)
{
        PSNODE temp;
        temp=NULL;
        if(!is_slist_empty(lst))
        {
                temp=lst->head;
                lst->head=lst->head->next;
                lst->count--;
                if(lst->count==0) lst->tail=NULL;
        }
        return temp;
}

PSNODE get_from_tail(PSLIST)
{
        PSNODE prev,temp;
        temp=NULL;
        if(!is_slist_empty(lst))
        {
                if(lst->count==1)
                {
                        temp=lst->head;
                        init_slist(lst);
                }
                else
                {
                        prev=lst->head;
                        while(prev->next->next!=NULL) prev=prev->next;
                        temp=lst->tail;
                        lst->tail=prev;
                        lst->count--;
                }
        }
        return temp;
}

PSNODE find_in_slist(PSLIST lst,int _key)
{
        PSNODE nd;
        nd=lst->head;
        while(nd!=NULL && nd->key!=_key) nd=nd->next;
        return nd;
}
void insert_in_slist(PSLIST lst,int _key,PSNODE nd)
{
        PSNODE tmp;
        tmp=lst->head;
        while(tmp!=NULL && tmp->key!=_key)
              tmp->next=tmp;
        if(!is_slist_overflow(lst))
        {
                if(tmp==NULL || tmp==lst->tail) append(lst,nd);
                else
                {
                        nd->next=tmp->next;
                        lst->count++;
                }
        }
}
PSNODE delete_from_slist(PSLIST lst,int _key)
{
        PSNODE prev,cur;
        prev=cur=lst->head;
        while(cur!=NULL && cur->key!=_key)
        {
                prev=cur;
                cur=cur->next;
        }
        if(cur!=NULL)
        {
                prev->next=cur->next;
                lst->count--;
                free(cur);
        }
}

файл slist.h:

#ifndef SLIST_H
#define SLIST_H
#define SLISTSIZE 100
typedef struct SNODE SNODE;
typedef struct SNODE *PSNODE;
struct SNODE
{
        int key;
	int info;
	PSNODE next;
}node;
typedef struct SLIST *PSLIST;
struct SLIST
{
	int size;
	int count;
	PSNODE head_tail;
}slist;
typedef enum {false,true} bool;
bool is_slist_empty(PSLIST);
bool is_slist_overflow(PSLIST);
void init_slist(PSLIST);
PSNODE get_from_head(PSLIST);
PSNODE get_from_tail(PSLIST);
void insert_in_slist(PSLIST,int,PSNODE);
PSNODE delete_from_slist(PSLIST,int);
void append(PSLIST,PSNODE);
void prepend(PSLIST,PSNODE);
PSNODE find_in_slist(PSLIST,int);
void print_slist(PSLIST);

#endif /*SLIST_H*/