Error en comentarios //

[chemaspain]

Hola a todos.

Esta es una cuestión simple para expertos como vosotros.

¿por que me da error el compilador al compilar un programa en todos los comentarios con la doble barra? Es como si no reconociese ese tipo de comentarios.

Y no encuentro el lugar donde indicarle al DEV-C++ para que los reconozca.

Saludos.
Jose.

[satu]

Hola

No tiene sentido, pon la parte del código donde tienes los comentarios para que veamos pero en principio debería funcionar.

Asegúrate de que son las barras // o que no se te olvide algún ;

Saludos

[chemaspain]

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 (c) [Seleccionar] Expandir


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




[Queta]

Quizás el error proviene del archivo de cabecera (marnet.h). Sería bueno que también nos lo dieras...

[chemaspain]

En el archivo de cabecera solo vienen las predeclaraciones de las funciones, y alli no da ningun error. Todos los errores los da en este archivo.

[Akai]

Existe la posibilidad de que dejes de usar Dev-C++, compilador e IDE obsoletos y uses algo más reciente como codeblocks?

Lo de los comentarios me suena a cuestión del estándar del 90, pero a saber. Con Dev-C++ empiezo a tomarme los errores a puro cachondeo ya.

Además, si estás hablando de errores, pon el log de errores y sabremos a lo que te refieres.

[chemaspain]

Existiría la posibilidad si dependiera de mi esa elección, pero es mandato de la universidad.

Aun así por simple curiosidad, y aunque no conocía codeblocks, supongo que buscando con San Google encontraré rápidamente de donde bajarlo.

Aqui tienes el codigo del log de errores:

Código (dos) [Seleccionar] Expandir

Compilador: Default compiler
Building Makefile: "C:\Users\...........\Documents\...............\Makefile.win"
Ejecutando  make clean
rm -f inout.o marnet.o prac.o prac3_private.res prac3.exe
gcc.exe -D__DEBUG__ -c inout.c -o inout.o -I"C:/Dev-Cpp/include"    -ansi -O2 -pg -g3
gcc.exe -D__DEBUG__ -c marnet.c -o marnet.o -I"C:/Dev-Cpp/include"    -ansi -O2 -pg -g3
marnet.c: In function `sup_del_furniture':
marnet.c:399: error: syntax error before '/' token
marnet.c:399: error: missing terminating ' character
marnet.c:404: error: `current' undeclared (first use in this function)
marnet.c:404: error: (Each undeclared identifier is reported only once
marnet.c:404: error: for each function it appears in.)
marnet.c:409: error: syntax error before '/' token
marnet.c:413: error: missing terminating ' character
marnet.c: At top level:
marnet.c:418: error: missing terminating ' character
marnet.c:425: error: missing terminating ' character
marnet.c:430: error: missing terminating ' character
marnet.c: In function `sup_set_profitMargin':
marnet.c:453: error: syntax error before '/' token
marnet.c: At top level:
marnet.c:465: error: syntax error before '/' token
marnet.c:471: error: syntax error before '/' token
marnet.c:473: error: `aux' undeclared here (not in a function)
marnet.c:473: error: initializer element is not constant
marnet.c:473: warning: data definition has no type or storage class
marnet.c:475: error: syntax error before "return"
marnet.c: In function `supOrder_create':
marnet.c:483: error: syntax error before '/' token
marnet.c:489: error: syntax error before '/' token
marnet.c:496: error: syntax error before '/' token
marnet.c: At top level:
marnet.c:510: error: syntax error before "else"
marnet.c:515: error: invalid type argument of `->'
marnet.c:515: warning: data definition has no type or storage class
marnet.c:516: error: syntax error before '->' token
marnet.c:518: error: syntax error before '&' token
marnet.c:518: error: conflicting types for 'get_current_date'
marnet.c:28: error: previous definition of 'get_current_date' was here
marnet.c:518: warning: data definition has no type or storage class
marnet.c:519: error: syntax error before '->' token
marnet.c:524: error: invalid type argument of `->'
marnet.c:524: warning: data definition has no type or storage class
marnet.c:525: error: syntax error before '}' token
marnet.c: In function `get_furniture':
marnet.c:538: error: syntax error before '/' token
marnet.c:548: error: syntax error before '/' token
marnet.c:552: error: syntax error before '/' token
marnet.c: In function `delivery_time':
marnet.c:569: error: syntax error before '/' token
marnet.c:573: error: syntax error before '/' token
marnet.c:577: error: syntax error before '/' token
marnet.c: In function `warehouse_stock':
marnet.c:600: error: syntax error before '/' token
marnet.c: At top level:
marnet.c:610: error: syntax error before '}' token
marnet.c: In function `sort_supOrder':
marnet.c:691: error: syntax error before '/' token
marnet.c:699: error: syntax error before '/' token
marnet.c:705: error: `supOrders' undeclared (first use in this function)
marnet.c:711: error: syntax error before '/' token
marnet.c:715: error: syntax error before '/' token
marnet.c:716: error: syntax error before ')' token
marnet.c: At top level:
marnet.c:727: error: invalid type argument of `->'
marnet.c:727: warning: data definition has no type or storage class
marnet.c:728: error: syntax error before '}' token
marnet.c:729: error: conflicting types for 'aux'
marnet.c:727: error: previous definition of 'aux' was here
marnet.c:729: error: conflicting types for 'aux'
marnet.c:727: error: previous definition of 'aux' was here
marnet.c:729: error: `supOrders' undeclared here (not in a function)
marnet.c:729: error: `i' undeclared here (not in a function)
marnet.c:729: warning: data definition has no type or storage class
marnet.c:730: error: syntax error before '->' token
make.exe: *** [marnet.o] Error 1
Ejecución Terminada


[Akai]

Como te decíamos, quita los comentarios con //, tu "compilador" no los reconoce.