%{ /* deffilep.y - parser for .def files */

#include "sysdep.h"

#include "libiberty.h"

#include "safe-ctype.h"

#include "bfd.h"

#include "ld.h"

#include "ldmisc.h"

#include "deffile.h"

#define TRACE 0

#define ROUND_UP(a, b) (((a)+((b)-1))&~((b)-1))

#define yymaxdepth def_maxdepth

#define yyparse def_parse

#define yylex def_lex

#define yyerror def_error

#define yylval def_lval

#define yychar def_char

#define yydebug def_debug

#define yypact def_pact

#define yyr1 def_r1

#define yyr2 def_r2

#define yydef def_def

#define yychk def_chk

#define yypgo def_pgo

#define yyact def_act

#define yyexca def_exca

#define yyerrflag def_errflag

#define yynerrs def_nerrs

#define yyps def_ps

#define yypv def_pv

#define yys def_s

#define yy_yys def_yys

#define yystate def_state

#define yytmp def_tmp

#define yyv def_v

#define yy_yyv def_yyv

#define yyval def_val

#define yylloc def_lloc

#define yyreds def_reds /* With YYDEBUG defined. */

#define yytoks def_toks /* With YYDEBUG defined. */

#define yylhs def_yylhs

#define yylen def_yylen

#define yydefred def_yydefred

#define yydgoto def_yydgoto

#define yysindex def_yysindex

#define yyrindex def_yyrindex

#define yygindex def_yygindex

#define yytable def_yytable

#define yycheck def_yycheck

typedef struct def_pool_str {

struct def_pool_str *next;

char data[1];

} def_pool_str;

static def_pool_str *pool_strs = NULL;

static char *def_pool_alloc (size_t sz);

static char *def_pool_strdup (const char *str);

static void def_pool_free (void);

static void def_description (const char *);

static void def_exports (const char *, const char *, int, int, const char *);

static void def_heapsize (int, int);

static void def_import (const char *, const char *, const char *, const char *,

int, const char *);

static void def_image_name (const char *, bfd_vma, int);

static void def_section (const char *, int);

static void def_section_alt (const char *, const char *);

static void def_stacksize (int, int);

static void def_version (int, int);

static void def_directive (char *);

static void def_aligncomm (char *str, int align);

static int def_parse (void);

static int def_error (const char *);

static int def_lex (void);

static int lex_forced_token = 0;

static const char *lex_parse_string = 0;

static const char *lex_parse_string_end = 0;

%union {

char *id;

const char *id_const;

int number;

bfd_vma vma;

char *digits;

};

%token NAME LIBRARY DESCRIPTION STACKSIZE_K HEAPSIZE CODE DATAU DATAL

%token SECTIONS EXPORTS IMPORTS VERSIONK BASE CONSTANTU CONSTANTL

%token PRIVATEU PRIVATEL ALIGNCOMM

%token READ WRITE EXECUTE SHARED NONAMEU NONAMEL DIRECTIVE EQUAL

%token <id> ID

%token <digits> DIGITS

%type <number> NUMBER

%type <vma> VMA opt_base

%type <digits> opt_digits

%type <number> opt_ordinal

%type <number> attr attr_list opt_number exp_opt_list exp_opt

%type <id> opt_name opt_name2 opt_equal_name anylang_id opt_id

%type <id> opt_equalequal_name

%type <id_const> keyword_as_name

start: start command

| command

;

command:

NAME opt_name opt_base { def_image_name ($2, $3, 0); }

| LIBRARY opt_name opt_base { def_image_name ($2, $3, 1); }

| DESCRIPTION ID { def_description ($2);}

| STACKSIZE_K NUMBER opt_number { def_stacksize ($2, $3);}

| HEAPSIZE NUMBER opt_number { def_heapsize ($2, $3);}

| CODE attr_list { def_section ("CODE", $2);}

| DATAU attr_list { def_section ("DATA", $2);}

| SECTIONS seclist

| EXPORTS explist

| IMPORTS implist

| VERSIONK NUMBER { def_version ($2, 0);}

| VERSIONK NUMBER '.' NUMBER { def_version ($2, $4);}

| DIRECTIVE ID { def_directive ($2);}

| ALIGNCOMM anylang_id ',' NUMBER { def_aligncomm ($2, $4);}

;

explist:

/* EMPTY */

| expline

| explist expline

;

expline:

/* The opt_comma is necessary to support both the usual

opt_name2 opt_equal_name opt_ordinal opt_comma exp_opt_list opt_comma opt_equalequal_name

{ def_exports ($1, $2, $3, $5, $7); }

;

exp_opt_list:

/* The opt_comma is necessary to support both the usual

exp_opt opt_comma exp_opt_list { $$ = $1 | $3; }

| { $$ = 0; }

;

exp_opt:

NONAMEU { $$ = 1; }

| NONAMEL { $$ = 1; }

| CONSTANTU { $$ = 2; }

| CONSTANTL { $$ = 2; }

| DATAU { $$ = 4; }

| DATAL { $$ = 4; }

| PRIVATEU { $$ = 8; }

| PRIVATEL { $$ = 8; }

;

implist:

implist impline

| impline

;

impline:

ID '=' ID '.' ID '.' ID opt_equalequal_name

{ def_import ($1, $3, $5, $7, -1, $8); }

| ID '=' ID '.' ID '.' NUMBER opt_equalequal_name

{ def_import ($1, $3, $5, 0, $7, $8); }

| ID '=' ID '.' ID opt_equalequal_name

{ def_import ($1, $3, 0, $5, -1, $6); }

| ID '=' ID '.' NUMBER opt_equalequal_name

{ def_import ($1, $3, 0, 0, $5, $6); }

| ID '.' ID '.' ID opt_equalequal_name

{ def_import( 0, $1, $3, $5, -1, $6); }

| ID '.' ID opt_equalequal_name

{ def_import ( 0, $1, 0, $3, -1, $4); }

;

seclist:

seclist secline

| secline

;

secline:

ID attr_list { def_section ($1, $2);}

| ID ID { def_section_alt ($1, $2);}

;

attr_list:

attr_list opt_comma attr { $$ = $1 | $3; }

| attr { $$ = $1; }

;

opt_comma:

','

|

;

opt_number: ',' NUMBER { $$=$2;}

| { $$=-1;}

;

attr:

READ { $$ = 1;}

| WRITE { $$ = 2;}

| EXECUTE { $$=4;}

| SHARED { $$=8;}

;

keyword_as_name: BASE { $$ = "BASE"; }

| CODE { $$ = "CODE"; }

| CONSTANTU { $$ = "CONSTANT"; }

| CONSTANTL { $$ = "constant"; }

| DATAU { $$ = "DATA"; }

| DATAL { $$ = "data"; }

| DESCRIPTION { $$ = "DESCRIPTION"; }

| DIRECTIVE { $$ = "DIRECTIVE"; }

| EXECUTE { $$ = "EXECUTE"; }

| EXPORTS { $$ = "EXPORTS"; }

| HEAPSIZE { $$ = "HEAPSIZE"; }

| IMPORTS { $$ = "IMPORTS"; }

| NAME { $$ = "NAME"; }

| NONAMEU { $$ = "NONAME"; }

| NONAMEL { $$ = "noname"; }

| PRIVATEU { $$ = "PRIVATE"; }

| PRIVATEL { $$ = "private"; }

| READ { $$ = "READ"; }

| SHARED { $$ = "SHARED"; }

| STACKSIZE_K { $$ = "STACKSIZE"; }

| VERSIONK { $$ = "VERSION"; }

| WRITE { $$ = "WRITE"; }

;

opt_name2: ID { $$ = $1; }

| '.' keyword_as_name

{

char *name = xmalloc (strlen ($2) + 2);

sprintf (name, ".%s", $2);

$$ = name;

}

| '.' opt_name2

{

char *name = def_pool_alloc (strlen ($2) + 2);

sprintf (name, ".%s", $2);

$$ = name;

}

| keyword_as_name '.' opt_name2

{

char *name = def_pool_alloc (strlen ($1) + 1 + strlen ($3) + 1);

sprintf (name, "%s.%s", $1, $3);

$$ = name;

}

| ID '.' opt_name2

{

char *name = def_pool_alloc (strlen ($1) + 1 + strlen ($3) + 1);

sprintf (name, "%s.%s", $1, $3);

$$ = name;

}

;

opt_name: opt_name2 { $$ = $1; }

| { $$ = ""; }

;

opt_equalequal_name: EQUAL ID { $$ = $2; }

| { $$ = 0; }

;

opt_ordinal:

'@' NUMBER { $$ = $2;}

| { $$ = -1;}

;

opt_equal_name:

'=' opt_name2 { $$ = $2; }

| { $$ = 0; }

;

opt_base: BASE '=' VMA { $$ = $3;}

| { $$ = (bfd_vma) -1;}

;

anylang_id: ID { $$ = $1; }

| '.' ID

{

char *id = def_pool_alloc (strlen ($2) + 2);

sprintf (id, ".%s", $2);

$$ = id;

}

| anylang_id '.' opt_digits opt_id

{

char *id = def_pool_alloc (strlen ($1) + 1 + strlen ($3) + strlen ($4) + 1);

sprintf (id, "%s.%s%s", $1, $3, $4);

$$ = id;

}

;

opt_digits: DIGITS { $$ = $1; }

| { $$ = ""; }

;

opt_id: ID { $$ = $1; }

| { $$ = ""; }

;

NUMBER: DIGITS { $$ = strtoul ($1, 0, 0); }

;

VMA: DIGITS { $$ = (bfd_vma) strtoull ($1, 0, 0); }

%%

static FILE *the_file;

static const char *def_filename;

static int linenumber;

static def_file *def;

static int saw_newline;

struct directive

{

struct directive *next;

char *name;

int len;

};

static struct directive *directives = 0;

def_file *

def_file_empty (void)

{

def_file *rv = xmalloc (sizeof (def_file));

memset (rv, 0, sizeof (def_file));

rv->is_dll = -1;

rv->base_address = (bfd_vma) -1;

rv->stack_reserve = rv->stack_commit = -1;

rv->heap_reserve = rv->heap_commit = -1;

rv->version_major = rv->version_minor = -1;

return rv;

}

def_file *

def_file_parse (const char *filename, def_file *add_to)

{

struct directive *d;

the_file = fopen (filename, "r");

def_filename = filename;

linenumber = 1;

if (!the_file)

{

perror (filename);

return 0;

}

if (add_to)

{

def = add_to;

}

else

{

def = def_file_empty ();

}

saw_newline = 1;

if (def_parse ())

{

def_file_free (def);

fclose (the_file);

def_pool_free ();

return 0;

}

fclose (the_file);

while ((d = directives) != NULL)

{

#if TRACE

printf ("Adding directive %08x `%s'\n", d->name, d->name);

#endif

def_file_add_directive (def, d->name, d->len);

directives = d->next;

free (d->name);

free (d);

}

def_pool_free ();

return def;

}

void

def_file_free (def_file *fdef)

{

int i;

if (!fdef)

return;

if (fdef->name)

free (fdef->name);

if (fdef->description)

free (fdef->description);

if (fdef->section_defs)

{

for (i = 0; i < fdef->num_section_defs; i++)

{

if (fdef->section_defs[i].name)

free (fdef->section_defs[i].name);

if (fdef->section_defs[i].class)

free (fdef->section_defs[i].class);

}

free (fdef->section_defs);

}

if (fdef->exports)

{

for (i = 0; i < fdef->num_exports; i++)

{

if (fdef->exports[i].internal_name

&& fdef->exports[i].internal_name != fdef->exports[i].name)

free (fdef->exports[i].internal_name);

if (fdef->exports[i].name)

free (fdef->exports[i].name);

if (fdef->exports[i].its_name)

free (fdef->exports[i].its_name);

}

free (fdef->exports);

}

if (fdef->imports)

{

for (i = 0; i < fdef->num_imports; i++)

{

if (fdef->imports[i].internal_name

&& fdef->imports[i].internal_name != fdef->imports[i].name)

free (fdef->imports[i].internal_name);

if (fdef->imports[i].name)

free (fdef->imports[i].name);

if (fdef->imports[i].its_name)

free (fdef->imports[i].its_name);

}

free (fdef->imports);

}

while (fdef->modules)

{

def_file_module *m = fdef->modules;

fdef->modules = fdef->modules->next;

free (m);

}

while (fdef->aligncomms)

{

def_file_aligncomm *c = fdef->aligncomms;

fdef->aligncomms = fdef->aligncomms->next;

free (c->symbol_name);

free (c);

}

free (fdef);

}

#ifdef DEF_FILE_PRINT

void

def_file_print (FILE *file, def_file *fdef)

{

int i;

fprintf (file, ">>>> def_file at 0x%08x\n", fdef);

if (fdef->name)

fprintf (file, " name: %s\n", fdef->name ? fdef->name : "(unspecified)");

if (fdef->is_dll != -1)

fprintf (file, " is dll: %s\n", fdef->is_dll ? "yes" : "no");

if (fdef->base_address != (bfd_vma) -1)

{

fprintf (file, " base address: 0x");

fprintf_vma (file, fdef->base_address);

fprintf (file, "\n");

}

if (fdef->description)

fprintf (file, " description: `%s'\n", fdef->description);

if (fdef->stack_reserve != -1)

fprintf (file, " stack reserve: 0x%08x\n", fdef->stack_reserve);

if (fdef->stack_commit != -1)

fprintf (file, " stack commit: 0x%08x\n", fdef->stack_commit);

if (fdef->heap_reserve != -1)

fprintf (file, " heap reserve: 0x%08x\n", fdef->heap_reserve);

if (fdef->heap_commit != -1)

fprintf (file, " heap commit: 0x%08x\n", fdef->heap_commit);

if (fdef->num_section_defs > 0)

{

fprintf (file, " section defs:\n");

for (i = 0; i < fdef->num_section_defs; i++)

{

fprintf (file, " name: `%s', class: `%s', flags:",

fdef->section_defs[i].name, fdef->section_defs[i].class);

if (fdef->section_defs[i].flag_read)

fprintf (file, " R");

if (fdef->section_defs[i].flag_write)

fprintf (file, " W");

if (fdef->section_defs[i].flag_execute)

fprintf (file, " X");

if (fdef->section_defs[i].flag_shared)

fprintf (file, " S");

fprintf (file, "\n");

}

}

if (fdef->num_exports > 0)

{

fprintf (file, " exports:\n");

for (i = 0; i < fdef->num_exports; i++)

{

fprintf (file, " name: `%s', int: `%s', ordinal: %d, flags:",

fdef->exports[i].name, fdef->exports[i].internal_name,

fdef->exports[i].ordinal);

if (fdef->exports[i].flag_private)

fprintf (file, " P");

if (fdef->exports[i].flag_constant)

fprintf (file, " C");

if (fdef->exports[i].flag_noname)

fprintf (file, " N");

if (fdef->exports[i].flag_data)

fprintf (file, " D");

fprintf (file, "\n");

}

}

if (fdef->num_imports > 0)

{

fprintf (file, " imports:\n");

for (i = 0; i < fdef->num_imports; i++)

{

fprintf (file, " int: %s, from: `%s', name: `%s', ordinal: %d\n",

fdef->imports[i].internal_name,

fdef->imports[i].module,

fdef->imports[i].name,

fdef->imports[i].ordinal);

}

}

if (fdef->version_major != -1)

fprintf (file, " version: %d.%d\n", fdef->version_major, fdef->version_minor);

fprintf (file, "<<<< def_file at 0x%08x\n", fdef);

}

#endif

static int

are_names_equal (const char *s1, const char *s2)

{

if (!s1 && !s2)

return 0;

if (!s1 || !s2)

return (!s1 ? -1 : 1);

return strcmp (s1, s2);

}

static int

cmp_export_elem (const def_file_export *e, const char *ex_name,

const char *in_name, const char *its_name,

int ord)

{

int r;

if ((r = are_names_equal (ex_name, e->name)) != 0)

return r;

if ((r = are_names_equal (in_name, e->internal_name)) != 0)

return r;

if ((r = are_names_equal (its_name, e->its_name)) != 0)

return r;

return (ord - e->ordinal);

}

static int

find_export_in_list (def_file_export *b, int max,

const char *ex_name, const char *in_name,

const char *its_name, int ord, int *is_ident)

{

int e, l, r, p;

*is_ident = 0;

if (!max)

return 0;

if ((e = cmp_export_elem (b, ex_name, in_name, its_name, ord)) <= 0)

{

if (!e)

*is_ident = 1;

return 0;

}

if (max == 1)

return 1;

if ((e = cmp_export_elem (b + (max - 1), ex_name, in_name, its_name, ord)) > 0)

return max;

else if (!e || max == 2)

{

if (!e)

*is_ident = 1;

return max - 1;

}

l = 0; r = max - 1;

while (l < r)

{

p = (l + r) / 2;

e = cmp_export_elem (b + p, ex_name, in_name, its_name, ord);

if (!e)

{

*is_ident = 1;

return p;

}

else if (e < 0)

r = p - 1;

else if (e > 0)

l = p + 1;

}

if ((e = cmp_export_elem (b + l, ex_name, in_name, its_name, ord)) > 0)

++l;

else if (!e)

*is_ident = 1;

return l;

}

def_file_export *

def_file_add_export (def_file *fdef,

const char *external_name,

const char *internal_name,

int ordinal,

const char *its_name,

int *is_dup)

{

def_file_export *e;

int pos;

int max_exports = ROUND_UP(fdef->num_exports, 32);

if (internal_name && !external_name)

external_name = internal_name;

if (external_name && !internal_name)

internal_name = external_name;

/* We need to avoid duplicates. */

*is_dup = 0;

pos = find_export_in_list (fdef->exports, fdef->num_exports,

external_name, internal_name,

its_name, ordinal, is_dup);

if (*is_dup != 0)

return (fdef->exports + pos);

if (fdef->num_exports >= max_exports)

{

max_exports = ROUND_UP(fdef->num_exports + 1, 32);

if (fdef->exports)

fdef->exports = xrealloc (fdef->exports,

max_exports * sizeof (def_file_export));

else

fdef->exports = xmalloc (max_exports * sizeof (def_file_export));

}

e = fdef->exports + pos;

if (pos != fdef->num_exports)

memmove (&e[1], e, (sizeof (def_file_export) * (fdef->num_exports - pos)));

memset (e, 0, sizeof (def_file_export));

e->name = xstrdup (external_name);

e->internal_name = xstrdup (internal_name);

e->its_name = (its_name ? xstrdup (its_name) : NULL);

e->ordinal = ordinal;

fdef->num_exports++;

return e;

}

def_file_module *

def_get_module (def_file *fdef, const char *name)

{

def_file_module *s;

for (s = fdef->modules; s; s = s->next)

if (strcmp (s->name, name) == 0)

return s;

return NULL;

}

static def_file_module *

def_stash_module (def_file *fdef, const char *name)

{

def_file_module *s;

if ((s = def_get_module (fdef, name)) != NULL)

return s;

s = xmalloc (sizeof (def_file_module) + strlen (name));

s->next = fdef->modules;

fdef->modules = s;

s->user_data = 0;

strcpy (s->name, name);

return s;

}

static int

cmp_import_elem (const def_file_import *e, const char *ex_name,

const char *in_name, const char *module,

int ord)

{

int r;

if ((r = are_names_equal (module, (e->module ? e->module->name : NULL))))

return r;

if ((r = are_names_equal (ex_name, e->name)) != 0)

return r;

if ((r = are_names_equal (in_name, e->internal_name)) != 0)

return r;

if (ord != e->ordinal)

return (ord < e->ordinal ? -1 : 1);

return 0;

}

static int

find_import_in_list (def_file_import *b, int max,

const char *ex_name, const char *in_name,

const char *module, int ord, int *is_ident)

{

int e, l, r, p;

*is_ident = 0;

if (!max)

return 0;

if ((e = cmp_import_elem (b, ex_name, in_name, module, ord)) <= 0)

{

if (!e)

*is_ident = 1;

return 0;

}

if (max == 1)

return 1;

if ((e = cmp_import_elem (b + (max - 1), ex_name, in_name, module, ord)) > 0)

return max;

else if (!e || max == 2)

{

if (!e)

*is_ident = 1;

return max - 1;

}

l = 0; r = max - 1;

while (l < r)

{

p = (l + r) / 2;

e = cmp_import_elem (b + p, ex_name, in_name, module, ord);

if (!e)

{

*is_ident = 1;

return p;

}

else if (e < 0)

r = p - 1;

else if (e > 0)

l = p + 1;

}

if ((e = cmp_import_elem (b + l, ex_name, in_name, module, ord)) > 0)

++l;

else if (!e)

*is_ident = 1;

return l;

}

static void

fill_in_import (def_file_import *i,

const char *name,

def_file_module *module,

int ordinal,

const char *internal_name,

const char *its_name)

{

memset (i, 0, sizeof (def_file_import));

if (name)

i->name = xstrdup (name);

i->module = module;

i->ordinal = ordinal;

if (internal_name)

i->internal_name = xstrdup (internal_name);

else

i->internal_name = i->name;

i->its_name = (its_name ? xstrdup (its_name) : NULL);

}

def_file_import *

def_file_add_import (def_file *fdef,

const char *name,

const char *module,

int ordinal,

const char *internal_name,

const char *its_name,

int *is_dup)

{

def_file_import *i;

int pos;

int max_imports = ROUND_UP (fdef->num_imports, 16);

/* We need to avoid here duplicates. */

*is_dup = 0;

pos = find_import_in_list (fdef->imports, fdef->num_imports,

name,

(!internal_name ? name : internal_name),

module, ordinal, is_dup);

if (*is_dup != 0)

return fdef->imports + pos;

if (fdef->num_imports >= max_imports)

{

max_imports = ROUND_UP (fdef->num_imports+1, 16);

if (fdef->imports)

fdef->imports = xrealloc (fdef->imports,

max_imports * sizeof (def_file_import));

else

fdef->imports = xmalloc (max_imports * sizeof (def_file_import));

}

i = fdef->imports + pos;

if (pos != fdef->num_imports)

memmove (i + 1, i, sizeof (def_file_import) * (fdef->num_imports - pos));

fill_in_import (i, name, def_stash_module (fdef, module), ordinal,

internal_name, its_name);

fdef->num_imports++;

return i;

}

int

def_file_add_import_from (def_file *fdef,

int num_imports,

const char *name,

const char *module,

int ordinal,

const char *internal_name,

const char *its_name ATTRIBUTE_UNUSED)

{

def_file_import *i;

int is_dup;

int pos;

int max_imports = ROUND_UP (fdef->num_imports, 16);

/* We need to avoid here duplicates. */

is_dup = 0;

pos = find_import_in_list (fdef->imports, fdef->num_imports,

name, internal_name ? internal_name : name,

module, ordinal, &is_dup);

if (is_dup != 0)

return -1;

if (fdef->imports && pos != fdef->num_imports)

{

i = fdef->imports + pos;

if (i->module && strcmp (i->module->name, module) == 0)

return -1;

}

if (fdef->num_imports + num_imports - 1 >= max_imports)

{

max_imports = ROUND_UP (fdef->num_imports + num_imports, 16);

if (fdef->imports)

fdef->imports = xrealloc (fdef->imports,

max_imports * sizeof (def_file_import));

else

fdef->imports = xmalloc (max_imports * sizeof (def_file_import));

}

i = fdef->imports + pos;

if (pos != fdef->num_imports)

memmove (i + num_imports, i,

sizeof (def_file_import) * (fdef->num_imports - pos));

return pos;

}

def_file_import *

def_file_add_import_at (def_file *fdef,

int pos,

const char *name,

const char *module,

int ordinal,

const char *internal_name,

const char *its_name)

{

def_file_import *i = fdef->imports + pos;

fill_in_import (i, name, def_stash_module (fdef, module), ordinal,

internal_name, its_name);

fdef->num_imports++;

return i;

}

struct

{

char *param;

int token;

}

diropts[] =

{

{ "-heap", HEAPSIZE },

{ "-stack", STACKSIZE_K },

{ "-attr", SECTIONS },

{ "-export", EXPORTS },

{ "-aligncomm", ALIGNCOMM },

{ 0, 0 }

};

void

def_file_add_directive (def_file *my_def, const char *param, int len)

{

def_file *save_def = def;

const char *pend = param + len;

char * tend = (char *) param;

int i;

def = my_def;

while (param < pend)

{

while (param < pend

&& (ISSPACE (*param) || *param == '\n' || *param == 0))

param++;

if (param == pend)

break;

/* Scan forward until we encounter any of:

for (tend = (char *) (param + 1);

(tend < pend

&& !(ISSPACE (tend[-1]) && *tend == '-')

&& *tend != '\n' && *tend != 0);

tend++)

;

for (i = 0; diropts[i].param; i++)

{

len = strlen (diropts[i].param);

if (tend - param >= len

&& strncmp (param, diropts[i].param, len) == 0

&& (param[len] == ':' || param[len] == ' '))

{

lex_parse_string_end = tend;