/[CvsGraph]/cvsgraph/readconf.c
ViewVC logotype

Diff of /cvsgraph/readconf.c

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph | View Patch Patch

revision 1.11, Fri Mar 14 14:24:50 2003 UTC revision 1.23, Thu Dec 15 13:06:09 2005 UTC
# Line 42  Line 42 
42    
43  typedef struct  typedef struct
44  {  {
45          char    *keyword;          const char      *keyword;
46          int     type;          int             type;
47          union {          union {
48                  void    *v;     /* join of other values */                  void    *v;     /* join of other values */
49                  int     *i;                  int     *i;
# Line 51  Line 51 
51                  char    **s;                  char    **s;
52                  color_t *c;                  color_t *c;
53                  double  *d;                  double  *d;
54                  int     val;    /* FIXME: Oops, sizeof(int) must be sizeof(void *) */                  stringlist_t *sl;
55                    colorlist_t *cl;
56                    INTTYPE val;
57          } confref;          } confref;
58  } keyword_t;  } keyword_t;
59    
# Line 76  Line 78 
78          TYPE_COLOR,          TYPE_COLOR,
79          TYPE_FONT,          TYPE_FONT,
80          TYPE_STRING,          TYPE_STRING,
81          TYPE_DOUBLE          TYPE_DOUBLE,
82            TYPE_COLORLIST,
83            TYPE_STRINGLIST
84  };  };
85    
86  static keyword_t keywords[] = {  static keyword_t keywords[] = {
# Line 98  Line 102 
102          { "branch_dupbox",      TYPE_BOOLEAN,   { &conf.branch_dupbox } },          { "branch_dupbox",      TYPE_BOOLEAN,   { &conf.branch_dupbox } },
103          { "branch_fold",        TYPE_BOOLEAN,   { &conf.branch_fold } },          { "branch_fold",        TYPE_BOOLEAN,   { &conf.branch_fold } },
104          { "branch_foldall",     TYPE_BOOLEAN,   { &conf.branch_foldall } },          { "branch_foldall",     TYPE_BOOLEAN,   { &conf.branch_foldall } },
105            { "branch_resort",      TYPE_BOOLEAN,   { &conf.branch_resort } },
106            { "branch_subtree",     TYPE_STRING,    { &conf.branch_subtree } },
107          { "upside_down",        TYPE_BOOLEAN,   { &conf.upside_down } },          { "upside_down",        TYPE_BOOLEAN,   { &conf.upside_down } },
108          { "left_right",         TYPE_BOOLEAN,   { &conf.left_right } },          { "left_right",         TYPE_BOOLEAN,   { &conf.left_right } },
109          { "auto_stretch",       TYPE_BOOLEAN,   { &conf.auto_stretch } },          { "auto_stretch",       TYPE_BOOLEAN,   { &conf.auto_stretch } },
# Line 114  Line 120 
120          { "parse_logs",         TYPE_BOOLEAN,   { &conf.parse_logs } },          { "parse_logs",         TYPE_BOOLEAN,   { &conf.parse_logs } },
121          { "html_level",         TYPE_NUMBER,    { &conf.html_level } },          { "html_level",         TYPE_NUMBER,    { &conf.html_level } },
122          { "thick_lines",        TYPE_NUMBER,    { &conf.thick_lines } },          { "thick_lines",        TYPE_NUMBER,    { &conf.thick_lines } },
123            { "msg_color",          TYPE_COLOR,     { &conf.msg_color } },
124            { "msg_font",           TYPE_FONT,      { &conf.msg_font.gdfont } },
125            { "msg_ttfont",         TYPE_STRING,    { &conf.msg_font.ttfont } },
126            { "msg_ttsize",         TYPE_DOUBLE,    { &conf.msg_font.ttsize } },
127            { "rev_hidenumber",     TYPE_BOOLEAN,   { &conf.rev_hidenumber } },
128          { "rev_color",          TYPE_COLOR,     { &conf.rev_color } },          { "rev_color",          TYPE_COLOR,     { &conf.rev_color } },
129          { "rev_bgcolor",        TYPE_COLOR,     { &conf.rev_bgcolor } },          { "rev_bgcolor",        TYPE_COLOR,     { &conf.rev_bgcolor } },
130          { "rev_font",           TYPE_FONT,      { &conf.rev_font.gdfont } },          { "rev_font",           TYPE_FONT,      { &conf.rev_font.gdfont } },
# Line 132  Line 143 
143          { "rev_text_ttfont",    TYPE_STRING,    { &conf.rev_text_font.ttfont } },          { "rev_text_ttfont",    TYPE_STRING,    { &conf.rev_text_font.ttfont } },
144          { "rev_text_ttsize",    TYPE_DOUBLE,    { &conf.rev_text_font.ttsize } },          { "rev_text_ttsize",    TYPE_DOUBLE,    { &conf.rev_text_font.ttsize } },
145          { "rev_maxtags",        TYPE_NUMBER,    { &conf.rev_maxtags } },          { "rev_maxtags",        TYPE_NUMBER,    { &conf.rev_maxtags } },
146          { "merge_color",        TYPE_COLOR,     { &conf.merge_color } },          { "merge_color",        TYPE_COLORLIST, { &conf.merge_color } },
147          { "merge_from",         TYPE_STRING,    { &conf.merge_from } },          { "merge_from",         TYPE_STRINGLIST,        { &conf.merge_from } },
148          { "merge_to",           TYPE_STRING,    { &conf.merge_to } },          { "merge_to",           TYPE_STRINGLIST,        { &conf.merge_to } },
149            { "merge_findall",      TYPE_BOOLEAN,   { &conf.merge_findall } },
150          { "merge_front",        TYPE_BOOLEAN,   { &conf.merge_front } },          { "merge_front",        TYPE_BOOLEAN,   { &conf.merge_front } },
151          { "merge_nocase",       TYPE_BOOLEAN,   { &conf.merge_nocase } },          { "merge_nocase",       TYPE_BOOLEAN,   { &conf.merge_nocase } },
152            { "merge_arrows",       TYPE_BOOLEAN,   { &conf.merge_arrows } },
153            { "merge_cvsnt",        TYPE_BOOLEAN,   { &conf.merge_cvsnt } },
154            { "merge_cvsnt_color",  TYPE_COLOR,     { &conf.merge_cvsnt_color } },
155            { "arrow_width",        TYPE_NUMBER,    { &conf.arrow_width } },
156            { "arrow_length",       TYPE_NUMBER,    { &conf.arrow_length } },
157          { "tag_color",          TYPE_COLOR,     { &conf.tag_color } },          { "tag_color",          TYPE_COLOR,     { &conf.tag_color } },
158          { "tag_font",           TYPE_FONT,      { &conf.tag_font.gdfont } },          { "tag_font",           TYPE_FONT,      { &conf.tag_font.gdfont } },
159          { "tag_ttfont",         TYPE_STRING,    { &conf.tag_font.ttfont } },          { "tag_ttfont",         TYPE_STRING,    { &conf.tag_font.ttfont } },
160          { "tag_ttsize",         TYPE_DOUBLE,    { &conf.tag_font.ttsize } },          { "tag_ttsize",         TYPE_DOUBLE,    { &conf.tag_font.ttsize } },
161            { "tag_ignore",         TYPE_STRING,    { &conf.tag_ignore } },
162            { "tag_ignore_merge",   TYPE_BOOLEAN,   { &conf.tag_ignore_merge } },
163            { "tag_nocase",         TYPE_BOOLEAN,   { &conf.tag_nocase } },
164            { "tag_negate",         TYPE_BOOLEAN,   { &conf.tag_negate } },
165          { "title",              TYPE_STRING,    { &conf.title } },          { "title",              TYPE_STRING,    { &conf.title } },
166          { "title_x",            TYPE_NUMBER,    { &conf.title_x } },          { "title_x",            TYPE_NUMBER,    { &conf.title_x } },
167          { "title_y",            TYPE_NUMBER,    { &conf.title_y } },          { "title_y",            TYPE_NUMBER,    { &conf.title_y } },
# Line 155  Line 176 
176          { "margin_right",       TYPE_NUMBER,    { &conf.margin_right } },          { "margin_right",       TYPE_NUMBER,    { &conf.margin_right } },
177          { "image_type",         TYPE_NUMBER,    { &conf.image_type } },          { "image_type",         TYPE_NUMBER,    { &conf.image_type } },
178          { "image_quality",      TYPE_NUMBER,    { &conf.image_quality } },          { "image_quality",      TYPE_NUMBER,    { &conf.image_quality } },
179            { "image_compress",     TYPE_NUMBER,    { &conf.image_compress } },
180            { "image_interlace",    TYPE_BOOLEAN,   { &conf.image_interlace } },
181          { "map_name",           TYPE_STRING,    { &conf.map_name } },          { "map_name",           TYPE_STRING,    { &conf.map_name } },
182          { "map_branch_href",    TYPE_STRING,    { &conf.map_branch_href } },          { "map_branch_href",    TYPE_STRING,    { &conf.map_branch_href } },
183          { "map_branch_alt",     TYPE_STRING,    { &conf.map_branch_alt } },          { "map_branch_alt",     TYPE_STRING,    { &conf.map_branch_alt } },
# Line 162  Line 185 
185          { "map_rev_alt",        TYPE_STRING,    { &conf.map_rev_alt } },          { "map_rev_alt",        TYPE_STRING,    { &conf.map_rev_alt } },
186          { "map_diff_href",      TYPE_STRING,    { &conf.map_diff_href } },          { "map_diff_href",      TYPE_STRING,    { &conf.map_diff_href } },
187          { "map_diff_alt",       TYPE_STRING,    { &conf.map_diff_alt } },          { "map_diff_alt",       TYPE_STRING,    { &conf.map_diff_alt } },
188            { "map_merge_href",     TYPE_STRING,    { &conf.map_merge_href } },
189            { "map_merge_alt",      TYPE_STRING,    { &conf.map_merge_alt } },
190          { "jpeg",               TYPE_VALUE,     { (void *)IMAGE_JPEG } },          { "jpeg",               TYPE_VALUE,     { (void *)IMAGE_JPEG } },
191          { "png",                TYPE_VALUE,     { (void *)IMAGE_PNG } },          { "png",                TYPE_VALUE,     { (void *)IMAGE_PNG } },
192          { "gif",                TYPE_VALUE,     { (void *)IMAGE_GIF } },          { "gif",                TYPE_VALUE,     { (void *)IMAGE_GIF } },
# Line 529  Line 554 
554                                                  c[1] = get_input();                                                  c[1] = get_input();
555                                                  c[2] = '\0';                                                  c[2] = '\0';
556                                                  if(!isxdigit((int)(unsigned char)c[0]) || !isxdigit((int)(unsigned char)c[1]))                                                  if(!isxdigit((int)(unsigned char)c[0]) || !isxdigit((int)(unsigned char)c[1]))
557                                                          yyerror("Invalid hex escape");                                                          stack_msg(MSG_ERR, "config: %d: Invalid hex escape", line_number);
558                                                  add_str((int)strtol(c, NULL, 16));                                                  add_str((int)strtol(c, NULL, 16));
559                                                  break;                                                  break;
560                                          case '0':                                          case '0':
# Line 548  Line 573 
573                                                  add_str((int)strtol(c, NULL, 8));                                                  add_str((int)strtol(c, NULL, 8));
574                                                  break;                                                  break;
575                                          case EOF:                                          case EOF:
576                                                    yyerror("Unexpected EOF in escape");                                                  yyerror("Unexpected EOF in escape");
577                                                    break;                                                  break;
578                                          }                                          }
579                                          break;                                          break;
580                                  case '"':                                  case '"':
# Line 590  Line 615 
615                                  skw.keyword = get_str();                                  skw.keyword = get_str();
616                                  kw = bsearch(&skw, keywords, NKEYWORDS, sizeof(keywords[0]), cmp_kw);                                  kw = bsearch(&skw, keywords, NKEYWORDS, sizeof(keywords[0]), cmp_kw);
617                                  if(!kw)                                  if(!kw)
618                                          yyerror("Unknown keyword '%s'", skw.keyword);                                  {
619                                  xfree(skw.keyword);                                          stack_msg(MSG_ERR, "config: %d: Unknown keyword '%s'", line_number, skw.keyword);
620                                            yylval.kw = NULL;
621                                            return TYPE_KEYWORD;
622                                    }
623                                    xfree((void *)skw.keyword);
624                                  if(kw->type == TYPE_VALUE)                                  if(kw->type == TYPE_VALUE)
625                                  {                                  {
626                                          yylval.i = kw->confref.val;                                          yylval.i = (int)kw->confref.val;
627                                          return TYPE_NUMBER;                                          return TYPE_NUMBER;
628                                  }                                  }
629                                  yylval.kw = kw;                                  yylval.kw = kw;
# Line 626  Line 655 
655                                  {                                  {
656                                          yylval.d = strtod(s, &eptr);                                          yylval.d = strtod(s, &eptr);
657                                          if(*eptr)                                          if(*eptr)
658                                                  yyerror("Invalid floating point number");                                                  stack_msg(MSG_ERR, "config: %d: Invalid floating point number", line_number);
659                                  }                                  }
660                                  else                                  else
661                                  {                                  {
662                                          yylval.i = strtol(s, &eptr, 0);                                          yylval.i = strtol(s, &eptr, 0);
663                                          if(*eptr)                                          if(*eptr)
664                                                  yyerror("Invalid number");                                                  stack_msg(MSG_ERR, "config: %d: Invalid number", line_number);
665                                  }                                  }
666                                  xfree(s);                                  xfree(s);
667                                  return type;                                  return type;
# Line 650  Line 679 
679          if(*s != '#' || strlen(s) != 7)          if(*s != '#' || strlen(s) != 7)
680          {          {
681  colorerror:  colorerror:
682                  yyerror("Invalid color value");                  stack_msg(MSG_ERR, "config: %d: Invalid color value '%s'", line_number, s);
683                    return;
684          }          }
685          c->b = strtol(s+5, &cptr, 16);          c->b = strtol(s+5, &cptr, 16);
686          if(*cptr)          if(*cptr)
# Line 708  Line 738 
738                  if(token == EOF)                  if(token == EOF)
739                  {                  {
740                          if(state)                          if(state)
741                                  yyerror("Unexpected EOF");                                  stack_msg(MSG_ERR, "config: %d: Unexpected EOF", line_number);
742                          break;                          break;
743                  }                  }
744    
# Line 721  Line 751 
751                                  state = 1;                                  state = 1;
752                          }                          }
753                          else if(token != ';')                          else if(token != ';')
754                                  yyerror("Keyword expected");                                  stack_msg(MSG_ERR, "config: %d: Keyword expected", line_number);
755                          break;                          break;
756                  case 1:                  case 1:
757                          if(token != '=')                          if(token != '=')
758                                  yyerror("'=' expected");                          {
759                          state = 2;                                  stack_msg(MSG_ERR, "config: %d: '=' expected", line_number);
760                                    while(1)
761                                    {
762                                            token = config_lex();
763                                            if(token == ';')
764                                            {
765                                                    state = 0;
766                                                    break;
767                                            }
768                                            else if(token == EOF)
769                                                    break;
770                                    }
771                            }
772                            else
773                                    state = 2;
774                          break;                          break;
775                  case 2:                  case 2:
776                            if(!kw)
777                            {
778                                    /* Error recovery of failed keyword */
779                                    state = 3;
780                                    break;
781                            }
782                          if(kw->type == TYPE_FONT || kw->type == TYPE_BOOLEAN)                          if(kw->type == TYPE_FONT || kw->type == TYPE_BOOLEAN)
783                                  t = TYPE_NUMBER;                                  t = TYPE_NUMBER;
784                          else if(kw->type == TYPE_COLOR)                          else if(kw->type == TYPE_COLOR || kw->type == TYPE_COLORLIST || kw->type == TYPE_STRINGLIST)
785                                  t = TYPE_STRING;                                  t = TYPE_STRING;
786                          else                          else
787                                  t = kw->type;                                  t = kw->type;
# Line 748  Line 798 
798                                  char *e;                                  char *e;
799                                  switch(kw->type)                                  switch(kw->type)
800                                  {                                  {
801                                  case TYPE_STRING:       e = "String"; break;                                  case TYPE_STRING:       e = "String"; yylval.str = xstrdup("error recovery"); break;
802                                  case TYPE_NUMBER:       e = "Number"; break;                                  case TYPE_STRINGLIST:   e = "StringL"; yylval.str = xstrdup("error recovery"); break;
803                                  case TYPE_COLOR:        e = "Color"; break;                                  case TYPE_NUMBER:       e = "Number"; yylval.i = 0; break;
804                                  case TYPE_FONT:         e = "Font"; break;                                  case TYPE_COLOR:        e = "Color"; yylval.str = xstrdup("#123456"); break;
805                                  case TYPE_BOOLEAN:      e = "Boolean"; break;                                  case TYPE_COLORLIST:    e = "ColorL"; yylval.str = xstrdup("#123456"); break;
806                                  case TYPE_DOUBLE:       e = "Double"; break;                                  case TYPE_FONT:         e = "Font"; yylval.i = 0; break;
807                                  default:                e = "Internal error: Unknown type"; break;                                  case TYPE_BOOLEAN:      e = "Boolean"; yylval.i = 0; break;
808                                    case TYPE_DOUBLE:       e = "Double"; yylval.d = 0.0; break;
809                                    default:                e = "Internal error: Unknown type"; yylval.i = 0; break;
810                                  }                                  }
811                                  yyerror("%s expected", e);                                  stack_msg(MSG_ERR, "config: %d: %s expected", line_number, e);
812                          }                          }
813  #ifdef DEBUG  #ifdef DEBUG
814                          printf("processing: '%s'\n", kw->keyword);                          printf("processing: '%s'\n", kw->keyword);
# Line 766  Line 818 
818                                  case TYPE_STRING:                                  case TYPE_STRING:
819                                          *kw->confref.s = yylval.str;                                          *kw->confref.s = yylval.str;
820                                          break;                                          break;
821                                    case TYPE_STRINGLIST:
822                                            kw->confref.sl->strs = xrealloc(kw->confref.sl->strs, sizeof(*kw->confref.sl->strs) * (kw->confref.sl->n + 1));
823                                            kw->confref.sl->strs[kw->confref.sl->n] = yylval.str;
824                                            kw->confref.sl->n++;
825                                            break;
826                                  case TYPE_NUMBER:                                  case TYPE_NUMBER:
827                                          *kw->confref.i = yylval.i;                                          *kw->confref.i = yylval.i;
828                                          break;                                          break;
# Line 778  Line 835 
835                                  case TYPE_COLOR:                                  case TYPE_COLOR:
836                                          set_color(kw->confref.c, yylval.str);                                          set_color(kw->confref.c, yylval.str);
837                                          break;                                          break;
838                                    case TYPE_COLORLIST:
839                                            kw->confref.cl->clrs = xrealloc(kw->confref.cl->clrs, sizeof(*kw->confref.cl->clrs) * (kw->confref.cl->n + 1));
840                                            set_color(&kw->confref.cl->clrs[kw->confref.cl->n], yylval.str);
841                                            kw->confref.cl->n++;
842                                            break;
843                                  case TYPE_FONT:                                  case TYPE_FONT:
844                                          kw->confref.f->gdfont = get_font(yylval.i);                                          kw->confref.f->gdfont = get_font(yylval.i);
845                                          break;                                          break;
# Line 792  Line 854 
854                          break;                          break;
855                  case 3:                  case 3:
856                          if(token != ';')                          if(token != ';')
857                                  yyerror("';' expected");                                  stack_msg(MSG_ERR, "config: %d: ';' expected", line_number);
858                          state = 0;                          state = 0;
859                          break;                          break;
860                  default:                  default:
# Line 866  Line 928 
928                  }                  }
929                  input_file = NULL;                  input_file = NULL;
930          }          }
931    
932            if(conf.merge_from.n != conf.merge_to.n)
933            {
934                    int x = conf.merge_from.n < conf.merge_to.n ? conf.merge_from.n : conf.merge_to.n;
935                    stack_msg(MSG_ERR, "config: merge_from(n=%d) does not match merge_to(n=%d)", conf.merge_from.n, conf.merge_to.n);
936                    conf.merge_from.n = x;
937                    conf.merge_to.n = x;
938            }
939            if(conf.merge_color.n < conf.merge_from.n)
940            {
941                    /* Silently extend missing merge_color statements with black */
942                    int x;
943                    char c[] = "#000000";
944                    for(x = conf.merge_color.n; x < conf.merge_from.n; x++)
945                    {
946                            conf.merge_color.clrs = xrealloc(conf.merge_color.clrs, sizeof(*conf.merge_color.clrs) * (conf.merge_color.n + 1));
947                            set_color(&conf.merge_color.clrs[conf.merge_color.n], c);
948                            conf.merge_color.n++;
949                    }
950            }
951    
952  #ifdef DEBUG  #ifdef DEBUG
953          dump_config();          dump_config();
954  #endif  #endif
955  }  }
956    
957    /*
958     **************************************************************************
959     * Color reference by name for late-binding color allocation
960     **************************************************************************
961     */
962    color_t *get_colorref(const char *confcolor, int idx)
963    {
964            keyword_t skw;
965            keyword_t *kw;
966    
967            assert(confcolor != NULL);
968    
969            skw.keyword = confcolor;
970            kw = bsearch(&skw, keywords, NKEYWORDS, sizeof(keywords[0]), cmp_kw);
971            if(!kw || (kw->type != TYPE_COLOR && kw->type != TYPE_COLORLIST))
972                    return NULL;
973            if(kw->type == TYPE_COLORLIST)
974            {
975                    if(idx >= kw->confref.cl->n)
976                            return NULL;
977                    return &kw->confref.cl->clrs[idx];
978            }
979            return kw->confref.c;
980    }

Legend:
Removed from v.1.11  
changed lines
  Added in v.1.23

  ViewVC Help
Powered by ViewVC 1.1.0 with CvsGraph 1.7.0