VirtualBox

Changeset 2415 in kBuild


Ignore:
Timestamp:
Sep 13, 2010 11:13:20 PM (15 years ago)
Author:
bird
Message:

kash: trimmed down the arith stuff, making it not drag in libc bits.

Location:
trunk/src/kash
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kash/arith.y

    r2382 r2415  
    5757int main(int , char *[]);
    5858int error(char *);
     59#else
     60# undef  malloc
     61# define malloc(cb)        sh_malloc(NULL, (cb))
     62# undef  realloc
     63# define realloc(pv,cb)    sh_realloc(NULL, (pv), (cb))
     64# undef  free
     65# define free(pv)          sh_free(NULL, (pv))
    5966#endif
    6067

  • trunk/src/kash/arith_lex.l

    r1233 r2415  
     1%option never-interactive
    12%option noyywrap
     3%option noinput
     4%option nounput
     5%option noyyget_out
     6%option noyy_push_state
     7%option noyy_pop_state
     8%option noyy_top_state
     9%option noyy_scan_buffer
     10%option noyy_scan_bytes
     11%option noyy_scan_string
     12%option noyyget_extra
     13%option noyyset_extra
     14%option noyyget_leng
     15%option noyyget_text
     16%option noyyget_lineno
     17%option noyyset_lineno
     18%option noyyget_in
     19%option noyyset_in
     20%option noyyget_out
     21%option noyyset_out
     22%option noyyget_lval
     23%option noyyset_lval
     24%option noyyget_lloc
     25%option noyyset_lloc
     26%option noyyget_debug
     27%option noyyset_debug
     28%option noyyalloc
     29%option noyyrealloc
     30%option noyyfree
     31/** @todo %option reentrant */
    232%{
    333/*      $NetBSD: arith_lex.l,v 1.13 2005/03/21 22:37:09 dsl Exp $       */
    … …  
    4373#endif
    4474
     75#include <stdio.h>
    4576#include "arith.h"
    4677#include "error.h"
    … …  
    5687        result = (*buf = *arith_buf++) ? 1 : YY_NULL;
    5788#define YY_NO_UNPUT
     89
     90/* Avoid unnecessary libc bits. */
     91#undef  ECHO
     92#define ECHO \
     93        do {} while (0)
     94#undef  stdin
     95#define stdin  \
     96        NULL
     97#undef  stdout
     98#define stdout \
     99        NULL
     100#undef  fprintf
     101#define fprintf(a, b, c) \
     102        ((void)0)
     103#undef  exit
     104#define exit(rc) \
     105        do {} while (0)
     106#define YY_FATAL_ERROR(msg) \
     107        error(arith_psh, "arith: fatal error: %s", msg)
    58108%}
    59109
    … …  
    102152#endif
    103153}
     154
     155void *
     156yyalloc(yy_size_t cb)
     157{
     158        return sh_malloc(NULL, cb);
     159}
     160
     161void *
     162yyrealloc(void *pv, yy_size_t cb)
     163{
     164        return sh_realloc(NULL, pv, cb);
     165}
     166
     167void
     168yyfree(void *pv)
     169{
     170        sh_free(NULL, pv);
     171}
     172

  • trunk/src/kash/exec.h

    r2298 r2415  
    4646
    4747
     48union param {
     49        int index;
     50        int (*bltin)(struct shinstance*, int, char**);
     51        union node *func;
     52};
     53
    4854struct cmdentry {
    4955        int cmdtype;
    50         union param {
    51                 int index;
    52                 int (*bltin)(struct shinstance*, int, char**);
    53                 union node *func;
    54         } u;
     56        union param u;
    5557};
    5658

  • trunk/src/kash/generated/arith.c

    r1233 r2415  
    11#ifndef lint
    2 /*static char yysccsid[] = "from: @(#)yaccpar   1.9 (Berkeley) 02/21/93";*/
    3 static char yyrcsid[] = "$Id$";
    4 #endif
     2static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
     3#endif
     4
     5#include <stdlib.h>
     6#include <string.h>
     7
    58#define YYBYACC 1
    69#define YYMAJOR 1
    710#define YYMINOR 9
    8 #define yyclearin (yychar=(-1))
    9 #define yyerrok (yyerrflag=0)
    10 #define YYRECOVERING (yyerrflag!=0)
     11#define YYPATCH 20091027
     12
     13#define YYEMPTY        (-1)
     14#define yyclearin      (yychar = YYEMPTY)
     15#define yyerrok        (yyerrflag = 0)
     16#define YYRECOVERING() (yyerrflag != 0)
     17
     18/* compatibility with bison */
     19#ifdef YYPARSE_PARAM
     20/* compatibility with FreeBSD */
     21#ifdef YYPARSE_PARAM_TYPE
     22#define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
     23#else
     24#define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
     25#endif
     26#else
     27#define YYPARSE_DECL() yyparse(void)
     28#endif /* YYPARSE_PARAM */
     29
     30extern int YYPARSE_DECL();
     31
     32static int yygrowstack(void);
    1133#define YYPREFIX "yy"
    1234/*      $NetBSD: arith.y,v 1.17 2003/09/17 17:33:36 jmmv Exp $  */
    … …  
    6789int main(int , char *[]);
    6890int error(char *);
     91#else
     92# undef  malloc
     93# define malloc(cb)        sh_malloc(NULL, (cb))
     94# undef  realloc
     95# define realloc(pv,cb)    sh_realloc(NULL, (pv), (cb))
     96# undef  free
     97# define free(pv)          sh_free(NULL, (pv))
    6998#endif
    7099
    … …  
    95124#define ARITH_BNOT 281
    96125#define YYERRCODE 256
    97 short yylhs[] = {                                        -1,
     126static const short yylhs[] = {                           -1,
    98127    0,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    99128    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    100129    1,    1,    1,    1,    1,
    101130};
    102 short yylen[] = {                                         2,
     131static const short yylen[] = {                            2,
    103132    1,    3,    3,    3,    3,    3,    3,    3,    3,    3,
    104133    3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
    105134    2,    2,    2,    2,    1,
    106135};
    107 short yydefred[] = {                                      0,
     136static const short yydefred[] = {                         0,
    108137   25,    0,    0,    0,    0,    0,    0,    0,    0,   24,
    109138   23,   21,   22,    0,    0,    0,    0,    0,    0,    0,
    … …  
    112141    0,    0,    0,    0,    0,    0,    0,   18,   19,   20,
    113142};
    114 short yydgoto[] = {                                       7,
     143static const short yydgoto[] = {                          7,
    115144    8,
    116145};
    117 short yysindex[] = {                                   -255,
     146static const short yysindex[] = {                      -255,
    118147    0, -255, -255, -255, -255, -255,    0,  -67,  -85,    0,
    119148    0,    0,    0, -255, -255, -255, -255, -255, -255, -255,
    … …  
    122151 -223, -223, -223, -253, -253, -248, -248,    0,    0,    0,
    123152};
    124 short yyrindex[] = {                                      0,
     153static const short yyrindex[] = {                         0,
    125154    0,    0,    0,    0,    0,    0,    0,   30,    0,    0,
    126155    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    … …  
    129158   73,   85,   97,   33,   47,    1,   17,    0,    0,    0,
    130159};
    131 short yygindex[] = {                                      0,
     160static const short yygindex[] = {                         0,
    132161  142,
    133162};
    134163#define YYTABLESIZE 418
    135 short yytable[] = {                                       0,
     164static const short yytable[] = {                          0,
    136165   16,    1,    2,   19,   20,   21,   22,   23,   24,   25,
    137166   26,   27,   28,   29,   30,   31,   17,    3,    4,   27,
    … …  
    177206   24,   25,   26,   27,   28,   29,   30,   31,
    178207};
    179 short yycheck[] = {                                      -1,
     208static const short yycheck[] = {                         -1,
    180209    0,  257,  258,  265,  266,  267,  268,  269,  270,  271,
    181210  272,  273,  274,  275,  276,  277,    0,  273,  274,  273,
    … …  
    227256#define YYMAXTOKEN 281
    228257#if YYDEBUG
    229 char *yyname[] = {
     258static const char *yyname[] = {
     259
    230260"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    2312610,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    … …  
    240270"ARITH_REM","ARITH_UNARYMINUS","ARITH_UNARYPLUS","ARITH_NOT","ARITH_BNOT",
    241271};
    242 char *yyrule[] = {
     272static const char *yyrule[] = {
    243273"$accept : exp",
    244274"exp : expr",
    … …  
    267297"expr : ARITH_ADD expr",
    268298"expr : ARITH_NUM",
     299
    269300};
    270301#endif
    … …  
    272303typedef int YYSTYPE;
    273304#endif
     305#if YYDEBUG
     306#include <stdio.h>
     307#endif
     308
     309/* define the initial stack-sizes */
    274310#ifdef YYSTACKSIZE
    275311#undef YYMAXDEPTH
    276 #define YYMAXDEPTH YYSTACKSIZE
     312#define YYMAXDEPTH  YYSTACKSIZE
    277313#else
    278314#ifdef YYMAXDEPTH
    … …  
    280316#else
    281317#define YYSTACKSIZE 500
    282 #define YYMAXDEPTH 500
    283 #endif
    284 #endif
    285 int yydebug;
    286 int yynerrs;
    287 int yyerrflag;
    288 int yychar;
    289 short *yyssp;
     318#define YYMAXDEPTH  500
     319#endif
     320#endif
     321
     322#define YYINITSTACKSIZE 500
     323
     324int      yydebug;
     325int      yynerrs;
     326int      yyerrflag;
     327int      yychar;
     328short   *yyssp;
    290329YYSTYPE *yyvsp;
    291 YYSTYPE yyval;
    292 YYSTYPE yylval;
    293 short yyss[YYSTACKSIZE];
    294 YYSTYPE yyvs[YYSTACKSIZE];
    295 #define yystacksize YYSTACKSIZE
     330YYSTYPE  yyval;
     331YYSTYPE  yylval;
     332
     333/* variables for the parser stack */
     334static short   *yyss;
     335static short   *yysslim;
     336static YYSTYPE *yyvs;
     337static unsigned yystacksize;
    296338int
    297339arith(shinstance *psh, const char *s)
    … …  
    370412yyerror(const char *s)
    371413{
    372    shinstance *psh = arith_psh;
     414    shinstance *psh = arith_psh;
     415#ifndef YYBISON /* yyerrok references yyerrstatus which is a local variable in yyparse().*/
    373416        yyerrok;
     417#endif
    374418        yyclearin;
    375419        arith_lex_reset();      /* reprime lex */
    … …  
    378422        /* NOTREACHED */
    379423}
    380 #define YYABORT goto yyabort
     424/* allocate initial stack or double stack size, up to YYMAXDEPTH */
     425static int yygrowstack(void)
     426{
     427    int i;
     428    unsigned newsize;
     429    short *newss;
     430    YYSTYPE *newvs;
     431
     432    if ((newsize = yystacksize) == 0)
     433        newsize = YYINITSTACKSIZE;
     434    else if (newsize >= YYMAXDEPTH)
     435        return -1;
     436    else if ((newsize *= 2) > YYMAXDEPTH)
     437        newsize = YYMAXDEPTH;
     438
     439    i = yyssp - yyss;
     440    newss = (yyss != 0)
     441          ? (short *)realloc(yyss, newsize * sizeof(*newss))
     442          : (short *)malloc(newsize * sizeof(*newss));
     443    if (newss == 0)
     444        return -1;
     445
     446    yyss  = newss;
     447    yyssp = newss + i;
     448    newvs = (yyvs != 0)
     449          ? (YYSTYPE *)realloc(yyvs, newsize * sizeof(*newvs))
     450          : (YYSTYPE *)malloc(newsize * sizeof(*newvs));
     451    if (newvs == 0)
     452        return -1;
     453
     454    yyvs = newvs;
     455    yyvsp = newvs + i;
     456    yystacksize = newsize;
     457    yysslim = yyss + newsize - 1;
     458    return 0;
     459}
     460
     461#define YYABORT  goto yyabort
    381462#define YYREJECT goto yyabort
    382463#define YYACCEPT goto yyaccept
    383 #define YYERROR goto yyerrlab
    384 #ifdef __cplusplus
    385 extern "C" {
    386 char * getenv();
    387 int yylex();
    388 int yyparse();
    389 }
    390 
    391 #endif
     464#define YYERROR  goto yyerrlab
     465
    392466int
    393 #if defined(__STDC__)
    394 yyparse(void)
    395 #else
    396 yyparse()
    397 #endif
     467YYPARSE_DECL()
    398468{
    399     register int yym, yyn, yystate;
    400 #if YYDEBUG
    401     register char *yys;
    402 #ifndef __cplusplus
    403     extern char *getenv();
    404 #endif
    405 
    406     if (yys = getenv("YYDEBUG"))
     469    int yym, yyn, yystate;
     470#if YYDEBUG
     471    const char *yys;
     472
     473    if ((yys = getenv("YYDEBUG")) != 0)
    407474    {
    408475        yyn = *yys;
    … …  
    414481    yynerrs = 0;
    415482    yyerrflag = 0;
    416     yychar = (-1);
    417 
     483    yychar = YYEMPTY;
     484    yystate = 0;
     485
     486    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    418487    yyssp = yyss;
    419488    yyvsp = yyvs;
    420     *yyssp = yystate = 0;
     489    yystate = 0;
     490    *yyssp = 0;
    421491
    422492yyloop:
    … …  
    444514                    YYPREFIX, yystate, yytable[yyn]);
    445515#endif
    446         if (yyssp >= yyss + yystacksize - 1)
     516        if (yyssp >= yysslim && yygrowstack())
    447517        {
    448518            goto yyoverflow;
    449519        }
    450         *++yyssp = yystate = yytable[yyn];
     520        yystate = yytable[yyn];
     521        *++yyssp = yytable[yyn];
    451522        *++yyvsp = yylval;
    452         yychar = (-1);
     523        yychar = YYEMPTY;
    453524        if (yyerrflag > 0)  --yyerrflag;
    454525        goto yyloop;
    … …  
    461532    }
    462533    if (yyerrflag) goto yyinrecovery;
     534
    463535    yyerror("syntax error");
    464 #ifdef lint
     536
    465537    goto yyerrlab;
    466 #endif
     538
    467539yyerrlab:
    468540    ++yynerrs;
     541
    469542yyinrecovery:
    470543    if (yyerrflag < 3)
    … …  
    481554 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
    482555#endif
    483                 if (yyssp >= yyss + yystacksize - 1)
     556                if (yyssp >= yysslim && yygrowstack())
    484557                {
    485558                    goto yyoverflow;
    486559                }
    487                 *++yyssp = yystate = yytable[yyn];
     560                yystate = yytable[yyn];
     561                *++yyssp = yytable[yyn];
    488562                *++yyvsp = yylval;
    489563                goto yyloop;
    … …  
    515589        }
    516590#endif
    517         yychar = (-1);
     591        yychar = YYEMPTY;
    518592        goto yyloop;
    519593    }
     594
    520595yyreduce:
    521596#if YYDEBUG
    … …  
    525600#endif
    526601    yym = yylen[yyn];
    527     yyval = yyvsp[1-yym];
     602    if (yym)
     603        yyval = yyvsp[1-yym];
     604    else
     605        memset(&yyval, 0, sizeof yyval);
    528606    switch (yyn)
    529607    {
    530608case 1:
    531 {
     609        {
    532610                        return (yyvsp[0]);
    533611                }
    534612break;
    535613case 2:
    536 { yyval = yyvsp[-1]; }
     614        { yyval = yyvsp[-1]; }
    537615break;
    538616case 3:
    539 { yyval = yyvsp[-2] ? yyvsp[-2] : yyvsp[0] ? yyvsp[0] : 0; }
     617        { yyval = yyvsp[-2] ? yyvsp[-2] : yyvsp[0] ? yyvsp[0] : 0; }
    540618break;
    541619case 4:
    542 { yyval = yyvsp[-2] ? ( yyvsp[0] ? yyvsp[0] : 0 ) : 0; }
     620        { yyval = yyvsp[-2] ? ( yyvsp[0] ? yyvsp[0] : 0 ) : 0; }
    543621break;
    544622case 5:
    545 { yyval = yyvsp[-2] | yyvsp[0]; }
     623        { yyval = yyvsp[-2] | yyvsp[0]; }
    546624break;
    547625case 6:
    548 { yyval = yyvsp[-2] ^ yyvsp[0]; }
     626        { yyval = yyvsp[-2] ^ yyvsp[0]; }
    549627break;
    550628case 7:
    551 { yyval = yyvsp[-2] & yyvsp[0]; }
     629        { yyval = yyvsp[-2] & yyvsp[0]; }
    552630break;
    553631case 8:
    554 { yyval = yyvsp[-2] == yyvsp[0]; }
     632        { yyval = yyvsp[-2] == yyvsp[0]; }
    555633break;
    556634case 9:
    557 { yyval = yyvsp[-2] > yyvsp[0]; }
     635        { yyval = yyvsp[-2] > yyvsp[0]; }
    558636break;
    559637case 10:
    560 { yyval = yyvsp[-2] >= yyvsp[0]; }
     638        { yyval = yyvsp[-2] >= yyvsp[0]; }
    561639break;
    562640case 11:
    563 { yyval = yyvsp[-2] < yyvsp[0]; }
     641        { yyval = yyvsp[-2] < yyvsp[0]; }
    564642break;
    565643case 12:
    566 { yyval = yyvsp[-2] <= yyvsp[0]; }
     644        { yyval = yyvsp[-2] <= yyvsp[0]; }
    567645break;
    568646case 13:
    569 { yyval = yyvsp[-2] != yyvsp[0]; }
     647        { yyval = yyvsp[-2] != yyvsp[0]; }
    570648break;
    571649case 14:
    572 { yyval = yyvsp[-2] << yyvsp[0]; }
     650        { yyval = yyvsp[-2] << yyvsp[0]; }
    573651break;
    574652case 15:
    575 { yyval = yyvsp[-2] >> yyvsp[0]; }
     653        { yyval = yyvsp[-2] >> yyvsp[0]; }
    576654break;
    577655case 16:
    578 { yyval = yyvsp[-2] + yyvsp[0]; }
     656        { yyval = yyvsp[-2] + yyvsp[0]; }
    579657break;
    580658case 17:
    581 { yyval = yyvsp[-2] - yyvsp[0]; }
     659        { yyval = yyvsp[-2] - yyvsp[0]; }
    582660break;
    583661case 18:
    584 { yyval = yyvsp[-2] * yyvsp[0]; }
     662        { yyval = yyvsp[-2] * yyvsp[0]; }
    585663break;
    586664case 19:
    587 {
     665        {
    588666                        if (yyvsp[0] == 0)
    589667                                yyerror("division by zero");
    … …  
    592670break;
    593671case 20:
    594 {
     672        {
    595673                        if (yyvsp[0] == 0)
    596674                                yyerror("division by zero");
    … …  
    599677break;
    600678case 21:
    601 { yyval = !(yyvsp[0]); }
     679        { yyval = !(yyvsp[0]); }
    602680break;
    603681case 22:
    604 { yyval = ~(yyvsp[0]); }
     682        { yyval = ~(yyvsp[0]); }
    605683break;
    606684case 23:
    607 { yyval = -(yyvsp[0]); }
     685        { yyval = -(yyvsp[0]); }
    608686break;
    609687case 24:
    610 { yyval = yyvsp[0]; }
     688        { yyval = yyvsp[0]; }
    611689break;
    612690    }
    … …  
    652730to state %d\n", YYPREFIX, *yyssp, yystate);
    653731#endif
    654     if (yyssp >= yyss + yystacksize - 1)
     732    if (yyssp >= yysslim && yygrowstack())
    655733    {
    656734        goto yyoverflow;
    657735    }
    658     *++yyssp = yystate;
     736    *++yyssp = (short) yystate;
    659737    *++yyvsp = yyval;
    660738    goto yyloop;
     739
    661740yyoverflow:
    662741    yyerror("yacc stack overflow");
     742
    663743yyabort:
    664744    return (1);
     745
    665746yyaccept:
    666747    return (0);

  • trunk/src/kash/generated/arith_lex.c

    r1233 r2415  
    1 #line 2 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
    2 
    3 #line 4 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     1#line 2 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/out/darwin.x86/release/obj/kash/arith_lex.c"
     2
     3#line 4 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/out/darwin.x86/release/obj/kash/arith_lex.c"
    44
    55#define  YY_INT_ALIGNED short int
    … …  
    478478#define YY_RESTORE_YY_MORE_OFFSET
    479479char *yytext;
    480 #line 1 "arith_lex.l"
    481 #line 3 "arith_lex.l"
     480#line 1 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
     481#define YY_NO_INPUT 1
     482/** @todo %option reentrant */
     483#line 33 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    482484/*      $NetBSD: arith_lex.l,v 1.13 2005/03/21 22:37:09 dsl Exp $       */
    483485
    … …  
    522524#endif
    523525
     526#include <stdio.h>
    524527#include "arith.h"
    525528#include "error.h"
    … …  
    535538        result = (*buf = *arith_buf++) ? 1 : YY_NULL;
    536539#define YY_NO_UNPUT
    537 #line 538 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     540
     541/* Avoid unnecessary libc bits. */
     542#undef  ECHO
     543#define ECHO \
     544        do {} while (0)
     545#undef  stdin
     546#define stdin  \
     547        NULL
     548#undef  stdout
     549#define stdout \
     550        NULL
     551#define YY_FATAL_ERROR(msg) \
     552        error(arith_psh, "arith: fatal error: %s", msg)
     553#line 554 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/out/darwin.x86/release/obj/kash/arith_lex.c"
    538554
    539555#define INITIAL 0
    … …  
    565581#endif
    566582
    567     static void yyunput (int c,char *buf_ptr  );
    568    
    569583#ifndef yytext_ptr
    570584static void yy_flex_strncpy (char *,yyconst char *,int );
    … …  
    688702        register int yy_act;
    689703   
    690 #line 60 "arith_lex.l"
    691 
    692 #line 693 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     704#line 104 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
     705
     706#line 707 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/out/darwin.x86/release/obj/kash/arith_lex.c"
    693707
    694708        if ( !(yy_init) )
    … …  
    749763                        ++yy_cp;
    750764                        }
    751                 while ( yy_base[yy_current_state] != 48 );
     765                while ( yy_current_state != 38 );
     766                yy_cp = (yy_last_accepting_cpos);
     767                yy_current_state = (yy_last_accepting_state);
    752768
    753769yy_find_action:
    754770                yy_act = yy_accept[yy_current_state];
    755                 if ( yy_act == 0 )
    756                         { /* have to back up */
    757                         yy_cp = (yy_last_accepting_cpos);
    758                         yy_current_state = (yy_last_accepting_state);
    759                         yy_act = yy_accept[yy_current_state];
    760                         }
    761771
    762772                YY_DO_BEFORE_ACTION;
    … …  
    776786/* rule 1 can match eol */
    777787YY_RULE_SETUP
    778 #line 61 "arith_lex.l"
     788#line 105 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    779789{ ; }
    780790        YY_BREAK
    781791case 2:
    782792YY_RULE_SETUP
    783 #line 62 "arith_lex.l"
     793#line 106 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    784794{ yylval = strtol(yytext, 0, 0); return(ARITH_NUM); }
    785795        YY_BREAK
    786796case 3:
    787797YY_RULE_SETUP
    788 #line 63 "arith_lex.l"
     798#line 107 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    789799{ yylval = strtol(yytext, 0, 0); return(ARITH_NUM); }
    790800        YY_BREAK
    791801case 4:
    792802YY_RULE_SETUP
    793 #line 64 "arith_lex.l"
     803#line 108 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    794804{ yylval = strtol(yytext, 0, 0); return(ARITH_NUM); }
    795805        YY_BREAK
    796806case 5:
    797807YY_RULE_SETUP
    798 #line 65 "arith_lex.l"
     808#line 109 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    799809{ char *v = lookupvar(arith_psh, yytext);
    800810                        if (v) {
    … …  
    808818case 6:
    809819YY_RULE_SETUP
    810 #line 73 "arith_lex.l"
     820#line 117 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    811821{ return(ARITH_LPAREN); }
    812822        YY_BREAK
    813823case 7:
    814824YY_RULE_SETUP
    815 #line 74 "arith_lex.l"
     825#line 118 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    816826{ return(ARITH_RPAREN); }
    817827        YY_BREAK
    818828case 8:
    819829YY_RULE_SETUP
    820 #line 75 "arith_lex.l"
     830#line 119 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    821831{ return(ARITH_OR); }
    822832        YY_BREAK
    823833case 9:
    824834YY_RULE_SETUP
    825 #line 76 "arith_lex.l"
     835#line 120 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    826836{ return(ARITH_AND); }
    827837        YY_BREAK
    828838case 10:
    829839YY_RULE_SETUP
    830 #line 77 "arith_lex.l"
     840#line 121 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    831841{ return(ARITH_BOR); }
    832842        YY_BREAK
    833843case 11:
    834844YY_RULE_SETUP
    835 #line 78 "arith_lex.l"
     845#line 122 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    836846{ return(ARITH_BXOR); }
    837847        YY_BREAK
    838848case 12:
    839849YY_RULE_SETUP
    840 #line 79 "arith_lex.l"
     850#line 123 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    841851{ return(ARITH_BAND); }
    842852        YY_BREAK
    843853case 13:
    844854YY_RULE_SETUP
    845 #line 80 "arith_lex.l"
     855#line 124 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    846856{ return(ARITH_EQ); }
    847857        YY_BREAK
    848858case 14:
    849859YY_RULE_SETUP
    850 #line 81 "arith_lex.l"
     860#line 125 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    851861{ return(ARITH_NE); }
    852862        YY_BREAK
    853863case 15:
    854864YY_RULE_SETUP
    855 #line 82 "arith_lex.l"
     865#line 126 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    856866{ return(ARITH_GT); }
    857867        YY_BREAK
    858868case 16:
    859869YY_RULE_SETUP
    860 #line 83 "arith_lex.l"
     870#line 127 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    861871{ return(ARITH_GE); }
    862872        YY_BREAK
    863873case 17:
    864874YY_RULE_SETUP
    865 #line 84 "arith_lex.l"
     875#line 128 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    866876{ return(ARITH_LT); }
    867877        YY_BREAK
    868878case 18:
    869879YY_RULE_SETUP
    870 #line 85 "arith_lex.l"
     880#line 129 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    871881{ return(ARITH_LE); }
    872882        YY_BREAK
    873883case 19:
    874884YY_RULE_SETUP
    875 #line 86 "arith_lex.l"
     885#line 130 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    876886{ return(ARITH_LSHIFT); }
    877887        YY_BREAK
    878888case 20:
    879889YY_RULE_SETUP
    880 #line 87 "arith_lex.l"
     890#line 131 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    881891{ return(ARITH_RSHIFT); }
    882892        YY_BREAK
    883893case 21:
    884894YY_RULE_SETUP
    885 #line 88 "arith_lex.l"
     895#line 132 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    886896{ return(ARITH_MUL); }
    887897        YY_BREAK
    888898case 22:
    889899YY_RULE_SETUP
    890 #line 89 "arith_lex.l"
     900#line 133 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    891901{ return(ARITH_DIV); }
    892902        YY_BREAK
    893903case 23:
    894904YY_RULE_SETUP
    895 #line 90 "arith_lex.l"
     905#line 134 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    896906{ return(ARITH_REM); }
    897907        YY_BREAK
    898908case 24:
    899909YY_RULE_SETUP
    900 #line 91 "arith_lex.l"
     910#line 135 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    901911{ return(ARITH_ADD); }
    902912        YY_BREAK
    903913case 25:
    904914YY_RULE_SETUP
    905 #line 92 "arith_lex.l"
     915#line 136 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    906916{ return(ARITH_SUB); }
    907917        YY_BREAK
    908918case 26:
    909919YY_RULE_SETUP
    910 #line 93 "arith_lex.l"
     920#line 137 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    911921{ return(ARITH_BNOT); }
    912922        YY_BREAK
    913923case 27:
    914924YY_RULE_SETUP
    915 #line 94 "arith_lex.l"
     925#line 138 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    916926{ return(ARITH_NOT); }
    917927        YY_BREAK
    918928case 28:
    919929YY_RULE_SETUP
    920 #line 95 "arith_lex.l"
     930#line 139 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    921931{ error(arith_psh, "arith: syntax error: \"%s\"", arith_startbuf); }
    922932        YY_BREAK
    923933case 29:
    924934YY_RULE_SETUP
    925 #line 96 "arith_lex.l"
     935#line 140 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    926936ECHO;
    927937        YY_BREAK
    928 #line 929 "/home/bird/vax/gdrive/coding/kbuild/svn/trunk/out/linux.x86/release/obj/src/kash/arith_lex.c"
     938#line 939 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/out/darwin.x86/release/obj/kash/arith_lex.c"
    929939case YY_STATE_EOF(INITIAL):
    930940        yyterminate();
    … …  
    9931003                        else
    9941004                                {
    995                                 yy_cp = (yy_c_buf_p);
     1005                                yy_cp = (yy_last_accepting_cpos);
     1006                                yy_current_state = (yy_last_accepting_state);
    9961007                                goto yy_find_action;
    9971008                                }
    … …  
    12471258}
    12481259
    1249     static void yyunput (int c, register char * yy_bp )
    1250 {
    1251         register char *yy_cp;
    1252    
    1253     yy_cp = (yy_c_buf_p);
    1254 
    1255         /* undo effects of setting up yytext */
    1256         *yy_cp = (yy_hold_char);
    1257 
    1258         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    1259                 { /* need to shift things up to make room */
    1260                 /* +2 for EOB chars. */
    1261                 register int number_to_move = (yy_n_chars) + 2;
    1262                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
    1263                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    1264                 register char *source =
    1265                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
    1266 
    1267                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    1268                         *--dest = *--source;
    1269 
    1270                 yy_cp += (int) (dest - source);
    1271                 yy_bp += (int) (dest - source);
    1272                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
    1273                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
    1274 
    1275                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    1276                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
    1277                 }
    1278 
    1279         *--yy_cp = (char) c;
    1280 
    1281         (yytext_ptr) = yy_bp;
    1282         (yy_hold_char) = *yy_cp;
    1283         (yy_c_buf_p) = yy_cp;
    1284 }
    1285 
    12861260#ifndef YY_NO_INPUT
    12871261#ifdef __cplusplus
    … …  
    13321306                                        {
    13331307                                        if ( yywrap( ) )
    1334                                                 return EOF;
     1308                                                return 0;
    13351309
    13361310                                        if ( ! (yy_did_buffer_switch_on_eof) )
    … …  
    14681442}
    14691443
    1470 #ifndef _UNISTD_H /* assume unistd.h has isatty() for us */
    1471 #ifdef __cplusplus
    1472 extern "C" {
    1473 #endif
    1474 #ifdef __THROW /* this is a gnuism */
    1475 extern int isatty (int ) __THROW;
    1476 #else
    1477 extern int isatty (int );
    1478 #endif
    1479 #ifdef __cplusplus
    1480 }
    1481 #endif
    1482 #endif
    1483    
    14841444/* Initializes or reinitializes a buffer.
    14851445 * This function is sometimes called more than once on the same buffer,
    … …  
    15051465    }
    15061466
    1507         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
     1467        b->yy_is_interactive = 0;
    15081468   
    15091469        errno = oerrno;
    … …  
    16311591}
    16321592
    1633 /** Setup the input buffer state to scan directly from a user-specified character buffer.
    1634  * @param base the character buffer
    1635  * @param size the size in bytes of the character buffer
    1636  *
    1637  * @return the newly allocated buffer state object.
    1638  */
    1639 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
    1640 {
    1641         YY_BUFFER_STATE b;
    1642    
    1643         if ( size < 2 ||
    1644              base[size-2] != YY_END_OF_BUFFER_CHAR ||
    1645              base[size-1] != YY_END_OF_BUFFER_CHAR )
    1646                 /* They forgot to leave room for the EOB's. */
    1647                 return 0;
    1648 
    1649         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
    1650         if ( ! b )
    1651                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    1652 
    1653         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
    1654         b->yy_buf_pos = b->yy_ch_buf = base;
    1655         b->yy_is_our_buffer = 0;
    1656         b->yy_input_file = 0;
    1657         b->yy_n_chars = b->yy_buf_size;
    1658         b->yy_is_interactive = 0;
    1659         b->yy_at_bol = 1;
    1660         b->yy_fill_buffer = 0;
    1661         b->yy_buffer_status = YY_BUFFER_NEW;
    1662 
    1663         yy_switch_to_buffer(b  );
    1664 
    1665         return b;
    1666 }
    1667 
    1668 /** Setup the input buffer state to scan a string. The next call to yylex() will
    1669  * scan from a @e copy of @a str.
    1670  * @param str a NUL-terminated string to scan
    1671  *
    1672  * @return the newly allocated buffer state object.
    1673  * @note If you want to scan bytes that may contain NUL values, then use
    1674  *       yy_scan_bytes() instead.
    1675  */
    1676 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
    1677 {
    1678    
    1679         return yy_scan_bytes(yystr,strlen(yystr) );
    1680 }
    1681 
    1682 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
    1683  * scan from a @e copy of @a bytes.
    1684  * @param bytes the byte buffer to scan
    1685  * @param len the number of bytes in the buffer pointed to by @a bytes.
    1686  *
    1687  * @return the newly allocated buffer state object.
    1688  */
    1689 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
    1690 {
    1691         YY_BUFFER_STATE b;
    1692         char *buf;
    1693         yy_size_t n;
    1694         int i;
    1695    
    1696         /* Get memory for full buffer, including space for trailing EOB's. */
    1697         n = _yybytes_len + 2;
    1698         buf = (char *) yyalloc(n  );
    1699         if ( ! buf )
    1700                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    1701 
    1702         for ( i = 0; i < _yybytes_len; ++i )
    1703                 buf[i] = yybytes[i];
    1704 
    1705         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
    1706 
    1707         b = yy_scan_buffer(buf,n );
    1708         if ( ! b )
    1709                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    1710 
    1711         /* It's okay to grow etc. this buffer, and we should throw it
    1712          * away when we're done.
    1713          */
    1714         b->yy_is_our_buffer = 1;
    1715 
    1716         return b;
    1717 }
    1718 
    17191593#ifndef YY_EXIT_FAILURE
    17201594#define YY_EXIT_FAILURE 2
    … …  
    17461620/* Accessor  methods (get/set functions) to struct members. */
    17471621
    1748 /** Get the current line number.
    1749  *
    1750  */
    1751 int yyget_lineno  (void)
    1752 {
    1753        
    1754     return yylineno;
    1755 }
    1756 
    1757 /** Get the input stream.
    1758  *
    1759  */
    1760 FILE *yyget_in  (void)
    1761 {
    1762         return yyin;
    1763 }
    1764 
    1765 /** Get the output stream.
    1766  *
    1767  */
    1768 FILE *yyget_out  (void)
    1769 {
    1770         return yyout;
    1771 }
    1772 
    1773 /** Get the length of the current token.
    1774  *
    1775  */
    1776 int yyget_leng  (void)
    1777 {
    1778         return yyleng;
    1779 }
    1780 
    17811622/** Get the current token.
    17821623 *
    17831624 */
    1784 
    1785 char *yyget_text  (void)
    1786 {
    1787         return yytext;
    1788 }
    1789 
    1790 /** Set the current line number.
    1791  * @param line_number
    1792  *
    1793  */
    1794 void yyset_lineno (int  line_number )
    1795 {
    1796    
    1797     yylineno = line_number;
    1798 }
    1799 
    1800 /** Set the input stream. This does not discard the current
    1801  * input buffer.
    1802  * @param in_str A readable stream.
    1803  *
    1804  * @see yy_switch_to_buffer
    1805  */
    1806 void yyset_in (FILE *  in_str )
    1807 {
    1808         yyin = in_str ;
    1809 }
    1810 
    1811 void yyset_out (FILE *  out_str )
    1812 {
    1813         yyout = out_str ;
    1814 }
    1815 
    1816 int yyget_debug  (void)
    1817 {
    1818         return yy_flex_debug;
    1819 }
    1820 
    1821 void yyset_debug (int  bdebug )
    1822 {
    1823         yy_flex_debug = bdebug ;
    1824 }
    18251625
    18261626static int yy_init_globals (void)
    … …  
    18981698#endif
    18991699
    1900 void *yyalloc (yy_size_t  size )
    1901 {
    1902         return (void *) malloc( size );
    1903 }
    1904 
    1905 void *yyrealloc  (void * ptr, yy_size_t  size )
    1906 {
    1907         /* The cast to (char *) in the following accommodates both
    1908          * implementations that use char* generic pointers, and those
    1909          * that use void* generic pointers.  It works with the latter
    1910          * because both ANSI C and C++ allow castless assignment from
    1911          * any pointer type to void*, and deal with argument conversions
    1912          * as though doing an assignment.
    1913          */
    1914         return (void *) realloc( (char *) ptr, size );
    1915 }
    1916 
    1917 void yyfree (void * ptr )
    1918 {
    1919         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
    1920 }
    1921 
    19221700#define YYTABLES_NAME "yytables"
    19231701
    1924 #line 96 "arith_lex.l"
     1702#line 140 "/Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/arith_lex.l"
    19251703
    19261704
    … …  
    19331711}
    19341712
     1713void *
     1714yyalloc(yy_size_t cb)
     1715{
     1716        return sh_malloc(NULL, cb);
     1717}
     1718
     1719void *
     1720yyrealloc(void *pv,yy_size_t cb)
     1721{
     1722        return sh_realloc(NULL, pv, cb);
     1723}
     1724
     1725void
     1726yyfree(void *pv)
     1727{
     1728        sh_free(NULL, pv);
     1729}
     1730
     1731

  • trunk/src/kash/generated/init.c

    r2290 r2415  
    110110#undef  STANDARD_BITS
    111111#define STANDARD_BITS   (S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO)
     112#undef  SHMEMHDR_MAGIC_FREE
     113#define SHMEMHDR_MAGIC_FREE     0xbeeff00d
     114#undef  SHMEMHDR_MAGIC_USED
     115#define SHMEMHDR_MAGIC_USED     0xfeedface
     116#undef  SHMEMCHUNK_MAGIC
     117#define SHMEMCHUNK_MAGIC        0x12345678
     118#undef  SHHEAP_MIN_CHUNK
     119#define SHHEAP_MIN_CHUNK        0x80000 //(1024*1024)
     120#undef  SHFILE_MAX
     121#define SHFILE_MAX          1024
     122#undef  SHFILE_GROW
     123#define SHFILE_GROW         64
     124#undef  SHFILE_UNIX_MIN_FD
     125#define SHFILE_UNIX_MIN_FD  32
     126#undef  SHFILE_MAX_PATH
     127#define SHFILE_MAX_PATH     4096
     128#undef  YY_NO_UNPUT
     129#define YY_NO_UNPUT
    112130
    113131
    … …  
    132150init(shinstance *psh) {
    133151
    134       /* from exec.c: */
     152      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/exec.c: */
    135153      {
    136154              hash_special_builtins(psh);
    137155      }
    138156
    139       /* from input.c: */
     157      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/input.c: */
    140158      {
    141159              psh->basepf.nextc = psh->basepf.buf = psh->basebuf;
    142160      }
    143161
    144       /* from options.c: */
     162      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/options.c: */
    145163      {
    146164              memcpy(&psh->optlist[0], &ro_optlist[0], sizeof(psh->optlist));
    147165      }
    148166
    149       /* from var.c: */
     167      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/var.c: */
    150168      {
    151169              char **envp;
    … …  
    170188reset(shinstance *psh) {
    171189
    172       /* from eval.c: */
     190      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/eval.c: */
    173191      {
    174192              psh->evalskip = 0;
    … …  
    177195      }
    178196
    179       /* from input.c: */
     197      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/input.c: */
    180198      {
    181199              if (psh->exception != EXSHELLPROC)
    … …  
    184202      }
    185203
    186       /* from output.c: */
     204      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/output.c: */
    187205      {
    188206              psh->out1 = &psh->output;
    … …  
    194212      }
    195213
    196       /* from parser.c: */
     214      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/parser.c: */
    197215      {
    198216              psh->tokpushback = 0;
    … …  
    200218      }
    201219
    202       /* from redir.c: */
     220      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/redir.c: */
    203221      {
    204222              while (psh->redirlist)
    … …  
    216234initshellproc(shinstance *psh) {
    217235
    218       /* from alias.c: */
     236      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/alias.c: */
    219237      {
    220238              rmaliases(psh);
    221239      }
    222240
    223       /* from eval.c: */
     241      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/eval.c: */
    224242      {
    225243              psh->exitstatus = 0;
    226244      }
    227245
    228       /* from exec.c: */
     246      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/exec.c: */
    229247      {
    230248              deletefuncs(psh);
    231249      }
    232250
    233       /* from input.c: */
     251      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/input.c: */
    234252      {
    235253              popallfiles(psh);
    236254      }
    237255
    238       /* from jobs.c: */
     256      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/jobs.c: */
    239257      {
    240258              psh->backgndpid = -1;
    … …  
    244262      }
    245263
    246       /* from options.c: */
     264      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/options.c: */
    247265      {
    248266              int i;
    … …  
    254272      }
    255273
    256       /* from redir.c: */
     274      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/redir.c: */
    257275      {
    258276              clearredir(psh, 0);
    259277      }
    260278
    261       /* from trap.c: */
     279      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/trap.c: */
    262280      {
    263281              char *sm;
    … …  
    270288      }
    271289
    272       /* from var.c: */
     290      /* from /Volumes/ScratchHFS/bird/kBuild/svn/trunk/src/kash/var.c: */
    273291      {
    274292              shprocvar(psh);

  • trunk/src/kash/shfile.h

    r2413 r2415  
    173173typedef struct shdir
    174174{
    175     shfdtab    *shfdtab;
     175    shfdtab    *pshfdtab;
    176176    void       *native;
    177177    shdirent    ent;
Note: See TracChangeset for help on using the changeset viewer.

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