Changeset 79008


Ignore:
Timestamp:
Jun 19, 2012, 12:43:40 PM (6 years ago)
Author:
Jurko Gospodnetic
Message:

Corrected some minor memory leaks and avoided extra list copying in Boost Jam when processing piecemeal actions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/tools/build/v2/engine/make1.c

    r79007 r79008  
    971971        LIST         * ns;
    972972        ACTIONS      * a1;
    973         int            start;
    974         int            chunk;
    975         int            length;
    976973
    977974        /* Only do rules with commands to execute. If this action has already
     
    10321029         * Note we loop through at least once, for sourceless actions.
    10331030         */
    1034 
    1035         start = 0;
    1036         chunk = length = list_length( ns );
    1037 
    1038         do
    1039         {
    1040             /* Build cmd: cmd_new consumes its lists. */
    1041             CMD * cmd = cmd_new( rule,
    1042                 list_copy( nt ),
    1043                 list_sublist( ns, start, chunk ),
    1044                 list_copy( shell ) );
    1045 
    1046             if ( cmd )
     1031        {
     1032            int const length = list_length( ns );
     1033            int start = 0;
     1034            int chunk = length;
     1035            LIST * cmd_targets = L0;
     1036            LIST * cmd_shell = L0;
     1037            do
    10471038            {
    1048                 /* It fit: chain it up. */
    1049                 if ( !cmds ) cmds = cmd;
    1050                 else cmds->tail->next = cmd;
    1051                 cmds->tail = cmd;
    1052                 start += chunk;
     1039                CMD * cmd;
     1040                LIST * cmd_sources = list_sublist( ns, start, chunk );
     1041
     1042                /* Build cmd: cmd_new() consumes its lists if successful. */
     1043                if ( list_empty( cmd_targets ) ) cmd_targets = list_copy( nt );
     1044                if ( list_empty( cmd_shell ) ) cmd_shell = list_copy( shell );
     1045                cmd = cmd_new( rule, cmd_targets, cmd_sources, cmd_shell );
     1046
     1047                if ( cmd )
     1048                {
     1049                    /* It fit: chain it up. */
     1050                    if ( !cmds ) cmds = cmd;
     1051                    else cmds->tail->next = cmd;
     1052                    cmds->tail = cmd;
     1053                    start += chunk;
     1054
     1055                    /* Mark consumed lists. */
     1056                    cmd_targets = L0;
     1057                    cmd_shell = L0;
     1058                }
     1059                else
     1060                {
     1061                    if ( ( actions->flags & RULE_PIECEMEAL ) && ( chunk > 1 ) )
     1062                    {
     1063                        /* Reduce chunk size slowly. */
     1064                        chunk = chunk * 9 / 10;
     1065                    }
     1066                    else
     1067                    {
     1068                        /* Too long and not splittable. */
     1069                        printf( "%s action is too long (max %d):\n", object_str(
     1070                            rule->name ), MAXLINE );
     1071
     1072                        /* Tell the user what did not fit. */
     1073                        cmd = cmd_new( rule, cmd_targets, cmd_sources,
     1074                            list_new( object_copy( constant_percent ) ) );
     1075                        fputs( cmd->buf->value, stdout );
     1076                        exit( EXITBAD );
     1077                    }
     1078
     1079                    list_free( cmd_sources );
     1080                }
    10531081            }
    1054             else if ( ( actions->flags & RULE_PIECEMEAL ) && ( chunk > 1 ) )
    1055             {
    1056                 /* Reduce chunk size slowly. */
    1057                 chunk = chunk * 9 / 10;
    1058             }
    1059             else
    1060             {
    1061                 /* Too long and not splittable. */
    1062                 printf( "%s action is too long (max %d):\n", object_str(
    1063                     rule->name ), MAXLINE );
    1064 
    1065                 /* Tell the user what did not fit. */
    1066                 cmd = cmd_new( rule, list_copy( nt ),
    1067                     list_sublist( ns, start, chunk ),
    1068                     list_new( object_copy( constant_percent ) ) );
    1069                 fputs( cmd->buf->value, stdout );
    1070                 exit( EXITBAD );
    1071             }
    1072         }
    1073         while ( start < length );
     1082            while ( start < length );
     1083        }
    10741084
    10751085        /* These were always copied when used. */
Note: See TracChangeset for help on using the changeset viewer.