Return to x.y CVS log

Up to [Research Unix] / researchv10no / cmd / pico

Annotation of researchv10no/cmd/pico/x.y, revision 1.1

1.1     ! root        1: %{
        !             2: #include <stdio.h>
        !             3: #include "pico.h"
        !             4: #include "pico2.h"
        !             5: 
        !             6: #define usedboth       usedold=usednew=1
        !             7: 
        !             8: #define YYDEBUG        1
        !             9: 
        !            10: extern short CURSCRATCH, CUROLD;
        !            11: extern char *progr;
        !            12: extern struct SRC src[MANY];
        !            13: extern int nsrc, nrparams, LO, linenumber, whichdevice;
        !            14: extern char usednew, usedold, faster, frameb, metheus;
        !            15: extern char isglobal, seetree, optim, touchedcmap;
        !            16: extern FILE *INPUT;
        !            17: %}
        !            18: 
        !            19: %union{
        !            20:        Node    *node;
        !            21:        Symbol  *sym;
        !            22:        int     resu;
        !            23:        struct SNode *snode;
        !            24: }
        !            25: 
        !            26: %type  <node>  stmnt sstmnt pprog pbody rval assign ifpre whpre
        !            27: %type  <node>  aparams fcall elist expr chann
        !            28: %type  <snode> iarray lval
        !            29: %type  <resu>  array SPEC eval vval arname
        !            30: %type  <sym>   ANAME XYI pathn defpr
        !            31: %token <sym>   VARIABLE AUTO ARRAY FCT BLTN NAME
        !            32: %token <resu>  VAL STRING
        !            33: 
        !            34: %start         comm
        !            35: %token         A WINDOW C DEF DEL SCOM ECOM
        !            36: %token         UP DOWN RUN F H Q R SET SETF
        !            37: %token         GET W PCONST RETURN
        !            38: %token         OPEN CLOSE DECL INT GLOBAL
        !            39: %token         X Y I OLD TMP CMAP
        !            40: %token         FOR DO WHILE JUMP IF ELSE
        !            41: %token         COLOR NOCOLOR ZAP FASTER SLOWER HELP
        !            42: %token         FRAMEBUFFER METHEUS BLIND SEETREE OPTIM
        !            43: %right         ','
        !            44: %right         ASSIGN
        !            45: %right         '?' ':' ';'
        !            46: %right         OPER
        !            47: %left          OROR
        !            48: %left          ANDAND
        !            49: %left          OR
        !            50: %left          '^'
        !            51: %left          AND
        !            52: %left          EQ NE
        !            53: %left          GT GE LT LE
        !            54: %left          LSH RSH
        !            55: %left          '+' '-'
        !            56: %left          '*' '/' '%'
        !            57: %right         POST
        !            58: %right         UNARYMINUS NOT '$' '~'
        !            59: %right         RCHAN GCHAN BCHAN BW RGB
        !            60: %right         POW
        !            61: %right         '.'
        !            62: 
        !            63: %%
        !            64: comm:  pcom ';'                { return 1; }
        !            65: |      RUN SPEC                { munge($2); return 1; }
        !            66: |      defpr YoN SPEC          { postfunct($1); return 1; }
        !            67: |      R pathn ';'             { redirect($2->name);
        !            68:                                  checkit();
        !            69:                                  return 1;
        !            70:                                }
        !            71: |      Q ';'                   { return 0; }
        !            72: 
        !            73: defpr: DEF NAME '(' rglst ')'  { prefunct($2, nrparams); $$ = $2; }
        !            74: |      DEF FCT  '(' rglst ')'  { prefunct($2, nrparams); $$ = $2; }
        !            75: 
        !            76: pcom:  /* empty */             { /* if (INPUT == stdin) linenumber--; */ }
        !            77: |      A pathn                 { append( 0,  0,  0,  0, $2->name); }
        !            78: |      A vval vval vval vval pathn { append($2, $3, $4, $5, $6->name); }
        !            79: |      DEL pathn               { discard($2->name); }
        !            80: |      DEL array               { if ($2 > 1 && $2 <= nsrc-1)
        !            81:                                        discard(src[$2].fname);
        !            82:                                  else
        !            83:                                        yyerror("unknown file number %d", $2);
        !            84:                                }
        !            85: |      DEL VAL                 { if ($2 > 1 && $2 <= nsrc-1)
        !            86:                                        discard(src[$2].fname);
        !            87:                                  else
        !            88:                                        yyerror("unknown file number %d", $2);
        !            89:                                }
        !            90: |      F                       { files(); }
        !            91: |      GET                     { getscreen(Old); }
        !            92: |      GET arname              { getter($2); }
        !            93: |      GET pathn               { getter(append( 0,  0,  0,  0, $2->name)); }
        !            94: |      GET vval vval vval vval pathn { getter(append($2, $3, $4, $5, $6->name)); }
        !            95: |      H hnmlst
        !            96: |      FASTER                  { faster = 1; }
        !            97: |      SLOWER                  { faster = 0; }
        !            98: |      SEETREE                 { seetree = 1 - seetree; }
        !            99: |      OPTIM                   { optim = 1 - optim; }
        !           100: |      NOCOLOR                 { Old->nchan = Scratch->nchan = 1; }
        !           101: |      COLOR                   { Old->nchan = Scratch->nchan = 3;
        !           102:                                  checkpix(Old); checkpix(Scratch);
        !           103:                                }
        !           104: |      HELP                    { dohelp(); }
        !           105: |      SET                     { showvars(); }
        !           106: |      SET ANAME               { showsym($2); }
        !           107: |      SETF                    { showfcts(); }
        !           108: |      WINDOW vval vval vval vval  { setwindow($2, $3, $4, $5); }
        !           109: |      W pathn                 { putdpix($2->name, PICO); }
        !           110: |      W '-' pathn             { putdpix($3->name, 0); }
        !           111: 
        !           112: arname:        array                   { $$ = $1; }
        !           113: |      vval vval array         { $$ = append($1, $2,  0,  0, src[$3].fname); }
        !           114: |      vval vval vval vval array { $$ = append($1, $2, $3, $4, src[$5].fname); }
        !           115: 
        !           116: hnmlst:        pathn                   { interpret($1->name); }
        !           117: |      hnmlst pathn            { interpret($2->name); }
        !           118: 
        !           119: rglst: /* empty */
        !           120: |      arglst
        !           121: 
        !           122: arglst:        NAME                    { automa($1, nrparams++); }
        !           123: |      arglst ',' NAME         { automa($3, nrparams++); }
        !           124: 
        !           125: SPEC:  sstmnt                  { compile($1, progr); $$ = BLOOP; }
        !           126: |      chann ';'               { compile($1, progr); $$ = SLOOP; }
        !           127: |      pprog ';'               { compile($1, progr); $$ = NLOOP; }
        !           128: 
        !           129: chann: CMAP ASSIGN expr                { $$ = mapall(cast($3)); }
        !           130: |      CMAP '.' RGB   ASSIGN expr      { $$ = mapall($5); }
        !           131: |      CMAP '.' RCHAN ASSIGN expr      { $$ = mapred(cast($5)); }
        !           132: |      CMAP '.' GCHAN ASSIGN expr      { $$ = mapgrn(cast($5)); }
        !           133: |      CMAP '.' BCHAN ASSIGN expr      { $$ = mapblu(cast($5)); }
        !           134: 
        !           135: YoN:   /* empty */
        !           136: |      ';'
        !           137: 
        !           138: decls: glob INT declst ';'
        !           139: |      glob DECL decars ';'
        !           140: 
        !           141: glob:  GLOBAL                  { isglobal = 1; }
        !           142: |      /* none */              { isglobal = 0; }
        !           143: 
        !           144: declst:        declo
        !           145: |      declst ',' declo
        !           146: 
        !           147: decars:        decar
        !           148: |      decars ',' decar
        !           149: 
        !           150: declo: XYI
        !           151: |      NAME                    { decvar($1, 0); }
        !           152: |      VARIABLE                { decvar($1, 0); }
        !           153: |      NAME ASSIGN eval        { decvar($1, $3); }
        !           154: |      VARIABLE ASSIGN eval    { decvar($1, $3); }
        !           155: 
        !           156: decar: NAME  '[' eval ']'      { decarray($1, $3); }
        !           157: |      ARRAY '[' eval ']'      { decarray($1, $3); }
        !           158: 
        !           159: XYI:   X                       { $$ = newsym("x"); }
        !           160: |      Y                       { $$ = newsym("y"); }
        !           161: |      I                       { $$ = newsym("i"); }
        !           162: 
        !           163: pprog: OPEN pbody YoN CLOSE    { $$ = $2; }
        !           164: 
        !           165: pbody: stmnt                   { $$ = $1; }
        !           166: |      pbody stmnt             { $$ = new(OCOMMA, $1, $2, Z); }
        !           167: 
        !           168: aparams: '(' ')'               { $$ =  Z; }
        !           169: |       '(' elist ')'          { $$ = $2; }
        !           170: 
        !           171: elist: expr                    { $$ = cast($1); }
        !           172: |      expr ',' elist          { $$ = new(ACOMMA, cast($1), $3, Z); }
        !           173: 
        !           174: ifpre: IF '(' expr ')' YoN     { $$ = $3; }
        !           175: whpre: WHILE '(' expr ')' YoN  { $$ = $3; }
        !           176: 
        !           177: ANAME: NAME                    { $$ = $1; }
        !           178: |      VARIABLE                { $$ = $1; }
        !           179: |      FCT                     { $$ = $1; }
        !           180: |      BLTN                    { $$ = $1; }
        !           181: |      AUTO                    { $$ = $1; }
        !           182: |      ARRAY                   { $$ = $1; }
        !           183: |      XYI                     { $$ = $1; }
        !           184: |      STRING                  { $$ = lookup($1); }
        !           185: 
        !           186: pathn: ANAME                   { $$ = $1; }
        !           187: 
        !           188: stmnt: pprog ';'               { $$ = $1; }
        !           189: |      ANAME ':' stmnt         { $$ = new(LABL,$3, Z, $1); }
        !           190: |      JUMP ANAME ';'          { $$ = new(GOTO, Z, Z, $2); }
        !           191: |      sstmnt                  { $$ = $1; }
        !           192: |      chann ';'               { $$ = $1; }
        !           193: 
        !           194: sstmnt:        assign ';'              { $$ = $1; }
        !           195: |      decls                   { $$ = Z; }
        !           196: |      fcall ';'               { $$ = $1; }
        !           197: |      ifpre stmnt             { $$ = new(CONDI, $2, Z, $1); }
        !           198: |      ifpre stmnt ELSE YoN stmnt              { $$ = new(CONDI, $2, $5, $1); }
        !           199: |      FOR '(' expr ';' expr ';' expr ')' YoN stmnt {
        !           200:                                  $$ = newloop($3, $5, $7, $10); }
        !           201: |      whpre stmnt             { $$ = newhile($1, $2); }
        !           202: |      DO YoN stmnt WHILE '(' expr ')' ';'     { $$ = newuntil($3, $6); }
        !           203: |      RETURN  expr ';'        { $$ = new(ORETURN, $2, Z, Z); }
        !           204: 
        !           205: iarray:        BW                      { usedboth; $$ = super(CURSCRATCH, Z, BW); }
        !           206: |      RGB                     { usedboth; $$ = super(CURSCRATCH, Z, RGB); }
        !           207: |      RCHAN                   { usedboth; $$ = super(CURSCRATCH, Z, RCHAN); }
        !           208: |      GCHAN                   { usedboth; $$ = super(CURSCRATCH, Z, GCHAN); }
        !           209: |      BCHAN                   { usedboth; $$ = super(CURSCRATCH, Z, BCHAN); }
        !           210: |      array                   { $$ = super($1, Z, (src[$1].nchan == 1)?BW:RGB); }
        !           211: |      array '.' RGB           { $$ = super($1, Z, RGB); }
        !           212: |      array '.' BW            { $$ = super($1, Z, BW);  }
        !           213: |      array '.' RCHAN         { $$ = super($1, Z, RCHAN); }
        !           214: |      array '.' GCHAN         { $$ = super($1, Z, GCHAN); }
        !           215: |      array '.' BCHAN         { $$ = super($1, Z, BCHAN); }
        !           216: |      array '[' elist ']'     { $$ = super($1, $3,(src[$1].nchan == 1)?BW:RGB); }
        !           217: |      array '[' elist ']' '.' RGB     { $$ = super($1, $3, RGB); }
        !           218: |      array '[' elist ']' '.' BW      { $$ = super($1, $3, BW);  }
        !           219: |      array '[' elist ']' '.' RCHAN   { $$ = super($1, $3, RCHAN); }
        !           220: |      array '[' elist ']' '.' GCHAN   { $$ = super($1, $3, GCHAN); }
        !           221: |      array '[' elist ']' '.' BCHAN   { $$ = super($1, $3, BCHAN); }
        !           222: |      array '.'   RGB '[' elist ']'   { $$ = super($1, $5, RGB); }
        !           223: |      array '.'    BW '[' elist ']'   { $$ = super($1, $5, BW);  }
        !           224: |      array '.' RCHAN '[' elist ']'   { $$ = super($1, $5, RCHAN); }
        !           225: |      array '.' GCHAN '[' elist ']'   { $$ = super($1, $5, GCHAN); }
        !           226: |      array '.' BCHAN '[' elist ']'   { $$ = super($1, $5, BCHAN); }
        !           227: |      ARRAY '[' elist ']'     { $$=nsup(RL(($1->u.ar->base),Index($3)),0,0,128);}
        !           228: |      ARRAY                   { $$=nsup(RL(($1->u.ar->base),DII), 0,0,128); }
        !           229: 
        !           230: assign:        lval POST               { $$ = weird($1, notnew(LO, $1->n, NR(1))); }
        !           231: |      lval OPER expr  { $$ = weird($1, notnew(LO, $1->n, $3)); }
        !           232: |      lval ASSIGN expr        { $$ = weird($1, $3); }
        !           233: 
        !           234: rval:  lval                    { $$ = $1->n; }
        !           235: |      fcall                   { $$ = $1;    }
        !           236: 
        !           237: lval:  X                       { $$ = nsup(new(REG, Z, Z, XREG), 0, 0, 128); }
        !           238: |      Y                       { $$ = nsup(new(REG, Z, Z, YREG), 0, 0, 128); }
        !           239: |      I                       { $$ = nsup(new(REG, Z, Z, IREG), 0, 0, 128); }
        !           240: |      iarray                  { $$ = $1; }
        !           241: |      NAME                    { yyerror("undeclared variable %s", $1->name); }
        !           242: |      VARIABLE                { $$ = nsup(new(VAR,  Z, Z, &$1->u.val), 0,0,128);}
        !           243: |      AUTO                    { $$ = nsup(new(OARG, Z, Z,  $1->u.val), 0,0,128);}
        !           244: 
        !           245: fcall: FCT aparams             { if ($1->u.fu->usednew == -1 && notrecurcall($1))
        !           246:                                        yyerror("undefined function %s", $1->name);
        !           247:                                  argcount($1->u.fu->nrparams, $2, $1->name);
        !           248:                                  usednew += $1->u.fu->usednew;
        !           249:                                  usedold += $1->u.fu->usedold;
        !           250:                                  $$ = new(OCALL, $2, Z, $1->u.fu->fct);
        !           251:                                }
        !           252: |      BLTN aparams            { argcount($1->u.bl->nrparams, $2, $1->name);
        !           253:                                  usednew += $1->u.bl->usednew;
        !           254:                                  $$ = new(CCALL, $2, Z, $1->u.bl->faddr);
        !           255:                                }
        !           256: 
        !           257: vval:  VAL                     { $$ = $1; }
        !           258: |      '-' VAL                 { $$ = -$2; }
        !           259: 
        !           260: eval:  VAL                     { $$ = $1; }
        !           261: |      VARIABLE                { $$ = $1->u.val; }
        !           262: |      fcall                   { compile($1, progr); $$ = callit(); }
        !           263: 
        !           264: expr:  rval                    { $$ = $1; }
        !           265: |      assign                  { $$ = $1; }
        !           266: |      '(' expr ')'            { $$ = $2; }
        !           267: |      '[' elist ']'           { $$ = new(COMP, $2, Z, Z); }
        !           268: |      VAL                     { $$ = NR($1); }
        !           269: |      STRING                  { $$ = NR($1); }
        !           270: |      expr '?' expr ':' expr { $$ = new(CONDI, $3, $5, $1); }
        !           271: |      '-' expr %prec UNARYMINUS  { $$ = new(OMINUS, $2, Z, Z); }
        !           272: |      '~' expr                { $$ = new(ONEG, $2, Z, Z); }
        !           273: |      NOT expr                { $$ = new(ONOT, $2, Z, Z); }
        !           274: |      expr '+' expr           { $$ = notnew(OADD, $1, $3); }
        !           275: |      expr '-' expr           { $$ = notnew(OSUB, $1, $3); }
        !           276: |      expr '*' expr           { $$ = notnew(OMUL, $1, $3); }
        !           277: |      expr '/' expr           { $$ = notnew(DIVV, $1, $3); }
        !           278: |      expr '%' expr           { $$ = notnew(MODU, $1, $3); }
        !           279: |      expr '^' expr           { $$ = notnew(OXOR, $1, $3); }
        !           280: |      expr POW expr           { $$ = notnew(OPOW, $1, $3); }
        !           281: |      expr GT expr            { $$ = notnew(OGT,  $1, $3); }
        !           282: |      expr GE expr            { $$ = notnew(OGE,  $1, $3); }
        !           283: |      expr LT expr            { $$ = notnew(OLT,  $1, $3); }
        !           284: |      expr LE expr            { $$ = notnew(OLE,  $1, $3); }
        !           285: |      expr EQ expr            { $$ = notnew(OEQ,  $1, $3); }
        !           286: |      expr NE expr            { $$ = notnew(ONE,  $1, $3); }
        !           287: |      expr ANDAND expr        { $$ = notnew(OANDAND, $1, $3); }
        !           288: |      expr OROR expr          { $$ = notnew(OOROR, $1, $3); }
        !           289: |      expr OR expr            { $$ = notnew(OOR,  $1, $3); }
        !           290: |      expr AND expr           { $$ = notnew(OAND, $1, $3); }
        !           291: |      expr LSH expr           { $$ = notnew(OLSH, $1, $3); }
        !           292: |      expr RSH expr           { $$ = notnew(OLSH, $1, notnew(OMINUS, $3, Z)); }
        !           293: 
        !           294: array: TMP                     { usednew=usedold=1; $$ = CURSCRATCH; }
        !           295: |      OLD                     { usedold=1; $$ = CUROLD; }
        !           296: |      '$' TMP                 { usednew=usedold=1; $$ = CURSCRATCH; }
        !           297: |      '$' OLD                 { usedold=1; $$ = CUROLD; }
        !           298: |      '$' VAL                 { int x = $2;
        !           299:                                  if (x < 0 || x > nsrc-2)
        !           300:                                        yyerror("unknown file number %d", x);
        !           301:                                  x = (x == 0) ? CUROLD : x+1;
        !           302:                                  if (x == CUROLD)
        !           303:                                        usedold=1;
        !           304:                                  else
        !           305:                                        src[x].used = 1;
        !           306:                                  $$ = x;
        !           307:                                }
        !           308: |      '$' ANAME               { int x = whatarray($2->name);
        !           309:                                  if (x <= 0)
        !           310:                                        x = prepare($2->name);
        !           311:                                  if (x <= 0)
        !           312:                                        yyerror("unknown file %s", $2->name);
        !           313:                                  src[x].used = 1;
        !           314:                                  $$ = x;
        !           315:                                }
        !           316: %%

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.