Error en comentarios //

Este es el código que da error en todos los comentarios con doble barra, y en los comentarios con barra y asterisco no da error. ¿Porque ocurre esto?
Código
/*****************************************************************************
         PRAC3
******************************************************************************/
 
/****************************************************************************
         Includes
******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "marnet.h"
 
/******************************************************************************
         Funcions bàsiques
******************************************************************************/
 
void init_date (tDate *d)
{
     d->minutes =0;
     d->hour = 0;
     d->day = 0;
     d->month = 0;
     d->year = 0;
}
 
void get_current_date(tDate *d)
{
      time_t now;
      struct tm *tm;
 
      now = time(0);
      tm = localtime(&now);
 
      d->year = tm->tm_year+1900;
      d->month = tm->tm_mon+1;
      d->day = tm->tm_mday;
      d->hour =  tm->tm_hour+1;
      d->minutes = tm->tm_min+1;
}
 
/*****
         Funcions bàsiques tSupplier
******/
tSupplier newSupplier()
{
      int i;
      tSupplier sup;
 
      sup.idSupplier = 0;
      sup.name[0] = '\0';
      sup.addr[0] = '\0';
      for( i = 0; i < MAX_PHONE; i++ )
           sup.phone[i] = 0;
      sup.firstFur = NULL;
      sup.currFur = NULL;          
      sup.profitMargin = 0.0;
 
      return sup;
}
 
int sup_get_id( tSupplier s )
{
    return s.idSupplier;
}
 
void sup_set_id( tSupplier *s, int i )
{
    s->idSupplier = i;
}
void sup_get_name( tSupplier s, tString *st )
{
    strcpy( *st, s.name );
}
void sup_set_name( tSupplier *s, tString n )
{     
    strcpy( s->name, n );
}
void sup_get_addr( tSupplier s, tString *st )
{
     strcpy( *st, s.addr );
}
void sup_set_add( tSupplier *s, tString n )
{     
    strcpy( s->addr, n );
}
void sup_get_phone( tSupplier s, int phone[MAX_PHONE] )
{
     int i;
     for( i = 0; i < MAX_PHONE; i++ )
           phone[i] = s.phone[i];
}
void sup_set_phone( tSupplier *s, int phone[MAX_PHONE] )
{     
      int i;
      for( i = 0; i < MAX_PHONE; i++ )
           s->phone[i] = phone[i];
}
 
/*****
         Funcions bàsiques tFurniture
*****/
tFurniture newFurniture()
{
    int i;
    tFurniture fur;
 
    fur.idFurniture = 0;
    fur.idSup = 0;
    fur.nameFur[0] = '\0';
    for( i = 0; i < MAX_SIZES; i++ )
       fur.sizes[i] = 0.0;
    fur.typeFur[0] = '\0';
    fur.color = white;
    fur.costPrice = 0.0;
    fur.retailPrice = 0.0;
    fur.deliveryTime = 0;
    fur.prevFur = NULL;
    fur.nextFur = NULL;
    fur.prevFurType = NULL;
    fur.nextFurType = NULL;
 
    return fur;
}
 
int fur_get_id( tFurniture f )
{
    return f.idFurniture;
}
void fur_set_id( tFurniture *f, int i )
{
    f->idFurniture = i;
}
int fur_get_idSupplier( tFurniture f )
{
    return f.idSup;
}
void fur_set_idSupplier( tFurniture *f, int i )
{
    f->idSup = i;
}
void fur_get_name( tFurniture f, tString *st )
{
    strcpy( *st, f.nameFur );
}
void fur_set_name( tFurniture *f, tString n )
{     
    strcpy( f->nameFur, n );
}
void fur_get_sizes( tFurniture f, float r[MAX_SIZES] )
{
     int i;
     for( i = 0; i < MAX_SIZES; i++ )
           r[i] = f.sizes[i];
}
void fur_set_sizes( tFurniture *f, float r[MAX_SIZES] )
{     
      int i;
      for( i = 0; i < MAX_SIZES; i++ )
           f->sizes[i] = r[i];
}
void fur_get_type( tFurniture f, tString *st )
{
    strcpy( *st, f.typeFur );
}
void fur_set_type( tFurniture *f, tString n )
{     
    strcpy( f->typeFur, n );
}
tColor fur_get_color( tFurniture f )
{
    return f.color;
}
void fur_set_color( tFurniture *f, tColor c )
{
    f->color = c;
}
float fur_get_costPrice( tFurniture f )
{
    return f.costPrice;
}
void fur_set_costPrice( tFurniture *f, float r )
{
    f->costPrice = r;
}
float fur_get_retailPrice( tFurniture f )
{
    return f.retailPrice;
}
void fur_set_retailPrice( tFurniture *f, float r )
{
    f->retailPrice = r;
}
int fur_get_deliveryTime( tFurniture f )
{
    return f.deliveryTime;
}
void fur_set_deliveryTime( tFurniture *f, int i )
{
    f->deliveryTime = i;
}
 
/*****
         Funcions bàsiques tCustomerOrder
*****/
tCustomerOrder newCustOrder()
{
    int i;
    tCustomerOrder co;
 
    co.idOrder = 0;
    co.nameCust[0] = '\0';
    co.addrCust[0] = '\0';
    for( i = 0; i < MAX_PHONE; i++ )
        co.phoneCust[i] = 0;
    init_date(&co.createdDate);
    co.state = cPending;
    co.firstItem = NULL;
    co.currItem = NULL;
    co. nextCustOrder = NULL;
 
    return co;
}
 
int custOrd_get_id( tCustomerOrder co )
{
    return co.idOrder;
}
void custOrd_set_id( tCustomerOrder *co, int i )
{
    co->idOrder = i;
}
void custOrd_get_name( tCustomerOrder co, tString *st )
{
    strcpy( *st, co.nameCust );
}
void custOrd_set_name( tCustomerOrder *co, tString n )
{     
    strcpy( co->nameCust, n );
}
void custOrd_get_addr( tCustomerOrder co, tString *st )
{
    strcpy( *st, co.addrCust );
}
void custOrd_set_addr( tCustomerOrder *co, tString n )
{     
    strcpy( co->addrCust, n );
}
void custOrd_get_phone( tCustomerOrder co, int phone[MAX_PHONE] )
{
     int i;
     for( i = 0; i < MAX_PHONE; i++ )
           phone[i] = co.phoneCust[i];
}
void custOrd_set_phone( tCustomerOrder *co, int phone[MAX_PHONE] )
{     
      int i;
      for( i = 0; i < MAX_PHONE; i++ )
           co->phoneCust[i] = phone[i];
}
tDate custOrd_get_createdDate( tCustomerOrder co )
{
    return co.createdDate;
}
void custOrd_set_createdDate( tCustomerOrder *co, tDate td )
{     
    co->createdDate = td;
}
tCustState custOrd_get_state( tCustomerOrder co )
{
    return co.state;
}
void custOrd_set_state( tCustomerOrder *co, tCustState st )
{     
    co->state = st;
}
 
 
/*****
         Funcions bàsiques tOrderRow
*****/
int orderRow_get_idProv( tOrderRow o )
{
    return o.idProv;
}
void orderRow_set_idProv( tOrderRow *o, int i )
{
    o->idProv = i;
}
int orderRow_get_idFur( tOrderRow o )
{
    return o.idFur;
}
void orderRow_set_idFur( tOrderRow *o, int i )
{
    o->idFur = i;
}
int orderRow_get_unit( tOrderRow o )
{
    return o.unit;
}
void orderRow_set_unit( tOrderRow *o, int i )
{
    o->unit = i;
}
float orderRow_get_unitCostPrice( tOrderRow o )
{
    return o.unitCostPrice;
}
void orderRow_set_unitCostPrice( tOrderRow *o, float i )
{
    o->unitCostPrice = i;
}
float orderRow_get_profitMargin( tOrderRow o )
{
    return o.profitMargin;
}
void orderRow_set_profitMargin( tOrderRow *o, float i )
{
    o->profitMargin = i;
}
 
/*****
         Funcions bàsiques tSupplierOrder
*****/
tSupplierOrder *newSupplierOrder()
{
      int i;
      tSupplierOrder *supOrd;
 
      supOrd = malloc(sizeof(tSupplierOrder));
 
      supOrd->idOrder = 0;
      supOrd->idSupplier = 0;
      init_date(&supOrd->createdDate);
      init_date(&supOrd->receivedDate);
      supOrd->state = sPending;
      supOrd->firstItem = NULL;
      supOrd->currItem = NULL;
      supOrd->totalPrice = 0;
      supOrd->nextSupOrder = NULL;
 
      return supOrd;
}
int supOrd_get_id( tSupplierOrder so )
{
    return so.idOrder;
}
void supOrd_set_id( tSupplierOrder *so, int i )
{
    so->idOrder = i;
}
int supOrd_get_idSupplier( tSupplierOrder so )
{
    return so.idSupplier;
}
void supOrd_set_idSupplier( tSupplierOrder *so, int i )
{
    so->idSupplier = i;
}
tDate supOrd_get_createdDate( tSupplierOrder so )
{
    return so.createdDate;
}
void supOrd_set_createdDate( tSupplierOrder *so, tDate td )
{     
    so->createdDate = td;
}
tDate supOrd_get_receivedDate( tSupplierOrder so )
{
    return so.receivedDate;
}
void supOrd_set_receivedDate( tSupplierOrder *so, tDate td )
{     
    so->receivedDate = td;
}
tSupState supOrd_get_state( tSupplierOrder so )
{
    return so.state;
}
void supOrd_set_state( tSupplierOrder *so, tSupState st )
{
    so->state = st;
}
float supOrd_get_totalPrice( tSupplierOrder so )
{
    return so.totalPrice;
}
void supOrd_set_totalPrice( tSupplierOrder *so, float r )
{
    so->totalPrice = r;
}
 
/*****
         Funcions basiques: Esborrar moble del cataleg d'un proveidor
*****/
void sup_del_furniture (tSupplier *s, tFurniture f)
{
     // recuperem la llista de tFurniture's del supplier
     tFurniture *current;
 
     // Busquem el moble a esborrar
     current = s->firstFur;
     while( (current != NULL) && (current->idFurniture != f.idFurniture))
     {
            current = current->nextFur;
     }
 
     // Si hem trobat el moble: actualitzem apuntadors de les llistes doblement encadenades a les queal pentany
     if( current->idFurniture == f.idFurniture )
     {
         // Llista de mobles de tSupplier
         // Actualitzem apuntador seguent de prevFur a l'element seguent al que estem esborrant
         if( current->prevFur )
         {
             current->prevFur->nextFur = current->nextFur;
         }
         // Actualitzem apuntador anterior de nextFur a l'element anterio al que estem esborrant
         if( current->nextFur )
         {
             current->nextFur->prevFur = current->prevFur;
         }
 
         // Llista de mobles de tType
         // Actualitzem apuntador seguent de prevFurType a l'element seguent al que estem esborrant
         if( current->prevFurType )
         {
             current->prevFurType->nextFurType = current->nextFurType;
         }
         // Actualitzem apuntador anterior de nextFurType a l'element anterio al que estem esborrant
         if( current->nextFurType )
         {
             current->nextFurType->prevFurType = current->prevFurType;
         }
     }
}
 
 
/*****
         Funcions basiques: Crear/Consultar/Modificar el percentatge de beneficis a un preu de cost
*****/
float sup_get_profitMargin (tSupplier s)
{
      return s.profitMargin;
}
 
void sup_set_profitMargin (tSupplier *s, float r)
{
     tFurniture *furAux;
 
     s->profitMargin = r;
 
     // Hem de recorrer tot el cataleg de mobles per actualitzar el PVP amb el nou percentatge de beneficis
     furAux = s->firstFur;
     while(furAux != NULL)
     {
        furAux->retailPrice = furAux->costPrice + (furAux->costPrice * r / 100);
        furAux = furAux->nextFur;
     }
}
/*****
         Funcions basiques: Crear comanda a proveïdors a partir de la comanda del client
*****/
 
// Afegim funcio auxiliar getNewSupIdOrder que ens retorna un nou id de comanda proveidors
int getNewSupIdOrder(int idCustOrder, int idSupplier)
{
    tString aux;
    int newID;
 
    // Per crear un nou idSupplier per a la comanda a proveidors concatenem id comanda client amb id proveidor
    sprintf(aux, "%d%d", idCustOrder, idSupplier);
    newID = atoi(aux);
 
    return newID;
}
 
tSupplierOrder *supOrder_create(tCustomerOrder co)
{
     tOrderRow *rowCus;
     tSupplierOrder *supOrd, *firstSupOrd, *currentSupOrd, *auxSupOrd;
 
     // Inicialitzem la llista 
     supOrd = malloc(sizeof(tSupplierOrder));
     // so = NULL;
     firstSupOrd = supOrd;
     currentSupOrd = supOrd;
 
     // Creem un tSupplierOrder per a cadascun dels diferents proveidors que tenim en la comanda de client
 
     // Buscar primer tOrderRow (firstItem) i recorrer tota llista
     rowCus = co.firstItem;
     while(rowCus != NULL)
     {
          auxSupOrd = firstSupOrd;
          // Comprovem si ja tenim inicialitzada una comanda a proveidor
          while((auxSupOrd != NULL) && (rowCus->idProv != auxSupOrd->idSupplier))
          {
                    auxSupOrd = auxSupOrd->nextSupOrder;               
          }
          // Comprovem si hem trobat comanda a proveidor ja inicialitzada
          if(rowCus->idProv == auxSupOrd->idSupplier)
          {
                        //Afegim un nou tOrderRow a la comanda a proveidor
                        rowCus->nextOrderRowSup = NULL;
                        auxSupOrd->currItem->nextOrderRowSup = rowCus;
                        auxSupOrd->currItem = auxSupOrd->currItem->nextOrderRowSup;
                        auxSupOrd->totalPrice += rowCus->unit * rowCus->unitCostPrice;
          }
          else
          {
              // No hem trobat el proveidor a la llista, hem de crear una nova comanda
              currentSupOrd->nextSupOrder = malloc(sizeof(tSupplierOrder));
              currentSupOrd->nextSupOrder = newSupplierOrder();
              currentSupOrd = currentSupOrd->nextSupOrder;
              currentSupOrd->idOrder = getNewSupIdOrder(co.idOrder, currentSupOrd->idSupplier);
              currentSupOrd->idSupplier = rowCus->idProv;
              get_current_date(&currentSupOrd->createdDate);
              rowCus->nextOrderRowSup = NULL;
              currentSupOrd->firstItem = rowCus;
              currentSupOrd->currItem = rowCus;
              currentSupOrd->totalPrice = rowCus->unit * rowCus->unitCostPrice;
          }
          rowCus = rowCus->nextOrderRow;
     }
}
 
 
/*****************************************************************************
         Operacions especials delivery_time i warehouse_stock. 
******************************************************************************/
tFurniture *get_furniture( tShop ts, int idSup, int idFur)
{
           tSupplier sup;
           tFurniture *fur;
           int i;
 
           fur = NULL; //Important per si no trobem proveidor o moble
           i = 0;
 
           // Busquem el proveidor
           while ((i<MAX_SUPPLIERS) && (ts.suppliers[i].idSupplier != idSup))
                 i++;
 
           if(ts.suppliers[i].idSupplier == idSup)
           {
                sup = ts.suppliers[i];
                // Busquem el moble
                fur = sup.firstFur;
                while((fur != NULL) && (fur->idFurniture !=idFur))
                           fur = fur->nextFur;
                // Quan sortim del bucle while o hem trobat el moble o estem al final de la llista
           }
 
           return fur;
}
 
/***** 
        delivery_time: Calcula el termini d'entrega d'una comanda client. 
        Depèn del màxim termini entrega (per part dels proveïdors) de tota la comanda
******/
int delivery_time(tShop ts, tCustomerOrder co)
{
    int maxDays;
    tOrderRow *row;
    tFurniture *fur;
 
    maxDays = 0;
    // Per a cada moble en la comanda de client busquem el corresponent tFurniture
    row = co.firstItem;
    while (row != NULL)
    {
          // Busquem moble
          fur = get_furniture(ts, row->idProv, row->idFur);
          if(fur!=NULL)
          {
               // Si el termini entrega es major que el maxim, actualitzem el maxim
               if(maxDays < fur->deliveryTime)
                    maxDays = fur->deliveryTime;
          }
          // Busquem seguent moble
          row = row->nextOrderRow;
    }
 
    return maxDays;
}
 
/*****
        warehouse_stock: Estoc del magatzem, és a dir, llistat de comandes rebudes i pendents d'entregar al client.
        Entenem que llistats surten per pantalla
*****/
void warehouse_stock(tShop ts)
{
     tCustomerOrder *custOrder;
 
     printf("WAREHOUSE STOCK:\n\n");     
     custOrder = ts.firstCustOrder;
     while(custOrder != NULL)
     {
          // Imprimim per pantalla la comanda
          if(custOrder->state == inWarehouse)
          {
               printf("ID:%d\tCUSTOMER:%s\tDATE:%d/%d/%d\tSTATE:%s\n",
                    custOrder->idOrder, custOrder->nameCust, 
                    custOrder->createdDate.day, custOrder->createdDate.month, 
                    custOrder->createdDate.year, custOrder->state);
          }
          custOrder = custOrder->nextCustOrder;
     }
}
 
 
/*****************************************************************************
         funció sort_supOrder que ordena la llista de comandes a proveïdors 
         de manera descendent, segons el preu total de la comanda. 
         Per a la ordenació utilitza el mètode de classificació Merge Sort.
******************************************************************************/
 
/*****
      combine: funcio auxiliar que combina dues llistes de manera ordenada
*****/
void combine (tSupplierOrder out[], int left, int middle, int right, int size)
{
  int r, i, j;
  tSupplierOrder outAux[size];
 
  r = left;
  i = left;
  j = middle + 1;
 
  while ((i <= middle) && (j <= right) && (j < size))
  {
     if(out[i].totalPrice > out[j].totalPrice) 
     {
        outAux[r] = out[i];
        i++;
        r++;
     }
     else 
     {
          outAux[r] = out[j];
          j++;
          r++;
     }
  }
 
  while(i <= middle)
  {
          outAux[r] = out[i];
          i++;
          r++;
  }
 
  while(j <= right)
  {
          outAux[r] = out[j];
          j++;
          r++;
  }
 
 
  for(i=left; i<=right; i++)
          out[i] = outAux[i];
}
 
/*****
      merge_sort: funcio auxiliar recursiva que aplica el metode Merge Sort
*****/
void merge_sort (tSupplierOrder s[], int left, int right, int size)
{
   int middle;
   tSupplierOrder *listLeft, *listRight;
 
   if (left < right) 
   {
      middle = (left + right) / 2; 
      merge_sort(s, left, middle, size);
      merge_sort(s, middle+1, right, size);
      combine(s, left, middle, right, size);
   } 
}
 
void sort_supOrder(tShop *t)
{
     int left, right, i, rightAux;
     tSupplierOrder *aux, *aux2;
 
     left = 0;
     right = 0;
 
     // Calculem el numero de comandes de proveidors que tenim i ho desem right (limit dret)
     aux = t->firstSupOrder;
     while(aux != NULL)
     {
               right++;
               aux = aux->nextSupOrder;
     }
 
     // Creem una copia de la llista en el vector i anem esborrant i alliberant memoria
     tSupplierOrder supOrders[right];
 
     aux = t->firstSupOrder;
     for(i=0; i<right; i++)
     {
              supOrders[i] = *aux;
              aux2 = aux;
              aux = aux->nextSupOrder;
              free(aux2);
     }
 
     // Cridem a la funcio merge_sort amb el nou vector i els limits Esquerre i Dret
     rightAux = right;
     merge_sort(supOrders, left, right-1, right);
 
     // Mostrem resultats per pantalla
     for(i=0; i<right; i++)
     {
              printf("idOrder:%d\ttotalPrice:%f\n", supOrders[i].idOrder, supOrders[i].totalPrice);
     }
     // Restaurem llista i actualitzem apuntadors
     aux = malloc(sizeof(tSupplierOrder));
     t->firstSupOrder = aux;
     for(i=0; i<right-1; i++)
     {
              *aux = supOrders[i];
              aux->nextSupOrder = malloc(sizeof(tSupplierOrder));
              aux = aux->nextSupOrder;
     }
     *aux = supOrders[i];
     aux->nextSupOrder = NULL;
}