/[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.12, Mon Jun 13 20:57:27 2005 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 42  Line 46 
46  static revs_t *add_revs(revs_t *s, char *t);  static revs_t *add_revs(revs_t *s, char *t);
47  static dtext_t *new_dtext(char *n, char *l, char *t);  static dtext_t *new_dtext(char *n, char *l, char *t);
48  static dtexts_t *add_dtexts(dtexts_t *s, dtext_t *t);  static dtexts_t *add_dtexts(dtexts_t *s, dtext_t *t);
49  static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next);  static phrase_t *new_phrase(phrase_type_e pt, char *t);
50    static phrases_t *add_phrases(phrases_t *s, phrase_t *t);
51    static phrases_t *merge_phrases(phrases_t *s, phrases_t *t);
52    static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next, phrases_t *phrases);
53  static deltas_t *add_deltas(deltas_t *s, delta_t *t);  static deltas_t *add_deltas(deltas_t *s, delta_t *t);
54  static rcsfile_t *new_rcsfile(char *head, char *branch, ids_t *access, tags_t *tags,  static rcsfile_t *new_rcsfile(char *head, char *branch, ids_t *access, tags_t *tags,
55                                  idrevs_t *locks, int strict, char *comment, char *expand);                                  idrevs_t *locks, int strict, char *comment, char *expand);
# Line 63  Line 70 
70          delta_t         *delta;          delta_t         *delta;
71          deltas_t        *deltas;          deltas_t        *deltas;
72          rcsfile_t       *rcsfile;          rcsfile_t       *rcsfile;
73            phrases_t       *phrases;
74            phrase_t        *phrase;
75  }  }
76    
77  %token tHEAD tBRANCH tACCESS tSYMBOLS tLOCKS tSTRICT tCOMMENT  %token tHEAD tBRANCH tACCESS tSYMBOLS tLOCKS tSTRICT tCOMMENT
78  %token tEXPAND tDATE tAUTHOR tSTATE tBRANCHES tNEXT  %token tEXPAND tDATE tAUTHOR tSTATE tBRANCHES tNEXT
79  %token tDESC tLOG tTEXT  %token tDESC tLOG tTEXT
80  %token tOWNER tGROUP tPERMISSIONS tSPECIAL tSYMLINK tHARDLINKS  %token tOWNER tGROUP tPERMISSIONS tSPECIAL tSYMLINK tHARDLINKS
81  %token tNAMESPACE tDEAD  %token tNAMESPACE tDEAD tMERGEPOINT
82    %token tDELTATYPE tCOMMITID tKOPT tFILENAME tPROPERTIES
83  %token <str> tNEWPHRASE  %token <str> tNEWPHRASE
84  %token <str> tSTRING tREV tID tSYM  %token <str> tSTRING tREV tID tSYM
85    
86    
87  %type <str>     ostr orev oid obranch ocomment oexpand desc  %type <str>     ostr orev oid obranch ocomment oexpand desc idorstr
88  %type <tag>     tag  %type <tag>     tag
89  %type <tags>    tags otags  %type <tags>    tags otags
90  %type <idrev>   idrev  %type <idrev>   idrev
# Line 87  Line 97 
97  %type <delta>   delta  %type <delta>   delta
98  %type <deltas>  deltas  %type <deltas>  deltas
99  %type <rcsfile> admin  %type <rcsfile> admin
100    %type <phrases> ophrases
101    %type <phrase>  phrase
102    
103  %%  %%
104  rcsfile : admin deltas desc dtexts      {  rcsfile : admin deltas desc {
105                  rcsfile = $1;                  rcsfile = $1;
106                  rcsfile->deltas = $2;                  rcsfile->deltas = $2;
107                  rcsfile->desc = $3;                  rcsfile->desc = $3;
108                  rcsfile->dtexts = $4;                  rcsfile->dtexts = NULL;
109                  if(rcsfile->head)                  if(rcsfile->head)
110                  {                  {
111                          char *h = xstrdup("HEAD");                          char *h = xstrdup("HEAD");
112                          char *r = xstrdup(rcsfile->head->rev);                          char *r = xstrdup(rcsfile->head->rev);
113                          tag_t *t = new_tag(h, r);                          tag_t *t = new_tag(h, r);
114                            t->ignore = -1; /* Make sure it doesn't get zapped */
115                          rcsfile->tags = add_tags(rcsfile->tags, t);                          rcsfile->tags = add_tags(rcsfile->tags, t);
116                  }                  }
117                  if(rcsfile->branch)                  if(rcsfile->branch)
# Line 113  Line 126 
126                   * trunk is reversed in order and the primary revision                   * trunk is reversed in order and the primary revision
127                   * numbers can vary.                   * numbers can vary.
128                   */                   */
129                    if(!conf.parse_logs)
130                    {
131                            /* Return from the yyparse() call early to avoid parsing
132                             * of the possibly extremely large deltatext. This speeds
133                             * up parsing of binary files by a very large factor.
134                             */
135                            return 0;
136                  }                  }
137          | error { yyerror("Parse error in RCS file"); }                  }
138    
139                    /* This is trailing deltatext context and possibly ignored */
140                    dtexts  { rcsfile->dtexts = $5; }
141          ;          ;
142    
143  admin   : tHEAD orev ';'  admin   : tHEAD orev ';'
# Line 149  Line 172 
172    
173  delta   : tREV  delta   : tREV
174            tDATE tREV ';'            tDATE tREV ';'
175            tAUTHOR { set_id(); } tID ';'            tAUTHOR { set_author(); } idorstr ';'
176            tSTATE  { set_id(); } oid ';'            tSTATE  { set_id(); } oid ';'
177            tBRANCHES orevs ';'            tBRANCHES orevs ';'
178              ophrases
179            tNEXT orev ';'            tNEXT orev ';'
180            ophrases                      { $$ = new_delta($1, $3, $7, $11, $14, $17); }            ophrases                      { $$ = new_delta($1, $3, $7, $11, $14, $18, merge_phrases($16, $20)); }
181            ;
182    
183    idorstr : tID                           { $$ = $1; }
184            | tSTRING                       { $$ = $1; }
185          ;          ;
186    
187  desc    : tDESC tSTRING                 { $$ = $2; }  desc    : tDESC tSTRING                 { $$ = $2; }
# Line 169  Line 197 
197            tTEXT { set_skipstr(); } tSTRING { $$ = new_dtext($1, $3, $7); }            tTEXT { set_skipstr(); } tSTRING { $$ = new_dtext($1, $3, $7); }
198          ;          ;
199    
200  ophrases: /* Empty */  ophrases: /* Empty */           { $$ = NULL; }
201          | ophrases phrase          | ophrases phrase       { $$ = add_phrases($1, $2); }
202          ;          ;
203    
204  phrase  : tNEWPHRASE { set_skip(); } ';'        {  phrase  : tNEWPHRASE { set_skip(); } ';'        {
205                  yywarning("Unrecognised `newphrase´ keyword '%s' skipped", $1);                  yywarning("Unrecognised `newphrase´ keyword '%s' skipped", $1);
206                  xfree($1);                  xfree($1);
207                    $$ = NULL;
208                  }                  }
209          | cvskw { set_skip(); } ';'     { yywarning("CVS extended keyword skipped"); }          | cvskw { set_skip(); } ';'     { $$ = NULL; /* yywarning("CVS extended keyword skipped"); */ }
210          | otherkw { set_skip(); } ';'   { yywarning("Other extended keyword"); }          | otherkw { set_skip(); } ';'   { $$ = NULL; /* yywarning("Other extended keyword"); */ }
211            | tMERGEPOINT tSTRING ';'       { $$ = new_phrase(PT_MERGEPOINT, $2); }
212            | tMERGEPOINT tREV ';'          { $$ = new_phrase(PT_MERGEPOINT, $2); }
213          ;          ;
214    
215  cvskw   : tOWNER  cvskw   : tOWNER
# Line 191  Line 222 
222    
223  otherkw : tNAMESPACE  otherkw : tNAMESPACE
224          | tDEAD          | tDEAD
225            | tDELTATYPE
226            | tCOMMITID
227            | tKOPT
228            | tFILENAME
229            | tPROPERTIES
230          ;          ;
231    
232  ostr    : /* Empty */                   { $$ = NULL; }  ostr    : /* Empty */                   { $$ = NULL; }
# Line 236  Line 272 
272          | tags                          { $$ = $1; }          | tags                          { $$ = $1; }
273          ;          ;
274    
275  tags    : tag                           { $$ = new_tags($1); }  tags    : tag                           { if($1) $$ = new_tags($1); else $$ = NULL; }
276          | tags tag                      { $$ = add_tags($1, $2); }          | tags tag                      { if($1 && $2) $$ = add_tags($1, $2); else if($2) $$ = new_tags($2); else $$ = $1; }
277          ;          ;
278    
279  tag     : tSYM ':' tREV                 { set_sym(); $$ = new_tag($1, $3); }  tag     : tSYM ':' tREV                 { set_sym(); $$ = new_tag($1, $3); }
280     /* Zap the additional tag-info from CVSNT */
281     /* This is a bit of a hack, but it is necessary to do like this */
282     /* because the parser is not allowed to do any look-ahead on ':'. */
283     /* Otherwise, we would have a tNEWPHRASE hit because we cannot set */
284     /* set_sym() before the lexer gets the next token. */
285            | ':' tREV ':' tSTRING          { set_sym(); $$ = NULL; }
286          ;          ;
287    
288  %%  %%
289  static rev_t *make_rev(char *s)  static rev_t *make_rev(char *s, int isrev)
290  {  {
291          char *cptr;          char *cptr;
292          int dots = 0;          int dots = 0;
# Line 280  Line 322 
322                  assert(cptr != NULL);                  assert(cptr != NULL);
323                  *cptr = '\0';                  *cptr = '\0';
324                  t = strrchr(r->branch, '.');                  t = strrchr(r->branch, '.');
325                  if((t&& !strcmp(t+1, "0")) || (!t && !strcmp(r->branch, "0")))                  if(!isrev && ((t && !strcmp(t+1, "0")) || (!t && !strcmp(r->branch, "0"))))
326                  {                  {
327                          /* Magic branch numbers "x.x.0.x" */                          /* Magic branch numbers "x.x.0.x" */
328                          r->isbranch = 1;                          r->isbranch = 1;
# Line 306  Line 348 
348  {  {
349          tag_t *t = xmalloc(sizeof(*t));          tag_t *t = xmalloc(sizeof(*t));
350          t->tag = s;          t->tag = s;
351          t->rev = make_rev(r);          t->rev = make_rev(r, 0);
352          return t;          return t;
353  }  }
354    
# Line 333  Line 375 
375  {  {
376          idrev_t *t = xmalloc(sizeof(*t));          idrev_t *t = xmalloc(sizeof(*t));
377          t->id = s;          t->id = s;
378          t->rev = make_rev(r);          t->rev = make_rev(r, 1);
379          return t;          return t;
380  }  }
381    
# Line 378  Line 420 
420          revs_t *t = xmalloc(sizeof(*t));          revs_t *t = xmalloc(sizeof(*t));
421          t->nrevs = 1;          t->nrevs = 1;
422          t->revs = xmalloc(sizeof(t->revs[0]));          t->revs = xmalloc(sizeof(t->revs[0]));
423          t->revs[0] = make_rev(s);          t->revs[0] = make_rev(s, 1);
424          return t;          return t;
425  }  }
426    
427  static revs_t *add_revs(revs_t *s, char *t)  static revs_t *add_revs(revs_t *s, char *t)
428  {  {
429          s->revs = xrealloc(s->revs, (s->nrevs+1) * sizeof(s->revs[0]));          s->revs = xrealloc(s->revs, (s->nrevs+1) * sizeof(s->revs[0]));
430          s->revs[s->nrevs] = make_rev(t);          s->revs[s->nrevs] = make_rev(t, 1);
431          s->nrevs++;          s->nrevs++;
432          return s;          return s;
433  }  }
# Line 393  Line 435 
435  static dtext_t *new_dtext(char *n, char *l, char *t)  static dtext_t *new_dtext(char *n, char *l, char *t)
436  {  {
437          dtext_t *d = xmalloc(sizeof(*d));          dtext_t *d = xmalloc(sizeof(*d));
438          d->rev = make_rev(n);          d->rev = make_rev(n, 1);
439          d->log = l;          d->log = l;
440          d->text = t;          d->text = t;
441          return d;          return d;
# Line 409  Line 451 
451          return s;          return s;
452  }  }
453    
454  static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next)  static phrase_t *new_phrase(phrase_type_e pt, char *t)
455    {
456            phrase_t *d = xmalloc(sizeof(*d));
457            d->type = pt;
458            d->rev = make_rev(t, 1);
459            return d;
460    }
461    
462    static phrases_t *add_phrases(phrases_t *s, phrase_t *t)
463    {
464            if(!t)
465                    return s;
466            if(!s)
467                    s = xmalloc(sizeof(*s));
468            if(t)
469            {
470                    s->phrases = xrealloc(s->phrases, (s->nphrases + 1) * sizeof(s->phrases[0]));
471                    s->phrases[s->nphrases] = t;
472                    s->nphrases++;
473            }
474            return s;
475    }
476    
477    static phrases_t *merge_phrases(phrases_t *s, phrases_t *t)
478    {
479            if(!t)
480                    return s;
481            if(!s)
482                    return t;
483            s->phrases = xrealloc(s->phrases, (s->nphrases + t->nphrases) * sizeof(s->phrases[0]));
484            memcpy(&s->phrases[s->nphrases], &t->phrases[0], t->nphrases * sizeof(t->phrases[0]));
485            s->nphrases += t->nphrases;
486            /* FIXME: Free t and content; hm, who cares... */
487            return s;
488    }
489    
490    static phrase_t *find_mergepoint(phrases_t *p)
491    {
492            int i;
493    
494            if(!p)
495                    return NULL;
496    
497            for(i = 0; i < p->nphrases; i++)
498            {
499                    if(p->phrases[i]->type == PT_MERGEPOINT)
500                            return p->phrases[i];
501            }
502            return NULL;
503    }
504    
505    static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next, phrases_t *phrases)
506  {  {
507          delta_t *d = xmalloc(sizeof(*d));          delta_t *d = xmalloc(sizeof(*d));
508          d->rev = make_rev(rev);          d->rev = make_rev(rev, 1);
509          d->date = date;          d->date = date;
510          d->author = author;          d->author = author;
511          d->state = state;          d->state = state;
512          d->branches = branches;          d->branches = branches;
513          d->next = make_rev(next);          d->next = make_rev(next, 1);
514            d->phrases = phrases;
515            d->mergepoint = find_mergepoint(phrases);
516          return d;          return d;
517  }  }
518    
# Line 435  Line 530 
530                                  idrevs_t *locks, int strict, char *comment, char *expand)                                  idrevs_t *locks, int strict, char *comment, char *expand)
531  {  {
532          rcsfile_t *r = xmalloc(sizeof(*r));          rcsfile_t *r = xmalloc(sizeof(*r));
533          r->head = make_rev(head);          r->head = make_rev(head, 1);
534          r->branch = make_rev(branch);          r->branch = make_rev(branch, 0);
535          r->access = access;          r->access = access;
536          r->tags = tags;          r->tags = tags;
537          r->locks = locks;          r->locks = locks;

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

  ViewVC Help
Powered by ViewVC 1.1.0 with CvsGraph 1.7.0