Return to mod_ssi_exprparser.y CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src

Annotation of embedaddon/lighttpd/src/mod_ssi_exprparser.y, revision 1.1.1.1

1.1       misho       1: %token_prefix TK_
                      2: %token_type {buffer *}
                      3: %extra_argument {ssi_ctx_t *ctx}
                      4: %name ssiexprparser
                      5: 
                      6: %include {
                      7: #include "mod_ssi_expr.h"
                      8: #include "buffer.h"
                      9: 
                     10: #include <assert.h>
                     11: #include <string.h>
                     12: }
                     13: 
                     14: %parse_failure {
                     15:   ctx->ok = 0;
                     16: }
                     17: 
                     18: %type expr { ssi_val_t * }
                     19: %type value { buffer * }
                     20: %type exprline { ssi_val_t * }
                     21: %type cond { int }
                     22: %token_destructor { buffer_free($$); }
                     23: 
                     24: %left AND.
                     25: %left OR.
                     26: %nonassoc EQ NE GT GE LT LE.
                     27: %right NOT.
                     28: 
                     29: input ::= exprline(B). {
                     30:   ctx->val.bo = ssi_val_tobool(B);
                     31:   ctx->val.type = SSI_TYPE_BOOL;
                     32: 
                     33:   ssi_val_free(B);
                     34: }
                     35: 
                     36: exprline(A) ::= expr(B) cond(C) expr(D). {
                     37:   int cmp;
                     38: 
                     39:   if (B->type == SSI_TYPE_STRING &&
                     40:       D->type == SSI_TYPE_STRING) {
                     41:        cmp = strcmp(B->str->ptr, D->str->ptr);
                     42:   } else {
                     43:     cmp = ssi_val_tobool(B) - ssi_val_tobool(D);
                     44:   }
                     45: 
                     46:   A = B;
                     47: 
                     48:   switch(C) {
                     49:   case SSI_COND_EQ: A->bo = (cmp == 0) ? 1 : 0; break;
                     50:   case SSI_COND_NE: A->bo = (cmp != 0) ? 1 : 0; break;
                     51:   case SSI_COND_GE: A->bo = (cmp >= 0) ? 1 : 0; break;
                     52:   case SSI_COND_GT: A->bo = (cmp > 0) ? 1 : 0; break;
                     53:   case SSI_COND_LE: A->bo = (cmp <= 0) ? 1 : 0; break;
                     54:   case SSI_COND_LT: A->bo = (cmp < 0) ? 1 : 0; break;
                     55:   }
                     56: 
                     57:   A->type = SSI_TYPE_BOOL;
                     58: 
                     59:   ssi_val_free(D);
                     60: }
                     61: exprline(A) ::= expr(B). {
                     62:   A = B;
                     63: }
                     64: expr(A) ::= expr(B) AND expr(C). {
                     65:   int e;
                     66: 
                     67:   e = ssi_val_tobool(B) && ssi_val_tobool(C);
                     68: 
                     69:   A = B;
                     70:   A->bo = e;
                     71:   A->type = SSI_TYPE_BOOL;
                     72:   ssi_val_free(C);
                     73: }
                     74: 
                     75: expr(A) ::= expr(B) OR expr(C). {
                     76:   int e;
                     77: 
                     78:   e = ssi_val_tobool(B) || ssi_val_tobool(C);
                     79: 
                     80:   A = B;
                     81:   A->bo = e;
                     82:   A->type = SSI_TYPE_BOOL;
                     83:   ssi_val_free(C);
                     84: }
                     85: 
                     86: expr(A) ::= NOT expr(B). {
                     87:   int e;
                     88: 
                     89:   e = !ssi_val_tobool(B);
                     90: 
                     91:   A = B;
                     92:   A->bo = e;
                     93:   A->type = SSI_TYPE_BOOL;
                     94: }
                     95: expr(A) ::= LPARAN exprline(B) RPARAN. {
                     96:   A = B;
                     97: }
                     98: 
                     99: expr(A) ::= value(B). {
                    100:   A = ssi_val_init();
                    101:   A->str = B;
                    102:   A->type = SSI_TYPE_STRING;
                    103: }
                    104: 
                    105: value(A) ::= VALUE(B). {
                    106:   A = B;
                    107: }
                    108: 
                    109: value(A) ::= value(B) VALUE(C). {
                    110:   A = B;
                    111:   buffer_append_string_buffer(A, C);
                    112:   buffer_free(C);
                    113: }
                    114: 
                    115: cond(A) ::= EQ. { A = SSI_COND_EQ; }
                    116: cond(A) ::= NE. { A = SSI_COND_NE; }
                    117: cond(A) ::= LE. { A = SSI_COND_LE; }
                    118: cond(A) ::= GE. { A = SSI_COND_GE; }
                    119: cond(A) ::= LT. { A = SSI_COND_LT; }
                    120: cond(A) ::= GT. { A = SSI_COND_GT; }