/[CvsGraph]/cvsgraph/rcsy.y
ViewVC logotype

Diff of /cvsgraph/rcsy.y

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

revision 1.2, Fri Nov 30 11:05:20 2001 UTC revision 1.8, Wed Oct 20 19:31:10 2004 UTC
# Line 20  Line 20 
20   */   */
21    
22  %{  %{
23    #define YYERROR_VERBOSE 1
24    
25  #include <stdio.h>  #include <stdio.h>
26  #include <stdlib.h>  #include <stdlib.h>
27  #include <string.h>  #include <string.h>
28  #include <assert.h>  #include <assert.h>
29    
30    #include <gd.h>         /* For gdFontPtr in cvsgraph.h */
31    #include "cvsgraph.h"
32  #include "utils.h"  #include "utils.h"
33  #include "rcs.h"  #include "rcs.h"
34    
# Line 74  Line 78 
78  %token <str> tSTRING tREV tID tSYM  %token <str> tSTRING tREV tID tSYM
79    
80    
81  %type <str>     ostr orev oid obranch ocomment oexpand desc  %type <str>     ostr orev oid obranch ocomment oexpand desc idorstr
82  %type <tag>     tag  %type <tag>     tag
83  %type <tags>    tags otags  %type <tags>    tags otags
84  %type <idrev>   idrev  %type <idrev>   idrev
# Line 89  Line 93 
93  %type <rcsfile> admin  %type <rcsfile> admin
94    
95  %%  %%
96  rcsfile : admin deltas desc dtexts      {  rcsfile : admin deltas desc {
97                  rcsfile = $1;                  rcsfile = $1;
98                  rcsfile->deltas = $2;                  rcsfile->deltas = $2;
99                  rcsfile->desc = $3;                  rcsfile->desc = $3;
100                  rcsfile->dtexts = $4;                  rcsfile->dtexts = NULL;
101                  if(rcsfile->head)                  if(rcsfile->head)
102                  {                  {
103                          char *h = xstrdup("HEAD");                          char *h = xstrdup("HEAD");
104                          char *r = xstrdup(rcsfile->head->rev);                          char *r = xstrdup(rcsfile->head->rev);
105                          tag_t *t = new_tag(h, r);                          tag_t *t = new_tag(h, r);
106                            t->ignore = -1; /* Make sure it doesn't get zapped */
107                          rcsfile->tags = add_tags(rcsfile->tags, t);                          rcsfile->tags = add_tags(rcsfile->tags, t);
108                  }                  }
109                  if(rcsfile->branch)                  if(rcsfile->branch)
# Line 113  Line 118 
118                   * trunk is reversed in order and the primary revision                   * trunk is reversed in order and the primary revision
119                   * numbers can vary.                   * numbers can vary.
120                   */                   */
121                    if(!conf.parse_logs)
122                    {
123                            /* Return from the yyparse() call early to avoid parsing
124                             * of the possibly extremely large deltatext. This speeds
125                             * up parsing of binary files by a very large factor.
126                             */
127                            return 0;
128                  }                  }
129          | error { yyerror("Parse error in RCS file"); }                  }
130    
131                    /* This is trailing deltatext context and possibly ignored */
132                    dtexts  { rcsfile->dtexts = $5; }
133          ;          ;
134    
135  admin   : tHEAD orev ';'  admin   : tHEAD orev ';'
# Line 149  Line 164 
164    
165  delta   : tREV  delta   : tREV
166            tDATE tREV ';'            tDATE tREV ';'
167            tAUTHOR { set_id(); } tID ';'            tAUTHOR { set_author(); } idorstr ';'
168            tSTATE  { set_id(); } oid ';'            tSTATE  { set_id(); } oid ';'
169            tBRANCHES orevs ';'            tBRANCHES orevs ';'
170            tNEXT orev ';'            tNEXT orev ';'
171            ophrases                      { $$ = new_delta($1, $3, $7, $11, $14, $17); }            ophrases                      { $$ = new_delta($1, $3, $7, $11, $14, $17); }
172          ;          ;
173    
174    idorstr : tID                           { $$ = $1; }
175            | tSTRING                       { $$ = $1; }
176            ;
177    
178  desc    : tDESC tSTRING                 { $$ = $2; }  desc    : tDESC tSTRING                 { $$ = $2; }
179          ;          ;
180    
# Line 236  Line 255 
255          | tags                          { $$ = $1; }          | tags                          { $$ = $1; }
256          ;          ;
257    
258  tags    : tag                           { $$ = new_tags($1); }  tags    : tag                           { if($1) $$ = new_tags($1); else $$ = NULL; }
259          | tags tag                      { $$ = add_tags($1, $2); }          | tags tag                      { if($1 && $2) $$ = add_tags($1, $2); else if($2) $$ = new_tags($2); else $$ = $1; }
260          ;          ;
261    
262  tag     : tSYM ':' tREV                 { set_sym(); $$ = new_tag($1, $3); }  tag     : tSYM ':' tREV                 { set_sym(); $$ = new_tag($1, $3); }
263     /* Zap the additional tag-info from CVSNT */
264     /* This is a bit of a hack, but it is necessary to do like this */
265     /* because the parser is not allowed to do any look-ahead on ':'. */
266     /* Otherwise, we would have a tNEWPHRASE hit because we cannot set */
267     /* set_sym() before the lexer gets the next token. */
268            | ':' tREV ':' tSTRING          { set_sym(); $$ = NULL; }
269          ;          ;
270    
271  %%  %%
272  static rev_t *make_rev(char *s)  static rev_t *make_rev(char *s, int isrev)
273  {  {
274          char *cptr;          char *cptr;
275          int dots = 0;          int dots = 0;
# Line 280  Line 305 
305                  assert(cptr != NULL);                  assert(cptr != NULL);
306                  *cptr = '\0';                  *cptr = '\0';
307                  t = strrchr(r->branch, '.');                  t = strrchr(r->branch, '.');
308                  if((t&& !strcmp(t+1, "0")) || (!t && !strcmp(r->branch, "0")))                  if(!isrev && ((t && !strcmp(t+1, "0")) || (!t && !strcmp(r->branch, "0"))))
309                  {                  {
310                          /* Magic branch numbers "x.x.0.x" */                          /* Magic branch numbers "x.x.0.x" */
311                          r->isbranch = 1;                          r->isbranch = 1;
# Line 306  Line 331 
331  {  {
332          tag_t *t = xmalloc(sizeof(*t));          tag_t *t = xmalloc(sizeof(*t));
333          t->tag = s;          t->tag = s;
334          t->rev = make_rev(r);          t->rev = make_rev(r, 0);
335          return t;          return t;
336  }  }
337    
# Line 333  Line 358 
358  {  {
359          idrev_t *t = xmalloc(sizeof(*t));          idrev_t *t = xmalloc(sizeof(*t));
360          t->id = s;          t->id = s;
361          t->rev = make_rev(r);          t->rev = make_rev(r, 1);
362          return t;          return t;
363  }  }
364    
# Line 378  Line 403 
403          revs_t *t = xmalloc(sizeof(*t));          revs_t *t = xmalloc(sizeof(*t));
404          t->nrevs = 1;          t->nrevs = 1;
405          t->revs = xmalloc(sizeof(t->revs[0]));          t->revs = xmalloc(sizeof(t->revs[0]));
406          t->revs[0] = make_rev(s);          t->revs[0] = make_rev(s, 1);
407          return t;          return t;
408  }  }
409    
410  static revs_t *add_revs(revs_t *s, char *t)  static revs_t *add_revs(revs_t *s, char *t)
411  {  {
412          s->revs = xrealloc(s->revs, (s->nrevs+1) * sizeof(s->revs[0]));          s->revs = xrealloc(s->revs, (s->nrevs+1) * sizeof(s->revs[0]));
413          s->revs[s->nrevs] = make_rev(t);          s->revs[s->nrevs] = make_rev(t, 1);
414          s->nrevs++;          s->nrevs++;
415          return s;          return s;
416  }  }
# Line 393  Line 418 
418  static dtext_t *new_dtext(char *n, char *l, char *t)  static dtext_t *new_dtext(char *n, char *l, char *t)
419  {  {
420          dtext_t *d = xmalloc(sizeof(*d));          dtext_t *d = xmalloc(sizeof(*d));
421          d->rev = make_rev(n);          d->rev = make_rev(n, 1);
422          d->log = l;          d->log = l;
423          d->text = t;          d->text = t;
424          return d;          return d;
# Line 412  Line 437 
437  static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next)  static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next)
438  {  {
439          delta_t *d = xmalloc(sizeof(*d));          delta_t *d = xmalloc(sizeof(*d));
440          d->rev = make_rev(rev);          d->rev = make_rev(rev, 1);
441          d->date = date;          d->date = date;
442          d->author = author;          d->author = author;
443          d->state = state;          d->state = state;
444          d->branches = branches;          d->branches = branches;
445          d->next = make_rev(next);          d->next = make_rev(next, 1);
446          return d;          return d;
447  }  }
448    
# Line 435  Line 460 
460                                  idrevs_t *locks, int strict, char *comment, char *expand)                                  idrevs_t *locks, int strict, char *comment, char *expand)
461  {  {
462          rcsfile_t *r = xmalloc(sizeof(*r));          rcsfile_t *r = xmalloc(sizeof(*r));
463          r->head = make_rev(head);          r->head = make_rev(head, 1);
464          r->branch = make_rev(branch);          r->branch = make_rev(branch, 0);
465          r->access = access;          r->access = access;
466          r->tags = tags;          r->tags = tags;
467          r->locks = locks;          r->locks = locks;

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.8

  ViewVC Help
Powered by ViewVC 1.1.0 with CvsGraph 1.7.0