CvsGraph/cvsgraph/rcsy.y

/*
 * CvsGraph graphical representation generator of brances and revisions
 * of a file in cvs/rcs.
 *
 * Copyright (C) 2001  B. Stultiens
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

%{
#define YYERROR_VERBOSE	1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include <gd.h>		/* For gdFontPtr in cvsgraph.h */
#include "cvsgraph.h"
#include "utils.h"
#include "rcs.h"

rcsfile_t *rcsfile;

static tag_t *new_tag(char *s, char *r);
static tags_t *new_tags(tag_t *s);
static tags_t *add_tags(tags_t *s, tag_t *t);
static idrev_t *new_idrev(char *s, char *r);
static idrevs_t *new_idrevs(idrev_t *s);
static idrevs_t *add_idrevs(idrevs_t *s, idrev_t *t);
static ids_t *new_ids(char *s);
static ids_t *add_ids(ids_t *s, char *t);
static revs_t *new_revs(char *s);
static revs_t *add_revs(revs_t *s, char *t);
static dtext_t *new_dtext(char *n, char *l, char *t);
static dtexts_t *add_dtexts(dtexts_t *s, dtext_t *t);
static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next);
static deltas_t *add_deltas(deltas_t *s, delta_t *t);
static rcsfile_t *new_rcsfile(char *head, char *branch, ids_t *access, tags_t *tags,
				idrevs_t *locks, int strict, char *comment, char *expand);

%}

%union{
	int		i;
	char		*str;
	tag_t		*tag;
	tags_t		*tags;
	idrev_t		*idrev;
	idrevs_t	*idrevs;
	ids_t		*ids;
	revs_t		*revs;
	dtext_t		*dtext;
	dtexts_t	*dtexts;
	delta_t		*delta;
	deltas_t	*deltas;
	rcsfile_t	*rcsfile;
}

%token tHEAD tBRANCH tACCESS tSYMBOLS tLOCKS tSTRICT tCOMMENT
%token tEXPAND tDATE tAUTHOR tSTATE tBRANCHES tNEXT
%token tDESC tLOG tTEXT
%token tOWNER tGROUP tPERMISSIONS tSPECIAL tSYMLINK tHARDLINKS
%token tNAMESPACE tDEAD
%token <str> tNEWPHRASE
%token <str> tSTRING tREV tID tSYM


%type <str>	ostr orev oid obranch ocomment oexpand desc idorstr
%type <tag>	tag
%type <tags>	tags otags
%type <idrev>	idrev
%type <idrevs>	idrevs oidrevs
%type <ids>	ids oids
%type <revs>	revs orevs
%type <i>	ostrict
%type <dtext>	dtext
%type <dtexts>	dtexts
%type <delta>	delta
%type <deltas>	deltas
%type <rcsfile>	admin

%%
rcsfile	: admin deltas desc {
		rcsfile = $1;
		rcsfile->deltas = $2;
		rcsfile->desc = $3;
		rcsfile->dtexts = NULL;
		if(rcsfile->head)
		{
			char *h = xstrdup("HEAD");
			char *r = xstrdup(rcsfile->head->rev);
			tag_t *t = new_tag(h, r);
			t->ignore = -1;	/* Make sure it doesn't get zapped */
			rcsfile->tags = add_tags(rcsfile->tags, t);
		}
		if(rcsfile->branch)
		{
			char *h = xstrdup("MAIN");
			char *r = xstrdup(rcsfile->branch->rev);
			tag_t *t = new_tag(h, r);
			t->rev->isbranch = 1;
			rcsfile->tags = add_tags(rcsfile->tags, t);
		}
		/* Else we need to add the main tag later because the
		 * trunk is reversed in order and the primary revision
		 * numbers can vary.
		 */
		if(!conf.parse_logs)
		{
			/* Return from the yyparse() call early to avoid parsing
			 * of the possibly extremely large deltatext. This speeds
			 * up parsing of binary files by a very large factor.
			 */
			return 0;
		}
		}

		/* This is trailing deltatext context and possibly ignored */
		dtexts	{ rcsfile->dtexts = $5; }
	;

admin	: tHEAD orev ';'
	  obranch
	  tACCESS  { set_id(); } oids ';'
	  tSYMBOLS { set_sym(); } otags ';'
	  tLOCKS { set_id(); } oidrevs ';' ostrict
	  ocomment
	  oexpand
	  ophrases			{ $$ = new_rcsfile($2, $4, $7, $11, $15, $17, $18, $19); }
	;

ostrict	: /* Empty */			{ $$ = 0; }
	| tSTRICT ';'			{ $$ = 1; }
	;

obranch	: /* Empty */			{ $$ = NULL; }
	| tBRANCH orev ';'		{ $$ = $2; }
	;

ocomment: /* Empty */			{ $$ = NULL; }
	| tCOMMENT ostr ';'		{ $$ = $2; }
	;

oexpand	: /* Empty */			{ $$ = NULL; }
	| tEXPAND ostr ';'		{ $$ = $2; }
	;

deltas	: /* Empty */			{ $$ = NULL; }
	| deltas delta			{ $$ = add_deltas($1, $2); }
	;

delta	: tREV
	  tDATE tREV ';'
	  tAUTHOR { set_author(); } idorstr ';'
	  tSTATE  { set_id(); } oid ';'
	  tBRANCHES orevs ';'
	  tNEXT orev ';'
	  ophrases			{ $$ = new_delta($1, $3, $7, $11, $14, $17); }
	;

idorstr	: tID				{ $$ = $1; }
	| tSTRING			{ $$ = $1; }
	;

desc	: tDESC tSTRING			{ $$ = $2; }
	;

dtexts	: /* Empty */			{ $$ = NULL; }
	| dtexts dtext			{ $$ = add_dtexts($1, $2); }
	;

dtext	: tREV
	  tLOG tSTRING
	  ophrases
	  tTEXT { set_skipstr(); } tSTRING { $$ = new_dtext($1, $3, $7); }
	;

ophrases: /* Empty */
	| ophrases phrase
	;

phrase	: tNEWPHRASE { set_skip(); } ';'	{
		yywarning("Unrecognised `newphrase� keyword '%s' skipped", $1);
		xfree($1);
		}
	| cvskw { set_skip(); } ';'	{ yywarning("CVS extended keyword skipped"); }
	| otherkw { set_skip(); } ';'	{ yywarning("Other extended keyword"); }
	;

cvskw	: tOWNER
	| tGROUP
	| tPERMISSIONS
	| tSPECIAL
	| tSYMLINK
	| tHARDLINKS
	;

otherkw	: tNAMESPACE
	| tDEAD
	;

ostr	: /* Empty */			{ $$ = NULL; }
	| tSTRING			{ $$ = $1; }
	;

orev	: /* Empty */			{ $$ = NULL; }
	| tREV				{ $$ = $1; }
	;

orevs	: /* Empty */			{ $$ = NULL; }
	| revs				{ $$ = $1; }
	;

revs	: tREV				{ $$ = new_revs($1); }
	| revs tREV			{ $$ = add_revs($1, $2); }
	;

oid	: /* Empty */			{ $$ = NULL; }
	| tID				{ $$ = $1; }
	;

oids	: /* Empty */			{ $$ = NULL; }
	| ids				{ $$ = $1; }
	;

ids	: tID				{ $$ = new_ids($1); }
	| ids tID			{ set_id(); $$ = add_ids($1, $2); }
	;

oidrevs	: /* Empty */			{ $$ = NULL; }
	| idrevs			{ $$ = $1; }
	;

idrevs	: idrev				{ $$ = new_idrevs($1); }
	| idrevs idrev			{ $$ = add_idrevs($1, $2); }
	;

idrev	: tID ':' tREV			{ set_id(); $$ = new_idrev($1, $3); }
	;

otags	: /* Empty */			{ $$ = NULL; }
	| tags				{ $$ = $1; }
	;

tags	: tag				{ if($1) $$ = new_tags($1); else $$ = NULL; }
	| tags tag			{ if($1 && $2) $$ = add_tags($1, $2); else if($2) $$ = new_tags($2); else $$ = $1; }
	;

tag	: tSYM ':' tREV 		{ set_sym(); $$ = new_tag($1, $3); }
 /* Zap the additional tag-info from CVSNT */
 /* This is a bit of a hack, but it is necessary to do like this */
 /* because the parser is not allowed to do any look-ahead on ':'. */
 /* Otherwise, we would have a tNEWPHRASE hit because we cannot set */
 /* set_sym() before the lexer gets the next token. */
 	| ':' tREV ':' tSTRING		{ set_sym(); $$ = NULL; }
	;

%%
static rev_t *make_rev(char *s, int isrev)
{
	char *cptr;
	int dots = 0;
	rev_t *r;

	if(!s)
		return NULL;

	r = xmalloc(sizeof(*r));

	for(cptr = s; *cptr; cptr++)
	{
		if(*cptr == '.')
			dots++;
	}
	if(!dots)
	{
		r->rev = xstrdup("");
		r->branch = xstrdup(s);
		r->isbranch = 1;
	}
	else if(!*s)
	{
		r->rev = xstrdup("?.?");
		r->branch = xstrdup("?");
	}
	else if(dots & 1)
	{
		char *t;
		r->rev = s;
		r->branch = xstrdup(s);
		cptr = strrchr(r->branch, '.');
		assert(cptr != NULL);
		*cptr = '\0';
		t = strrchr(r->branch, '.');
		if(!isrev && ((t && !strcmp(t+1, "0")) || (!t && !strcmp(r->branch, "0"))))
		{
			/* Magic branch numbers "x.x.0.x" */
			r->isbranch = 1;
			if(t)
				strcpy(t+1, cptr+1);
			else
				strcpy(r->branch, cptr+1);
		}
	}
	else
	{
		r->isbranch = 1;
		r->branch = s;
		r->rev = xmalloc(strlen(s) + 3);
		strcpy(r->rev, s);
		strcat(r->rev, ".?");
	}
	return r;
}


static tag_t *new_tag(char *s, char *r)
{
	tag_t *t = xmalloc(sizeof(*t));
	t->tag = s;
	t->rev = make_rev(r, 0);
	return t;
}

static tags_t *new_tags(tag_t *s)
{
	tags_t *t = xmalloc(sizeof(*t));
	t->ntags = 1;
	t->tags = xmalloc(sizeof(t->tags[0]));
	t->tags[0] = s;
	return t;
}

static tags_t *add_tags(tags_t *s, tag_t *t)
{
	if(!s)
		return new_tags(t);
	s->tags = xrealloc(s->tags, (s->ntags+1) * sizeof(s->tags[0]));
	s->tags[s->ntags] = t;
	s->ntags++;
	return s;
}

static idrev_t *new_idrev(char *s, char *r)
{
	idrev_t *t = xmalloc(sizeof(*t));
	t->id = s;
	t->rev = make_rev(r, 1);
	return t;
}

static idrevs_t *new_idrevs(idrev_t *s)
{
	idrevs_t *t = xmalloc(sizeof(*t));
	t->nidrevs = 1;
	t->idrevs = xmalloc(sizeof(t->idrevs[0]));
	t->idrevs[0] = s;
	return t;
}

static idrevs_t *add_idrevs(idrevs_t *s, idrev_t *t)
{
	if(!s)
		return new_idrevs(t);
	s->idrevs = xrealloc(s->idrevs, (s->nidrevs+1) * sizeof(s->idrevs[0]));
	s->idrevs[s->nidrevs] = t;
	s->nidrevs++;
	return s;
}

static ids_t *new_ids(char *s)
{
	ids_t *t = xmalloc(sizeof(*t));
	t->nids = 1;
	t->ids = xmalloc(sizeof(t->ids[0]));
	t->ids[0] = s;
	return t;
}

static ids_t *add_ids(ids_t *s, char *t)
{
	s->ids = xrealloc(s->ids, (s->nids+1) * sizeof(s->ids[0]));
	s->ids[s->nids] = t;
	s->nids++;
	return s;
}

static revs_t *new_revs(char *s)
{
	revs_t *t = xmalloc(sizeof(*t));
	t->nrevs = 1;
	t->revs = xmalloc(sizeof(t->revs[0]));
	t->revs[0] = make_rev(s, 1);
	return t;
}

static revs_t *add_revs(revs_t *s, char *t)
{
	s->revs = xrealloc(s->revs, (s->nrevs+1) * sizeof(s->revs[0]));
	s->revs[s->nrevs] = make_rev(t, 1);
	s->nrevs++;
	return s;
}

static dtext_t *new_dtext(char *n, char *l, char *t)
{
	dtext_t *d = xmalloc(sizeof(*d));
	d->rev = make_rev(n, 1);
	d->log = l;
	d->text = t;
	return d;
}

static dtexts_t *add_dtexts(dtexts_t *s, dtext_t *t)
{
	if(!s)
		s = xmalloc(sizeof(*s));
	s->dtexts = xrealloc(s->dtexts, (s->ndtexts+1) * sizeof(s->dtexts[0]));
	s->dtexts[s->ndtexts] = t;
	s->ndtexts++;
	return s;
}

static delta_t *new_delta(char *rev, char *date, char *author, char *state, revs_t *branches, char *next)
{
	delta_t *d = xmalloc(sizeof(*d));
	d->rev = make_rev(rev, 1);
	d->date = date;
	d->author = author;
	d->state = state;
	d->branches = branches;
	d->next = make_rev(next, 1);
	return d;
}

static deltas_t *add_deltas(deltas_t *s, delta_t *t)
{
	if(!s)
		s = xmalloc(sizeof(*s));
	s->deltas = xrealloc(s->deltas, (s->ndeltas+1) * sizeof(s->deltas[0]));
	s->deltas[s->ndeltas] = t;
	s->ndeltas++;
	return s;
}

static rcsfile_t *new_rcsfile(char *head, char *branch, ids_t *access, tags_t *tags,
				idrevs_t *locks, int strict, char *comment, char *expand)
{
	rcsfile_t *r = xmalloc(sizeof(*r));
	r->head = make_rev(head, 1);
	r->branch = make_rev(branch, 0);
	r->access = access;
	r->tags = tags;
	r->locks = locks;
	r->strict = strict;
	r->comment = comment;
	r->expand = expand;
	return r;
}

1	bertho	1.1	/*
2			* CvsGraph graphical representation generator of brances and revisions
3			* of a file in cvs/rcs.
4			*
5			* Copyright (C) 2001 B. Stultiens
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20			*/
21
22			%{
23	bertho	1.3	#define YYERROR_VERBOSE 1
24
25	bertho	1.1	#include <stdio.h>
26			#include <stdlib.h>
27			#include <string.h>
28			#include <assert.h>
29
30	bertho	1.4	#include <gd.h> /* For gdFontPtr in cvsgraph.h */
31			#include "cvsgraph.h"
32	bertho	1.1	#include "utils.h"
33			#include "rcs.h"
34
35			rcsfile_t *rcsfile;
36
37			static tag_t new_tag(char s, char *r);
38			static tags_t new_tags(tag_t s);
39			static tags_t add_tags(tags_t s, tag_t *t);
40			static idrev_t new_idrev(char s, char *r);
41			static idrevs_t new_idrevs(idrev_t s);
42			static idrevs_t add_idrevs(idrevs_t s, idrev_t *t);
43			static ids_t new_ids(char s);
44			static ids_t add_ids(ids_t s, char *t);
45			static revs_t new_revs(char s);
46			static revs_t add_revs(revs_t s, char *t);
47			static dtext_t new_dtext(char n, char l, char t);
48			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);
50			static deltas_t add_deltas(deltas_t s, delta_t *t);
51			static rcsfile_t new_rcsfile(char head, char branch, ids_t access, tags_t *tags,
52			idrevs_t locks, int strict, char comment, char *expand);
53
54			%}
55
56			%union{
57			int i;
58			char *str;
59			tag_t *tag;
60			tags_t *tags;
61			idrev_t *idrev;
62			idrevs_t *idrevs;
63			ids_t *ids;
64			revs_t *revs;
65			dtext_t *dtext;
66			dtexts_t *dtexts;
67			delta_t *delta;
68			deltas_t *deltas;
69			rcsfile_t *rcsfile;
70			}
71
72			%token tHEAD tBRANCH tACCESS tSYMBOLS tLOCKS tSTRICT tCOMMENT
73			%token tEXPAND tDATE tAUTHOR tSTATE tBRANCHES tNEXT
74			%token tDESC tLOG tTEXT
75			%token tOWNER tGROUP tPERMISSIONS tSPECIAL tSYMLINK tHARDLINKS
76			%token tNAMESPACE tDEAD
77			%token <str> tNEWPHRASE
78			%token <str> tSTRING tREV tID tSYM
79
80
81	bertho	1.5	%type <str> ostr orev oid obranch ocomment oexpand desc idorstr
82	bertho	1.1	%type <tag> tag
83			%type <tags> tags otags
84			%type <idrev> idrev
85			%type <idrevs> idrevs oidrevs
86			%type <ids> ids oids
87			%type <revs> revs orevs
88			%type <i> ostrict
89			%type <dtext> dtext
90			%type <dtexts> dtexts
91			%type <delta> delta
92			%type <deltas> deltas
93			%type <rcsfile> admin
94
95			%%
96	bertho	1.4	rcsfile : admin deltas desc {
97	bertho	1.1	rcsfile = $1;
98			rcsfile->deltas = $2;
99			rcsfile->desc = $3;
100	bertho	1.4	rcsfile->dtexts = NULL;
101	bertho	1.1	if(rcsfile->head)
102			{
103			char *h = xstrdup("HEAD");
104			char *r = xstrdup(rcsfile->head->rev);
105			tag_t *t = new_tag(h, r);
106	bertho	1.7	t->ignore = -1; /* Make sure it doesn't get zapped */
107	bertho	1.1	rcsfile->tags = add_tags(rcsfile->tags, t);
108			}
109			if(rcsfile->branch)
110			{
111			char *h = xstrdup("MAIN");
112			char *r = xstrdup(rcsfile->branch->rev);
113			tag_t *t = new_tag(h, r);
114			t->rev->isbranch = 1;
115			rcsfile->tags = add_tags(rcsfile->tags, t);
116			}
117			/* Else we need to add the main tag later because the
118			* trunk is reversed in order and the primary revision
119			* numbers can vary.
120			*/
121	bertho	1.4	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	bertho	1.1	}
130	bertho	1.4
131			/* This is trailing deltatext context and possibly ignored */
132			dtexts { rcsfile->dtexts = $5; }
133	bertho	1.1	;
134
135			admin : tHEAD orev ';'
136			obranch
137			tACCESS { set_id(); } oids ';'
138			tSYMBOLS { set_sym(); } otags ';'
139	bertho	1.2	tLOCKS { set_id(); } oidrevs ';' ostrict
140	bertho	1.1	ocomment
141			oexpand
142	bertho	1.2	ophrases { $$ = new_rcsfile($2, $4, $7, $11, $15, $17, $18, $19); }
143	bertho	1.1	;
144
145			ostrict : /* Empty */ { $$ = 0; }
146			\| tSTRICT ';' { $$ = 1; }
147			;
148
149			obranch : /* Empty */ { $$ = NULL; }
150			\| tBRANCH orev ';' { $$ = $2; }
151			;
152
153			ocomment: /* Empty */ { $$ = NULL; }
154			\| tCOMMENT ostr ';' { $$ = $2; }
155			;
156
157			oexpand : /* Empty */ { $$ = NULL; }
158			\| tEXPAND ostr ';' { $$ = $2; }
159			;
160
161			deltas : /* Empty */ { $$ = NULL; }
162			\| deltas delta { $$ = add_deltas($1, $2); }
163			;
164
165			delta : tREV
166			tDATE tREV ';'
167	bertho	1.5	tAUTHOR { set_author(); } idorstr ';'
168	bertho	1.1	tSTATE { set_id(); } oid ';'
169			tBRANCHES orevs ';'
170			tNEXT orev ';'
171			ophrases { $$ = new_delta($1, $3, $7, $11, $14, $17); }
172	bertho	1.5	;
173
174			idorstr : tID { $$ = $1; }
175			\| tSTRING { $$ = $1; }
176	bertho	1.1	;
177
178			desc : tDESC tSTRING { $$ = $2; }
179			;
180
181			dtexts : /* Empty */ { $$ = NULL; }
182			\| dtexts dtext { $$ = add_dtexts($1, $2); }
183			;
184
185			dtext : tREV
186			tLOG tSTRING
187			ophrases
188			tTEXT { set_skipstr(); } tSTRING { $$ = new_dtext($1, $3, $7); }
189			;
190
191			ophrases: /* Empty */
192			\| ophrases phrase
193			;
194
195			phrase : tNEWPHRASE { set_skip(); } ';' {
196			yywarning("Unrecognised `newphrase� keyword '%s' skipped", $1);
197			xfree($1);
198			}
199			\| cvskw { set_skip(); } ';' { yywarning("CVS extended keyword skipped"); }
200			\| otherkw { set_skip(); } ';' { yywarning("Other extended keyword"); }
201			;
202
203			cvskw : tOWNER
204			\| tGROUP
205			\| tPERMISSIONS
206			\| tSPECIAL
207			\| tSYMLINK
208			\| tHARDLINKS
209			;
210
211			otherkw : tNAMESPACE
212			\| tDEAD
213			;
214
215			ostr : /* Empty */ { $$ = NULL; }
216			\| tSTRING { $$ = $1; }
217			;
218
219			orev : /* Empty */ { $$ = NULL; }
220			\| tREV { $$ = $1; }
221			;
222
223			orevs : /* Empty */ { $$ = NULL; }
224			\| revs { $$ = $1; }
225			;
226
227			revs : tREV { $$ = new_revs($1); }
228			\| revs tREV { $$ = add_revs($1, $2); }
229			;
230
231			oid : /* Empty */ { $$ = NULL; }
232			\| tID { $$ = $1; }
233			;
234
235			oids : /* Empty */ { $$ = NULL; }
236			\| ids { $$ = $1; }
237			;
238
239			ids : tID { $$ = new_ids($1); }
240			\| ids tID { set_id(); $$ = add_ids($1, $2); }
241			;
242
243			oidrevs : /* Empty */ { $$ = NULL; }
244			\| idrevs { $$ = $1; }
245			;
246
247			idrevs : idrev { $$ = new_idrevs($1); }
248			\| idrevs idrev { $$ = add_idrevs($1, $2); }
249			;
250
251			idrev : tID ':' tREV { set_id(); $$ = new_idrev($1, $3); }
252			;
253
254			otags : /* Empty */ { $$ = NULL; }
255			\| tags { $$ = $1; }
256			;
257
258	bertho	1.6	tags : tag { if($1) $$ = new_tags($1); else $$ = NULL; }
259			\| tags tag { if($1 && $2) $$ = add_tags($1, $2); else if($2) $$ = new_tags($2); else $$ = $1; }
260	bertho	1.1	;
261
262			tag : tSYM ':' tREV { set_sym(); $$ = new_tag($1, $3); }
263	bertho	1.6	/* 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	bertho	1.1	;
270
271			%%
272	bertho	1.8	static rev_t make_rev(char s, int isrev)
273	bertho	1.1	{
274			char *cptr;
275			int dots = 0;
276			rev_t *r;
277
278			if(!s)
279			return NULL;
280
281			r = xmalloc(sizeof(*r));
282
283			for(cptr = s; *cptr; cptr++)
284			{
285			if(*cptr == '.')
286			dots++;
287			}
288			if(!dots)
289			{
290			r->rev = xstrdup("");
291			r->branch = xstrdup(s);
292			r->isbranch = 1;
293			}
294			else if(!*s)
295			{
296			r->rev = xstrdup("?.?");
297			r->branch = xstrdup("?");
298			}
299			else if(dots & 1)
300			{
301			char *t;
302			r->rev = s;
303			r->branch = xstrdup(s);
304			cptr = strrchr(r->branch, '.');
305			assert(cptr != NULL);
306			*cptr = '\0';
307			t = strrchr(r->branch, '.');
308	bertho	1.8	if(!isrev && ((t && !strcmp(t+1, "0")) \|\| (!t && !strcmp(r->branch, "0"))))
309	bertho	1.1	{
310			/* Magic branch numbers "x.x.0.x" */
311			r->isbranch = 1;
312			if(t)
313			strcpy(t+1, cptr+1);
314			else
315			strcpy(r->branch, cptr+1);
316			}
317			}
318			else
319			{
320			r->isbranch = 1;
321			r->branch = s;
322			r->rev = xmalloc(strlen(s) + 3);
323			strcpy(r->rev, s);
324			strcat(r->rev, ".?");
325			}
326			return r;
327			}
328
329
330			static tag_t new_tag(char s, char *r)
331			{
332			tag_t t = xmalloc(sizeof(t));
333			t->tag = s;
334	bertho	1.8	t->rev = make_rev(r, 0);
335	bertho	1.1	return t;
336			}
337
338			static tags_t new_tags(tag_t s)
339			{
340			tags_t t = xmalloc(sizeof(t));
341			t->ntags = 1;
342			t->tags = xmalloc(sizeof(t->tags[0]));
343			t->tags[0] = s;
344			return t;
345			}
346
347			static tags_t add_tags(tags_t s, tag_t *t)
348			{
349			if(!s)
350			return new_tags(t);
351			s->tags = xrealloc(s->tags, (s->ntags+1) * sizeof(s->tags[0]));
352			s->tags[s->ntags] = t;
353			s->ntags++;
354			return s;
355			}
356
357			static idrev_t new_idrev(char s, char *r)
358			{
359			idrev_t t = xmalloc(sizeof(t));
360			t->id = s;
361	bertho	1.8	t->rev = make_rev(r, 1);
362	bertho	1.1	return t;
363			}
364
365			static idrevs_t new_idrevs(idrev_t s)
366			{
367			idrevs_t t = xmalloc(sizeof(t));
368			t->nidrevs = 1;
369			t->idrevs = xmalloc(sizeof(t->idrevs[0]));
370			t->idrevs[0] = s;
371			return t;
372			}
373
374			static idrevs_t add_idrevs(idrevs_t s, idrev_t *t)
375			{
376			if(!s)
377			return new_idrevs(t);
378			s->idrevs = xrealloc(s->idrevs, (s->nidrevs+1) * sizeof(s->idrevs[0]));
379			s->idrevs[s->nidrevs] = t;
380			s->nidrevs++;
381			return s;
382			}
383
384			static ids_t new_ids(char s)
385			{
386			ids_t t = xmalloc(sizeof(t));
387			t->nids = 1;
388			t->ids = xmalloc(sizeof(t->ids[0]));
389			t->ids[0] = s;
390			return t;
391			}
392
393			static ids_t add_ids(ids_t s, char *t)
394			{
395			s->ids = xrealloc(s->ids, (s->nids+1) * sizeof(s->ids[0]));
396			s->ids[s->nids] = t;
397			s->nids++;
398			return s;
399			}
400
401			static revs_t new_revs(char s)
402			{
403			revs_t t = xmalloc(sizeof(t));
404			t->nrevs = 1;
405			t->revs = xmalloc(sizeof(t->revs[0]));
406	bertho	1.8	t->revs[0] = make_rev(s, 1);
407	bertho	1.1	return t;
408			}
409
410			static revs_t add_revs(revs_t s, char *t)
411			{
412			s->revs = xrealloc(s->revs, (s->nrevs+1) * sizeof(s->revs[0]));
413	bertho	1.8	s->revs[s->nrevs] = make_rev(t, 1);
414	bertho	1.1	s->nrevs++;
415			return s;
416			}
417
418			static dtext_t new_dtext(char n, char l, char t)
419			{
420			dtext_t d = xmalloc(sizeof(d));
421	bertho	1.8	d->rev = make_rev(n, 1);
422	bertho	1.1	d->log = l;
423			d->text = t;
424			return d;
425			}
426
427			static dtexts_t add_dtexts(dtexts_t s, dtext_t *t)
428			{
429			if(!s)
430			s = xmalloc(sizeof(*s));
431			s->dtexts = xrealloc(s->dtexts, (s->ndtexts+1) * sizeof(s->dtexts[0]));
432			s->dtexts[s->ndtexts] = t;
433			s->ndtexts++;
434			return s;
435			}
436
437			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));
440	bertho	1.8	d->rev = make_rev(rev, 1);
441	bertho	1.1	d->date = date;
442			d->author = author;
443			d->state = state;
444			d->branches = branches;
445	bertho	1.8	d->next = make_rev(next, 1);
446	bertho	1.1	return d;
447			}
448
449			static deltas_t add_deltas(deltas_t s, delta_t *t)
450			{
451			if(!s)
452			s = xmalloc(sizeof(*s));
453			s->deltas = xrealloc(s->deltas, (s->ndeltas+1) * sizeof(s->deltas[0]));
454			s->deltas[s->ndeltas] = t;
455			s->ndeltas++;
456			return s;
457			}
458
459			static rcsfile_t new_rcsfile(char head, char branch, ids_t access, tags_t *tags,
460			idrevs_t locks, int strict, char comment, char *expand)
461			{
462			rcsfile_t r = xmalloc(sizeof(r));
463	bertho	1.8	r->head = make_rev(head, 1);
464			r->branch = make_rev(branch, 0);
465	bertho	1.1	r->access = access;
466			r->tags = tags;
467			r->locks = locks;
468			r->strict = strict;
469			r->comment = comment;
470			r->expand = expand;
471			return r;
472			}
473