Thread: compiler build error

This is the error I am getting. Can anybody help with this??? Code to follow error line.

G:\Makefile.win
[Build Error] No rule to make target `all'. Stop.

Code:

// File: ListType.h  Class and type definitions for the C++ dynamic 
// memory allocation imlementationof ADT list

#ifndef LISTDO_H
#define LISTDO_H

#endif

#include "el_t.h"

typedef struct node_t* pointer_t;
struct node_t
{
    el_t         el;
    pointer_t    next;
};

class list
{
    public:
    // List constructor and destructor
    list(void);
    ~list(void);
    
    //Methods that manipulate list nodes
    void    StoreInfo(el_t);
    el_t    RetrieveInfo(void);
    el_t    RetrieveNextInfo(void);
    
    //Methods that manipulate the list
    void    Insert(el_t);
    void    InsertAfter(el_t);
    void    Delete(void);
    
    //Methods that test for certain conditions
    bool    AtFirst(void);
    bool    AtEnd(void);
    bool    ListIsEmpty(void);
    bool    ListIsFull(void);
    bool    CurIsEmpty(void);
    
   
    protected:
    pointer_t     head;    //pointer to head node
    pointer_t     cur;     //pointer to current node
    pointer_t     prev;    //pointer to previous node
    
    pointer_t     MakeNode(el_t);
    void          DestroyNode(pointer_t);
    void          NodeReferenceError(void);
    
};

// File: ListTypeImp.cpp  Contents: C++ source code for dynamic memeory
// allocation implementations of ADT list

#include<iostream.h>
#include<stdlib.h>
#include "ListType.h"

using namespace std;

// Default constructor; initializes a list to empty
//Pre:none
//Post: The head, current, and previous pointers are empty

list::list(void)
{
    head = NULL;
    cur = NULL;
    prev = NULL;
}

// List destructor function
//Pre: The lis thas gone out of scope or an explicit call
//     to the list destructor has occurred.
//Post:All the nodes of this list have been destoryed.

list::~list(void)
{
    ToFirst();
    while(!ListIsEmpty())
        Delete():
}

// Boolean function to return TRUE if the list is empty
// Pre: The list has been intialized
//Post: The function has returned TRUE if the list is empty,
//      FALSE otherwise.

bool list::ListIsEmpty(void)
{
    return (head == NULL ?  true : false);
}

// Boolean function to return TRUE if list is full
//Pre: The list has been intialized
//Post: The function has returned FALSE because, within the 
//      bounds of memory size, the list never fills.

bool list::ListIsFull(void)
{
    return false;
}

// Boolean function to return TRUE if the current postion is 
// empty
//Pre:  The list has been intialized
//Post: The function return TRUE if there is no current node,
//      FALSE otherwise

list::CurIsEmpty(void)
{
    return ( cur == NULL true : false);
}

// Function to set the curr3ent node to the head node
// Pre: The list has been intialized
//Post: cur has the value of head (NULL of address of first node)

void list::ToFirst(void)
{
    cur = head;
    prev = NULL;
}

// Function to return TRUE if the current position is at head 
// node or the list is empty
//Pre: cur is NULL or a reference node.
//Post: The function returned TRUE if cur has the same value as head
//      (NULL or address of first node); FALSE otherwise

bool list::AtFirst(void)
{
    return (head == cur ? true : false);
}

// Boolean function to return TRUE if the current node is the last in
// the list or the list is empty
//Pre: The list has been intialized
//Post: The funtion has returned TRUE if the current node is the last
//      node or the lsit is empty; FALSE otherwise

bool list::AtEnd(void)
{
    bool rc;    //return code
    
    if ListIsEmpty())
        rc = true;
    else if (CurisEmpty())
        rc = false;
    else
        rc = (cur -> next == NULL ? true : false );

    return (rc);
}

//Function to make a nonempty current position indicate the nest 
//node in the list
//Pre: The list has an nonempty current position
//Post: cur points to the next node ir os NULL incase cur intitially
//      pointed to the last node.  If the current positionwas NULL
//      initally, errorhandling routine NOdeReferenceError was called.

void list::Advance(void)
{
    if (curIsEmpty())
        NodeReferenceError();
    else
        {
        prev = cur;
        cur = cur -> next;
        }
}

// Funtion to insert new node adfter the current node
//Pre: The list is empty or there is a current node. e is the 
//     value for the node to be inserted.
//Post: The list has a new node with e's value. If the list was
//      empty initially, this is the only node.  If not, the new node
//      is after the current node.  If the list was not empty but the current
//      position was, then NodeRefernceError was called.

void list::InsertAfter(el_t e)
{
    pointer_t target = MakeNode(e);
    
    if (ListIsEmpty())        // create one-element list
    {
        head = target;
        cur = target;
        prev = NULL;
    }
    else if (CurIsEmpty())    //empty cur, nonempty list
        NodeRefernnceError();
    else                        // insert after current node
        {
           target -> next = cur -> next;
           cur -> next = target;
        }
}

// Function to insert a node before the current node and make the new
// node the current node
//Pre: The list is empty or there is a current node.  e is the value
//       for the node to be inserted
//Post:  The lsit has a new node with e's value.  If the list was
//       empty initially, this is the only node.  If not, the new
//       node is before the former current node.  The new node is 
//       now the current node.  If the list was not empty but the
//       current position was, then NodeRefernceError was called.

void list::Insert(el_t e) 
{
    pointer_t target = MakeNode(e);
    
    if (ListIsEmpty())        // create one-element list
    {
        head = target;
        cur = target;
        prev = NULL;
    }
    else if (CurIsEmpty())    // empty cur, nonempty list
        NodeRefernceError();
    else if (atFirst())        //new head node
    {
        target -> next = cur;
        head = target;
        cur = target;
    }
    else                        // insert between 2 nodes
        {
                target -> next = cur;
                prev->next = target;
                cur = target;
        }
}

// Function to delete the current node of the list
//Pre: The list is nonempty with a nonempty current position.
//Post: The list has been revised so that the former current
//      node has been deleted and its successor has become the new 
//      current node.

void list::Delete(void)
{
    pointer_t tmp;
    if(curIsEmpty())        //empty list of cur
        NodeRefernceError();
    else if (AtFirst())        //delete head node
        {
            tmp = cur;
            cur = cur -> next;
            head = cur;
            DestroyNode(tmp);
        }
    else
        {     
            tmp = cur;
            cur = cur-> next;
            prev->next = cur;
            DestroyNode(tmp);
        }
}

// Function to store a value in the information field of the 
// current node
//Pre:  There is a current node, and e is the type el_t
//Post: The information field of the current node has e's value
//      If there is no such node, NodeREfernceError was called

void list::StoreInfo(el_t e)
{
    if (CurIsEmpty())
        NodeRefernceError();
    else
        cur->el = e;
}

// Function to return the information portion fo the current node
//Pre:  There is no current node
//Post:  The function returns information field of the current node.
//       If there is no such node, NodeRefernceError ws called.

el_t list::RetrieveInfo(void)
{
    if (CurIsEmpty())
        NodeRefernceError();
    
    retrun (cur->el);
}

//Function to return the value from the information field of node
// after the current node
// Pre: There is a current node that is not the last node
//Post: The informnation field of the node after current node has
//      been returned.  If there is no such node, NodeRefernceError
//      was called.

el_t list::RetreiveNextInfo(void)
{
    if (CurIsEmpty() || AtEnd())
        NodeRefernceError();
    
    return ((cur->next)->el);
}

//Function to place information into a new node and return a 
//pointer to that node.
//Pre: e is an item of type el_t.
//Post: The function has returned a pointer (type pointer_t)
//      to a node that contains an information portion with value
//      e and a link portion with value NULL.  If allocation failed
//      the program aborted.

pointer_t list::MakeNode(el_t e)
{
    pointer_t p = new node_t;
    
    if(!p)
    {
        cerr <<"Error making node\n";
        exit(1);
    }
    else
    {
        p->el = e;
        p->next = NULL;
    }
    return p;
}

//Function to destroy a list node
//Pre: p points to a node
//Post: The node has been freed.

void list::DestroyNode(pointer_t p)
{
    delete p;
}

//Error procedure for no current node or an improper node
//Pre: A node reference error condition exists.
//Post: An error message has been printed and the program aborted

void list::NodeRefernceError(void)
{
    cerr<< "Error: No current node or an improper node\n";
    exit(1);
}
#include <iostream>
#include <ctdlib>
#include "ListType.h"
#include <fstream>

int main
{
  
/*truct el_t 
  {
    int  int_field;
    char char_field;
    link 
   not sure that this belongs yet */
  list L;
  el_t e;
  
  system("PAUSE");	
  return 0;
}