%{
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 * Copyright (c) 2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include "gnu_msgfmt.h"
#include "gnu_lex.h"

static int	plural_index;

%}

%union {
	char	*str;
	int	num;
	struct entry	msg;
	struct ch	c;
}

%token	<num> DOMAIN
%token	<num> MSGID
%token	<num> MSGID_PLURAL
%token	<num> MSGSTR
%token	<num> NUM
%token	<str> STR
%token	<str> COMMENT
%token	<str> SYMBOL
%token	<c>	CHR
%type	<msg> message_string plural_messages plural_message
%%

start	:
	| start po
	;

po	: comment
	| domain
	| body
	;

domain	: DOMAIN STR
	{
		handle_domain($2);
	}
	;

comment	: COMMENT
	{
		handle_comment($1);
	}

body	: MSGID message_string MSGSTR message_string
	{
		struct entry	och1, och2;

		och1.no = 1;
		och1.num = $1;
		och1.str = $2.str;
		och1.len = $2.len;
		och1.pos = NULL;

		och2.no = 1;
		och2.num = $3;
		och2.str = $4.str;
		och2.len = $4.len;
		och2.pos = NULL;

		handle_message(&och1, &och2);
		clear_state();
	}
	| MSGID message_string MSGID_PLURAL
		message_string {plural_index = 0;} plural_messages
	{
		size_t	len;
		struct entry	och1, och2;
		struct loc	*pos1;
		char	*id_str;

		len = $2.len + $4.len;
		id_str = (char *)Xmalloc(len);
		(void) memcpy(id_str, $2.str, $2.len);
		(void) memcpy(id_str + $2.len, $4.str, $4.len);
		free($2.str);
		free($4.str);

		pos1 = (struct loc *)Xmalloc(2 * sizeof (struct loc));
		pos1[0].off = 0;
		pos1[0].len = $2.len;
		pos1[0].num = $1;
		pos1[1].off = $2.len;
		pos1[1].len = $4.len;
		pos1[1].num = $3;
		och1.no = 2;
		och1.num = $1;
		och1.str = id_str;
		och1.len = len;
		och1.pos = pos1;

		och2 = $6;
		handle_message(&och1, &och2);
		clear_state();
	}
	| MSGID message_string
	{
		error(gettext(ERR_NO_MSGSTR), $1, cur_po);
		/* NOTREACHED */
	}
	| MSGID message_string MSGID_PLURAL message_string
	{
		error(gettext(ERR_NO_MSGSTRS), $1, cur_po);
		/* NOTRECHED */
	}
	| MSGID message_string plural_messages
	{
		error(gettext(ERR_NO_MSGID_PLURAL), $1, cur_po);
		/* NOTREACHED */
	}
	;

message_string	: STR
	{
		$$.str = $1;
		$$.len = strlen($1) + 1;
	}
	| message_string STR
	{
		size_t	len, len1, len2;
		char	*str;

		/* $1.len includes null-termination */
		len1 = $1.len - 1;
		len2 = strlen($2);

		/* len doesn't include null-termination */
		len = len1 + len2;

		str = (char *)Xmalloc(len + 1);
		(void) memcpy(str, $1.str, len1);
		(void) memcpy(str + len1, $2, len2 + 1);
		free($1.str);
		free($2);
		$$.str = str;
		$$.len = len + 1;
	}
	;

plural_messages	: plural_message
	{
		$$ = $1;
	}
	| plural_messages plural_message
	{
		struct loc	*tmp;
		size_t	len;
		char	*plural_str;
		int	no;

		no = $1.no + 1;
		tmp = (struct loc *)Xrealloc($1.pos,
			no * sizeof (struct loc));
		tmp[no - 1].off = $1.len;
		tmp[no - 1].len = $2.len;
		tmp[no - 1].num = $2.num;
		free($2.pos);

		len = $1.len + $2.len;
		plural_str = (char *)Xmalloc(len);
		(void) memcpy(plural_str, $1.str, $1.len);
		(void) memcpy(plural_str + $1.len, $2.str, $2.len);

		$$.no = no;
		$$.num = $1.num;
		$$.str = plural_str;
		$$.len = len;
		$$.pos = tmp;
		free($1.str);
		free($2.str);
	}
	;

plural_message	: MSGSTR '[' NUM ']' message_string
	{
		struct loc	*pos;
		if ($3 != plural_index) {
			error(gettext(ERR_INVALID_PLURALS), $1, cur_po);
			/* NOTREACHED */
		}
		plural_index++;
		pos = (struct loc *)Xmalloc(sizeof (struct loc));
		pos->off = 0;
		pos->len = $5.len;
		pos->num = $1;
		$$.no = 1;
		$$.num = $1;
		$$.str = $5.str;
		$$.len = $5.len;
		$$.pos = pos;
	}
	;
%%
int
yyerror(const char *err)
{
	(void) fprintf(stderr,
		gettext(ERR_LOCATION), cur_line, cur_po);
	(void) fprintf(stderr, "%s\n", err);

	exit(1);
}