Newsgroup: it.comp.lang.c++
Titolo: Help !!

Il programma allegato al presente,in fase di compilazione segnala alcuni
errori
se potete aiutarmi vi sarei veramente grato
Ps.
purtoppo uso altri linguaggi di programmazione ( area AS/400 Iseries )
Grazie
==========================================================================
==========================================================================
==========================================================================
==========================================================================
==========================================================================
/*
    KNAP.C  by  Kai Risku, 1992, 1993
    Crunching program to solve knapsack problem.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
/* Round "a" up to nearest higher multiple of "n" */
#define ROUND_UP(a,n) (((a)+((n)-(1))) - ((a)+((n)-1)) % n)
#define VER "2.0"
#define OPT_NOGROUP     0x01
#define OPT_OVERFLOW    0x02
#define OPT_VERBOSE     0x04
struct filespec
{
    long size;
    char *name;
    int dest;
    struct filespec *next;
};
typedef struct
{
    int options;            /* bitfield options */
    int sizepos;            /* position of size */
    long items;             /* number of items */
    long threshold;         /* accept fit when space<=threshold */
    long quant;             /* round up itemsizes to nearest multiple of
quant */
    long total;             /* total space to be filled */
    struct filespec *firstspec;
                            /* following used in recur: */
    int  kbhit;
    long recleft;
    int  disk;
    int  maxlevel;
} globstr;
/* Global variables */
struct filespec **specs;        /* pointer to list of filespec pointers */
int *fits;                      /* used in "fitting" files */
globstr glob;                   /* global data & options */
unsigned _stklen = 32000;       /* set a bigger stack */
void usage( void );
long get_item_info( void );
int  get_cmd_line( int ac, char *av[] );
void do_fit( void );
void do_disk( int diskno, int maxdisk );
int  sort_seq( void );
int  sort_big( void );
int  recur( long space, struct filespec *this, int level );
void freeall( void );
void flag_int( void );
int  split_line( char *s, char *args[] );
void usage( void )
{
    fputs( "KNAP ver "VER", "__DATE__" by Kai Risku\n\n"
           "KNAP tries to optimally fit the items with\n"
           "associated sizes into bins of the given targetsize.\n\n"
           "Usage:   KNAP [options] targetsize [< file]\n\n"
           "Options: -n       no opt; files assigned in given order\n"
           "         -o       allow overflow (greater than targetsize)\n"
           "         -v       verbose; output more info to stderr\n"
           "         -p val   set position of itemsize in inputdata, default
is 2\n"
           "         -t val   set threshold to val, default is 0\n"
           "         -q val   set quantizing to val, default is 1\n"
            , stderr );
    exit( 1 );
}
int main( int argc, char *argv[] )
{
    int i, disks, wid;
    if( argc==1 )
    {
        usage();
        exit( 0 );
    }
    if( get_cmd_line( argc, argv )==0 )
        exit( 1 );                 /* error on command line */
    glob.items = get_item_info();
    if( glob.items==0L )
        fputs( "Nothing to do!\n", stderr );
    else
        do_fit();
    freeall();
    return( 0 );
}
int get_cmd_line( int ac, char *av[] )
{
    int ok, n, i;
    ok = 1;
    glob.options = 0;                   /* defaults */
    glob.total = 0L;
    glob.items = glob.threshold = 0L;
    glob.quant = 1L;
    glob.sizepos = 2;
    for( n=1; n<ac; n++ )
    {
        if( av[n][0]=='-' )
        {
            i = 1;
            while( av[n][i] )
            {
                switch( av[n][i] )         /* options */
                {
                    case 'n':   glob.options |= OPT_NOGROUP;
                                break;
                    case 'o':   glob.options |= OPT_OVERFLOW;
                                break;
                    case 'v':   glob.options |= OPT_VERBOSE;
                                break;
                    case 'p':   if( av[n][i+1]=='\0' )
                                    ok = sscanf( av[++n], "%d",
&glob.sizepos );
                                else
                                    ok = sscanf( &av[n][i+1], "%d",
&glob.sizepos );
                                if( ok==0 )
                                    fprintf( stderr, "Error in option %s\n",
av[n] );
                                i = strlen( av[n] ) - 1;
                                break;
                    case 't':   if( av[n][i+1]=='\0' )
                                    ok = sscanf( av[++n], "%ld",
&glob.threshold );
                                else
                                    ok = sscanf( &av[n][i+1], "%ld",
&glob.threshold );
                                if( ok==0 )
                                    fprintf( stderr, "Error in option %s\n",
av[n] );
                                i = strlen( av[n] ) - 1;
                                break;
                    case 'q':   if( av[n][i+1]=='\0' )
                                    ok = sscanf( av[++n], "%ld",
&glob.quant );
                                else
                                    ok = sscanf( &av[n][i+1], "%ld",
&glob.quant );
                                if( ok==0 )
                                    fprintf( stderr, "Error in option %s\n",
av[n] );
                                i = strlen( av[n] ) - 1;
                                break;
                    default:    fprintf( stderr, "Unknown option in %s\n",
                                            av[n] );
                                ok = 0;
                                break;
                }
                i++;
            }
        }
        else
        {
            if( glob.total!=0L )
                fprintf( stderr, "Ambiguous targetsize!\n" );
            else
            {
                ok = sscanf( av[n], "%ld", &glob.total );
                if( ok==0 )
                    fprintf( stderr, "Invalid targetsize '%s'!\n", av[n] );
            }
        }
    }
    if( glob.total==0L && ok==1 )
    {
        ok = 0;
        fputs( "No size given!\n", stderr );
    }
    glob.total = ROUND_UP( glob.total, glob.quant );
    return( ok );
}
/* here we read the itemnames and sizes into a linked list */
long get_item_info( void )
{
    int i, p;
    long size, qty;
    char str[81], str2[81], *args[64];
    struct filespec *prev, *node, *new;
    qty = 0L;
    glob.firstspec = (struct filespec *) calloc( 1, sizeof(struct
filespec) );
    prev = node = glob.firstspec;
    fgets( str, 81, stdin );
    while( !feof(stdin) )
    {
        if( str[strlen(str)-1]=='\n' )
            str[strlen(str)-1] = 0;
        strcpy( str2, str );
        i = split_line( str2, args );
        if( glob.sizepos>=0 )
            p = glob.sizepos;
        else
            p = i+glob.sizepos+1;
        if( sscanf( args[p-1], "%ld", &size )!=1 )
            size = -1L;
        if( i>=p && size<=glob.total && size>=0L )
        {
            new = (struct filespec *) calloc( 1, sizeof(struct filespec) );
            new->name = strdup( str );
            new->size = ROUND_UP( size, glob.quant );
            new->next = prev->next;
            prev->next = new;
            prev = new;
            qty++;
        }
        else
        {
            if( glob.options&OPT_VERBOSE )
            {
                fprintf( stderr, "Skipped line: '%s'\n", str );
                if( i<p )
                {
                    fprintf( stderr, "Too few arguments in line!\n" );
                }
                else
                {
                    if( size>glob.total )
                        fprintf( stderr, "Itemsize exceeds targetsize!\n" );
                    else
                        fprintf( stderr, "Invalid itemsize: %s\n",
args[glob.sizepos-1] );
                }
            }
        }
        fgets( str, 81, stdin );
    }
    fits = (int *)calloc( qty, sizeof(int) );
    specs = (struct filespec **)calloc( qty, sizeof(struct filespec*) );
    i = 0;
    node = glob.firstspec->next;
    while( node!=NULL )
    {
        fits[i] = -1;
        specs[i] = node;
        node = node->next;
        i++;
    }
    return( qty );
}
void do_fit( void )
{
    int dd, i;
    long totbytes;
    struct filespec *node;
    totbytes = 0L;
    for( i=0; i<glob.items; i++ )
        totbytes += specs[i]->size;
    if( glob.options&OPT_NOGROUP )
        dd = sort_seq();
    else
        dd = sort_big();
    for( i=1; i<=dd; i++)
        do_disk( i, dd );
}
void do_disk( int diskno, int maxdisk )
{
    int i;
    long l, t;
    puts( "" );
    printf( "# Bin %d of %d:\n", diskno, maxdisk );
    l = 0L;
    for( i=0; i<glob.items; i++ )
    {
        if( specs[i]->dest==diskno )
        {
            printf( " %s\n", specs[i]->name );
            l += specs[i]->size;
        }
    }
    t = glob.total - l;
    printf( "## Total size: %6ld (%ld %s target)\n", l, labs( t ),
t<0?"over":"from" );
}
/* sort files sequentially on the disks */
int sort_seq( void )
{
    int lp, disk;
    long size;
    struct filespec *node;
    for( lp=0; lp<glob.items; lp++ )
        specs[lp]->dest = 0;
    size = 0L;
    disk = 1;
    for( lp=0; lp<glob.items; lp++ )
    {
        if( size+specs[lp]->size > glob.total )
        {
            disk++;
            size = 0L;
        }
        size += specs[lp]->size;
        specs[lp]->dest = disk;
    }
    return( disk );
}
/* try "fitting" the files on the disks */
int sort_big( void )
{
    int lp, disk, best, left;
    long bytesfree;
    struct filespec *node;
    signal( SIGINT, flag_int );     /* so we can abort the fitting
gracefully */
    for( lp=0; lp<glob.items; lp++ )
    {
        specs[lp]->dest = 0;
        fits[lp] = -1;
    }
    bytesfree = glob.total;
    disk = 1;
    left = glob.items;
    if( glob.options&OPT_VERBOSE )
        fprintf( stderr, "Bin %2d: %7ld from target ", 1, bytesfree );
    do
    {
        fits[0] = -1;
        glob.recleft = bytesfree;
        glob.disk = disk;
        glob.maxlevel = left;
        best = recur( bytesfree, specs[0], 0 );
        bytesfree = glob.recleft;
        if( bytesfree<0 )           /* aborted */
        {
            lp = 0;
            while( fits[lp]>=0 && lp<glob.items )
                specs[fits[lp++]]->dest = disk;
            left -= lp;
            best = 0;
            bytesfree = -bytesfree;
        }
        if( best==0 )               /* disk full */
        {
            disk++;
            bytesfree = glob.total;
            if( glob.options&OPT_VERBOSE )
                fprintf( stderr, "\nBin %2d: %7ld from target ", disk,
bytesfree );
        }
        else
        {
            for( lp=0; lp<best; lp++ )
                specs[fits[lp]]->dest = disk;
            left -= best;
        }
    } while( left>0 );              /* more to go.. (same disk) */
    if( glob.options&OPT_VERBOSE )
        fputs( "\n", stderr );
    signal( SIGINT, SIG_DFL );      /* back to normal signal handler */
    return( disk );
}
/* recursively combine files to obtain maximum fill */
int recur( long space, struct filespec *this, int level )
{
    unsigned i, t, p;
    char done;
    long absleft;
    done = 0;
    if( glob.kbhit )
    {
        fprintf( stderr, " [Halted!]  C)ontinue, A)ccept fit or Q)uit? " );
        do
            i = fgetc( stderr );
        while( strchr( "cCaAqQ", i )==NULL );
        glob.kbhit = 0;
        if( glob.options&OPT_VERBOSE )
            fprintf( stderr, " \rBin %2d: %7ld from target
",
                        glob.disk, glob.recleft );
        if( i=='Q' || i=='q' )
        {
            freeall();
            fputs( "\nProgram quitted!\n", stderr );
            exit( 2 );
        }
        if( i=='A' || i=='a' )
        {
            glob.recleft = -glob.recleft;
            return( 0 );
        }
    }
    while( !done && this!=NULL )
    {
        if( this->dest==0 )
        {
            if( glob.options&OPT_OVERFLOW )
                absleft = labs( space - this->size );
            else
                absleft = space - this->size;
            if( absleft>=0L && space>0L )
            {
                if( absleft < glob.recleft )
                {
                    glob.recleft = absleft;
                    if( glob.options&OPT_VERBOSE )
                        fprintf( stderr, "\rBin %2d: %7ld from target ",
                                glob.disk, glob.recleft );
                    this->dest = glob.disk+1;
                    done = -1;
                    for( t = p = 0; t<glob.items; t++ )
                    {
                        if( specs[t]->dest==glob.disk+1 )
                            fits[p++] = t;
                        if( specs[t]->dest==0 )
                            done = 0;
                    }
                    while( p<=glob.items )
                        fits[p++] = -1;
                    this->dest = 0;
                    if( glob.recleft <= glob.threshold )
                        done = 1;
                }
                if( !done && level+1 < glob.maxlevel )
                {
                    this->dest = glob.disk+1;
                    done = recur( space - this->size, this->next, level+1 );
                    this->dest = 0;
                }
            }
        }
        this = this->next;
    }
    if( level!=0 )
    {
        return( done );
    }
    else
    {
        t = 0;
        while( fits[t]!=-1 )
            t++;
        return( t );
    }
}
void freeall( void )
{
    int i;
    for( i=0; i<glob.items; i++ )
    {
        if( specs[i]->name!=NULL )
            free( specs[i]->name );
        free( specs[i] );
    }
    free( specs );
    free( fits );
}
void flag_int( void )
{
    glob.kbhit = 1;
}
/*
 *  Split the string into arguments.
 *  The function returns the number of arguments found.
 *  The passed string will be destroyed.
 */
int split_line( char *s, char *args[] )
{
    int i, j;
    char *p, *h;
    char *stops[64];
    i = 0;
    args[0] = NULL;
    p = s;
    do
    {
        while( *p!=0 && strchr( " ,;\r\n\t", *p )!=NULL )   /* gobble spaces
*/
            p++;
        h = p;                          /* beginning of the argument */
        if( *h=='\'' || *h=='\"' )
        {
            p = strchr( h+1, *h );
            if( p!=NULL )
            {
                args[i] = h+1;
                stops[i] = p;
                i++;
                p++;
            }
        }
        else
        {
            p = strpbrk( h, " ,;\t\r\n\'\"" );
            args[i] = h;
            if( p!=NULL )
                stops[i] = p;
            else
                stops[i] = s+strlen( s );
            if( args[i]!=stops[i] )
                i++;
        }
    }while( p!=NULL && *p!=0 );
    for( j=0; j<i; j++ )
        *stops[j] = 0;
    args[i] = NULL;
    return( i );
}

 se potete aiutarmi vi sarei veramente grato
Quanto paghi per LOC e per ora?
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Dept. of Physics, Univ. of Padova, Italy              ROT13: 
ybe...@cq.vasa.vg


Scusa... ma come puoi sperare che qualcuno si legga tutto il listato
che hai pastato senza nemmeno sapere "quale" errore cercare??
Andrea
----
http://space.tin.it/io/andrea.fa

Hai ragione, ma pensavo che il compilatore C dell'as400 non vi potesse essere di molto  auiuto
ecco qua:
Grazie !!!!!
============================== 1 errore
15 !        if( i>=p && size<=glob.total && size>=0L )
   !        {
16 !            new = (struct filespec *) calloc( 1, sizeof(struct filespec) );
17 !            new->name = strdup( str );
==> ......................b.a.....................................................................
=========> a - CZM0304  No function prototype given for 'strdup'.
5R1M0  010525   IBM ILE C for AS/400    APPO/C(KNAPSAK)                    S44315CA        18.03.0
=========> b - CZM0068  Operation between types "unsigned char*" and "int" is not allowed.
18 !            new->size = ROUND_UP( size, glob.quant );
19 !            new->next = prev->next;
20 !            prev->next = new;
21 !            prev = new;
22 !            qty++;
=============================== 2 errore
!        if( i>=p && size<=glob.total && size>=0L )
!        {
!            new = (struct filespec *) calloc( 1, sizeof(struct filespec) );
!            new->name = strdup( str );
 ......................b.a.........................................................................
======> a - CZM0304  No function prototype given for 'strdup'.
M0  010525   IBM ILE C for AS/400    APPO/C(KNAPSAK)                    S44315CA        18.03.04 18
======> b - CZM0068  Operation between types "unsigned char*" and "int" is not allowed.
!            new->size = ROUND_UP( size, glob.quant );
!            new->next = prev->next;
!            prev->next = new;
!            prev = new;
!            qty++;
!        }
=============================== 3 errore ( credo quello fatale !!
!    signal( SIGINT, flag_int );     /* so we can abort the fitting gracefully */                  !    346
+    signal( 4, flag_int );     /* so we can abort the fitting gracefully */                       +    346
 ...............a..................................................................................
======> a - CZM0280  Function argument assignment between types "void(*)(int)" and "void(*)(void)" is not allowed.
!                                                                                                  !    347
!    for( lp=0; lp<glob.items; lp++ )                                                              !    348
!    {                                                                                             !    349
)))))))))))))))))))))))))))))))))))))))))))))))))))))
================================
MSG ID      SEV     TEXT
                    <SEQNBR>-<FILE NO>:<FILE LINE NO>
CZM0304     10      No function prototype given for ''.
                     ( 227-0:227 )
CZM0068     10      Operation between types "" and "" is not allowed.
                     ( 227-0:227 )
CZM0280     30      Function argument assignment between types "" and "" is not allowed.
                     ( 346-0:346 )
                                      * * * * *   E N D   O F   M E S S A G E S   * * * * *
5722WDS V5R1M0  010525   IBM ILE C for AS/400    APPO/C(KNAPSAK)                    S44315CA        18.03.04 18:16:09
                                       * * * * *   M E S S A G E   S U M M A R Y   * * * * *
      Total      Informational(00)      Warning(10)      Error(20)      Severe Error(30)      Unrecoverable Error(40)
        3              0                    2               0                  1                        0
                               * * * * *   E N D   O F   M E S S A G E   S U M M A R Y   * * * * *
Program KNAPSAK is not created because statement errors occurred.
                                   * * * * *   E N D   O F   C O M P I L A T I O N   * * * * *
===========================================================================


dalle mie parti si parla di 5/6 euro/ora, una miseria ma se interessa (:-))))
( Forza, dammi una mano che sono nella merda !!! )
(:-)))


 ( Forza, dammi una mano che sono nella merda !!! )
Be' allora guadagna di piu' la mia babysitter...
Comunque alcuni degli errori, non l'ultimo (ma la
gestione dei segnali non la conosco)
dipendono chiaramente dal fatto che per qualche motivo
il tuo compilatore non conosce la funzione strdup(),
che di solito si trova in string.h, (che pure includi)
ma quello che  vale nel nostro universo non sempre vale sull'AS/400...
In ogni caso considera che la strdup duplica una stringa
allocando opportunamente la memoria, quindi
se hai l'istruzione
new->name = strdup( str );
puoi trasformala in
new->name = (char *) malloc(strlen(str)+1);
strcpy(new->name, str);
e similmente per le altre occorrenze di strdup.
L'errore che segue quello delle strdup dovrebbe scomparire da solo.
Credo che adesso sia causato dal fatto che il compilatore
non conoscendo strdup() assume di default che il tipo ritornato
sia un integer e allora si incavola perche' non
puoi assegnare ad una variabile char * (ovvero new->name) un
integer.
ciao,
g.

Ciao,
il tuo messaggio e' un notevole esempio di come *non* ci si comporta
sui newsgroup. Intanto hai postato un problema di C, mentre questo
gruppo si occupa di C++ . In secondo luogo hai postato un listato di
oltre 500 righe, senza spiegare cosa fa e cosa c'e' che non va, e
pretendi che qualcuno te lo aggiusti.
Se non mostri di fare il minimo sforzo per capire cosa c'e' che non
va, come puoi aspettarti che altri abbiano voglia di fare la fatica di
aiutarti?
Ciao,
Nicola

 Nicola

Ok ci sono riuscito,
visto che oramai ho deciso di essere veramente
OT, ne approfitto perche' non riesco a capire la sintassi dei parametri che devo passare.
hai lumi ?
Grazie davvero !!
=============================================================================
KNAP tries to optimally fit the items with
associated sizes into bins of the given targetsize.
Usage:   KNAP [options] targetsize [< file]
Options: -n       no opt; files assigned in given order
         -o       allow overflow (greater than targetsize)
         -v       verbose; output more info to stderr
         -p val   set position of itemsize in inputdata, default is 2
         -t val   set threshold to val, default is 0
         -q val   set quantizing to val, default is 1
Premere INVIO per chiudere la sessione del terminale.
KNAP ver 2.0, Mar 19 2004 by Kai Risku
=============================================================================

 e consente a tutti di migliorarsi
Gruppo che vai, consuetudini che trovi. Rispondete anche a domande su
OpenVMS?
Qui si parla del linguaggio C++ come definito dallo standard ISO e
siamo piuttosto rigorosi al proposito.
 
Ciao,
Nicola

 siamo piuttosto rigorosi al proposito.
la' si parla di CL sql rpg rpg-ile c cobol java VB VC html cgi ecc....
comunque Scusa ancora !

quel linguaggio in teoria dovrebbe anche capire i problemi
Se conosco l'italiano, non necessariamente sono in grado di capire
_ogni_ libro in italiano.
-- 
Debugging is twice as hard as writing the code in the first place.
Therefore, if you write the code as cleverly as possible, you are,
by definition, not smart enough to debug it.
    - Brian W. Kernighan

 si cerca di dare sempre il massimo dell'aiuto
OpenVMS e' un sistema operativo della Digital, ora Compaq (se fossero
stati piu' furbi ora probabilmente lavoreresti su un VAX e non su un
AS400). Qui sta la differenza tra il tuo newsgroup e il nostro:
nessuno che opera su una piattaforma diversa si sognerebbe di venire
da voi a porre domande sul suo sistema. Qui da noi invece chiunque
abbia una volta visto scritto C++ (o anche C) da qualche parte ritiene
di essere in argomento, e molto spesso non e' vero. Di qui la
rigidita'. Non e' cattiveria, e' solo la speranza di riuscire a
parlare, prevalntemente, del tema che ci interessa.
Ciao,
Nicola