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;
}

---

It's nothing to do with your code (at least not yet it isn't).

You (or your IDE) didn't create the makefile properly.

At the very least, post the contents of the file which you mentioned.

Also, which compiler are you using?

It looks like the file wasn't made because it is empty. I am using DEV C compiler. What should be in the makefile??