VirtualBox

Changeset 51 in kBuild for trunk/src/kmk/for.c


Ignore:
Timestamp:
Apr 7, 2003 1:30:32 AM (22 years ago)
Author:
bird
Message:

kMk and porting to kLib.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kmk/for.c

    r35 r51  
    1313 * 3. All advertising materials mentioning features or use of this software
    1414 *    must display the following acknowledgement:
    15  *      This product includes software developed by the University of
    16  *      California, Berkeley and its contributors.
     15 *      This product includes software developed by the University of
     16 *      California, Berkeley and its contributors.
    1717 * 4. Neither the name of the University nor the names of its contributors
    1818 *    may be used to endorse or promote products derived from this software
    … …  
    3434#ifndef lint
    3535#if 0
    36 static char sccsid[] = "@(#)for.c       8.1 (Berkeley) 6/6/93";
     36static char sccsid[] = "@(#)for.c       8.1 (Berkeley) 6/6/93";
    3737#else
    3838static const char rcsid[] =
    3939  "$FreeBSD: src/usr.bin/make/for.c,v 1.10 1999/09/11 13:08:01 hoek Exp $";
    4040#endif
     41#define KLIBFILEDEF rcsid
    4142#endif /* not lint */
    4243
    4344/*-
    4445 * for.c --
    45  *      Functions to handle loops in a makefile.
     46 *      Functions to handle loops in a makefile.
    4647 *
    4748 * Interface:
    48  *      For_Eval        Evaluate the loop in the passed line.
    49  *      For_Run         Run accumulated loop
     49 *      For_Eval        Evaluate the loop in the passed line.
     50 *      For_Run         Run accumulated loop
    5051 *
    5152 */
    … …  
    7172 */
    7273
    73 static int        forLevel = 0;         /* Nesting level        */
    74 static char      *forVar;               /* Iteration variable   */
    75 static Buffer     forBuf;               /* Commands in loop     */
    76 static Lst        forLst;               /* List of items        */
     74static int        forLevel = 0;         /* Nesting level        */
     75static char      *forVar;               /* Iteration variable   */
     76static Buffer     forBuf;               /* Commands in loop     */
     77static Lst        forLst;               /* List of items        */
    7778
    7879/*
    … …  
    8081 */
    8182typedef struct _For {
    82     Buffer        buf;                  /* Unexpanded buffer    */
    83     char*         var;                  /* Index name           */
    84     Lst           lst;                  /* List of variables    */
     83    Buffer        buf;                  /* Unexpanded buffer    */
     84    char*         var;                  /* Index name           */
     85    Lst           lst;                  /* List of variables    */
    8586} For;
    8687
    87 static int ForExec      __P((ClientData, ClientData));
     88static int ForExec      __P((ClientData, ClientData));
    8889
    8990
    … …  
    9495 *-----------------------------------------------------------------------
    9596 * For_Eval --
    96  *      Evaluate the for loop in the passed line. The line
    97  *      looks like this:
    98  *          .for <variable> in <varlist>
     97 *      Evaluate the for loop in the passed line. The line
     98 *      looks like this:
     99 *          .for <variable> in <varlist>
    99100 *
    100101 * Results:
    101  *      TRUE: We found a for loop, or we are inside a for loop
    102  *      FALSE: We did not find a for loop, or we found the end of the for
    103  *             for loop.
     102 *      TRUE: We found a for loop, or we are inside a for loop
     103 *      FALSE: We did not find a for loop, or we found the end of the for
     104 *             for loop.
    104105 *
    105106 * Side Effects:
    106  *      None.
     107 *      None.
    107108 *
    108109 *-----------------------------------------------------------------------
    … …  
    110111int
    111112For_Eval (line)
    112     char            *line;    /* Line to parse */
     113    char            *line;    /* Line to parse */
    113114{
    114     char            *ptr = line, *sub, *wrd;
    115     int             level;      /* Level at which to report errors. */
     115    char            *ptr = line, *sub, *wrd;
     116    int             level;      /* Level at which to report errors. */
    116117
    117118    level = PARSE_FATAL;
    … …  
    119120
    120121    if (forLevel == 0) {
    121         Buffer      buf;
    122         int         varlen;
    123 
    124         for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
    125             continue;
    126         /*
    127         * If we are not in a for loop quickly determine if the statement is
    128         * a for.
    129         */
    130         if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
    131             !isspace((unsigned char) ptr[3]))
    132             return FALSE;
    133         ptr += 3;
    134 
    135         /*
    136         * we found a for loop, and now we are going to parse it.
    137         */
    138         while (*ptr && isspace((unsigned char) *ptr))
    139             ptr++;
    140 
    141         /*
    142         * Grab the variable
    143         */
    144         buf = Buf_Init(0);
    145         for (wrd = ptr; *ptr && !isspace((unsigned char) *ptr); ptr++)
    146             continue;
    147         Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd);
    148 
    149         forVar = (char *) Buf_GetAll(buf, &varlen);
    150         if (varlen == 0) {
    151             Parse_Error (level, "missing variable in for");
    152             return 0;
    153         }
    154         Buf_Destroy(buf, FALSE);
    155 
    156         while (*ptr && isspace((unsigned char) *ptr))
    157             ptr++;
    158 
    159         /*
    160         * Grab the `in'
    161         */
    162         if (ptr[0] != 'i' || ptr[1] != 'n' ||
    163             !isspace((unsigned char) ptr[2])) {
    164             Parse_Error (level, "missing `in' in for");
    165             printf("%s\n", ptr);
    166             return 0;
    167         }
    168         ptr += 3;
    169 
    170         while (*ptr && isspace((unsigned char) *ptr))
    171             ptr++;
    172 
    173         /*
    174         * Make a list with the remaining words
    175         */
    176         forLst = Lst_Init(FALSE);
    177         buf = Buf_Init(0);
    178         sub = Var_Subst(NULL, ptr, VAR_GLOBAL, FALSE);
     122        Buffer      buf;
     123        int         varlen;
     124
     125        for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
     126            continue;
     127        /*
     128        * If we are not in a for loop quickly determine if the statement is
     129        * a for.
     130        */
     131        if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
     132            !isspace((unsigned char) ptr[3]))
     133            return FALSE;
     134        ptr += 3;
     135
     136        /*
     137        * we found a for loop, and now we are going to parse it.
     138        */
     139        while (*ptr && isspace((unsigned char) *ptr))
     140            ptr++;
     141
     142        /*
     143        * Grab the variable
     144        */
     145        buf = Buf_Init(0);
     146        for (wrd = ptr; *ptr && !isspace((unsigned char) *ptr); ptr++)
     147            continue;
     148        Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd);
     149
     150        forVar = (char *) Buf_GetAll(buf, &varlen);
     151        if (varlen == 0) {
     152            Parse_Error (level, "missing variable in for");
     153            return 0;
     154        }
     155        Buf_Destroy(buf, FALSE);
     156
     157        while (*ptr && isspace((unsigned char) *ptr))
     158            ptr++;
     159
     160        /*
     161        * Grab the `in'
     162        */
     163        if (ptr[0] != 'i' || ptr[1] != 'n' ||
     164            !isspace((unsigned char) ptr[2])) {
     165            Parse_Error (level, "missing `in' in for");
     166            printf("%s\n", ptr);
     167            return 0;
     168        }
     169        ptr += 3;
     170
     171        while (*ptr && isspace((unsigned char) *ptr))
     172            ptr++;
     173
     174        /*
     175        * Make a list with the remaining words
     176        */
     177        forLst = Lst_Init(FALSE);
     178        buf = Buf_Init(0);
     179        sub = Var_Subst(NULL, ptr, VAR_GLOBAL, FALSE);
    179180
    180181#define ADDWORD() \
    181         Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd), \
    182         Buf_AddByte(buf, (Byte) '\0'), \
    183         Lst_AtFront(forLst, (ClientData) Buf_GetAll(buf, &varlen)), \
    184         Buf_Destroy(buf, FALSE)
    185 
    186         for (ptr = sub; *ptr && isspace((unsigned char) *ptr); ptr++)
    187             continue;
    188 
    189         for (wrd = ptr; *ptr; ptr++)
    190             if (isspace((unsigned char) *ptr)) {
    191                 ADDWORD();
    192                 buf = Buf_Init(0);
    193                 while (*ptr && isspace((unsigned char) *ptr))
    194                     ptr++;
    195                 wrd = ptr--;
    196             }
    197         if (DEBUG(FOR))
    198             (void) fprintf(stderr, "For: Iterator %s List %s\n", forVar, sub);
    199         if (ptr - wrd > 0)
    200             ADDWORD();
    201         else
    202             Buf_Destroy(buf, TRUE);
    203         efree((Address) sub);
    204 
    205         forBuf = Buf_Init(0);
    206         forLevel++;
    207         return 1;
     182        Buf_AddBytes(buf, ptr - wrd, (Byte *) wrd), \
     183        Buf_AddByte(buf, (Byte) '\0'), \
     184        Lst_AtFront(forLst, (ClientData) Buf_GetAll(buf, &varlen)), \
     185        Buf_Destroy(buf, FALSE)
     186
     187        for (ptr = sub; *ptr && isspace((unsigned char) *ptr); ptr++)
     188            continue;
     189
     190        for (wrd = ptr; *ptr; ptr++)
     191            if (isspace((unsigned char) *ptr)) {
     192                ADDWORD();
     193                buf = Buf_Init(0);
     194                while (*ptr && isspace((unsigned char) *ptr))
     195                    ptr++;
     196                wrd = ptr--;
     197            }
     198        if (DEBUG(FOR))
     199            (void) fprintf(stderr, "For: Iterator %s List %s\n", forVar, sub);
     200        if (ptr - wrd > 0)
     201            ADDWORD();
     202        else
     203            Buf_Destroy(buf, TRUE);
     204        efree((Address) sub);
     205
     206        forBuf = Buf_Init(0);
     207        forLevel++;
     208        return 1;
    208209    }
    209210    else if (*ptr == '.') {
    210211
    211         for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
    212             continue;
    213 
    214         if (strncmp(ptr, "endfor", 6) == 0 &&
    215             (isspace((unsigned char) ptr[6]) || !ptr[6])) {
    216             if (DEBUG(FOR))
    217                 (void) fprintf(stderr, "For: end for %d\n", forLevel);
    218             if (--forLevel < 0) {
    219                 Parse_Error (level, "for-less endfor");
    220                 return 0;
    221             }
    222         }
    223         else if (strncmp(ptr, "for", 3) == 0 &&
    224                 isspace((unsigned char) ptr[3])) {
    225             forLevel++;
    226             if (DEBUG(FOR))
    227                 (void) fprintf(stderr, "For: new loop %d\n", forLevel);
    228         }
     212        for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
     213            continue;
     214
     215        if (strncmp(ptr, "endfor", 6) == 0 &&
     216            (isspace((unsigned char) ptr[6]) || !ptr[6])) {
     217            if (DEBUG(FOR))
     218                (void) fprintf(stderr, "For: end for %d\n", forLevel);
     219            if (--forLevel < 0) {
     220                Parse_Error (level, "for-less endfor");
     221                return 0;
     222            }
     223        }
     224        else if (strncmp(ptr, "for", 3) == 0 &&
     225                isspace((unsigned char) ptr[3])) {
     226            forLevel++;
     227            if (DEBUG(FOR))
     228                (void) fprintf(stderr, "For: new loop %d\n", forLevel);
     229        }
    229230    }
    230231
    231232    if (forLevel != 0) {
    232         Buf_AddBytes(forBuf, strlen(line), (Byte *) line);
    233         Buf_AddByte(forBuf, (Byte) '\n');
    234         return 1;
     233        Buf_AddBytes(forBuf, strlen(line), (Byte *) line);
     234        Buf_AddByte(forBuf, (Byte) '\n');
     235        return 1;
    235236    }
    236237    else {
    237         return 0;
     238        return 0;
    238239    }
    239240}
    … …  
    242243 *-----------------------------------------------------------------------
    243244 * ForExec --
    244  *      Expand the for loop for this index and push it in the Makefile
     245 *      Expand the for loop for this index and push it in the Makefile
    245246 *
    246247 * Results:
    247  *      None.
     248 *      None.
    248249 *
    249250 * Side Effects:
    250  *      None.
     251 *      None.
    251252 *
    252253 *-----------------------------------------------------------------------
    … …  
    262263    Var_Set(arg->var, name, VAR_GLOBAL);
    263264    if (DEBUG(FOR))
    264         (void) fprintf(stderr, "--- %s = %s\n", arg->var, name);
     265        (void) fprintf(stderr, "--- %s = %s\n", arg->var, name);
    265266    Parse_FromString(Var_Subst(arg->var, (char *) Buf_GetAll(arg->buf, &len),
    266                                VAR_GLOBAL, FALSE));
     267                               VAR_GLOBAL, FALSE));
    267268    Var_Delete(arg->var, VAR_GLOBAL);
    268269
    … …  
    275276 *-----------------------------------------------------------------------
    276277 * For_Run --
    277  *      Run the for loop, immitating the actions of an include file
     278 *      Run the for loop, immitating the actions of an include file
    278279 *
    279280 * Results:
    280  *      None.
     281 *      None.
    281282 *
    282283 * Side Effects:
    283  *      None.
     284 *      None.
    284285 *
    285286 *-----------------------------------------------------------------------
    … …  
    291292
    292293    if (forVar == NULL || forBuf == NULL || forLst == NULL)
    293         return;
     294        return;
    294295    arg.var = forVar;
    295296    arg.buf = forBuf;
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette