?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Update window URI when its binding is redirected.
[wine/multimedia.git] / tools / wmc / mcy.y
blob54403d5f8989b1eb8594b41ebbd0533692561d8d
1 /*
2 * Wine Message Compiler parser
3 *
4 * Copyright 2000 Bertho A. Stultiens (BS)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * NOTES:
21 *
22 * The basic grammar of the file is yet another example of, humpf,
23 * design. There is a mix of context-insensitive and -sensitive
24 * stuff, which makes it rather complicated.
25 * The header definitions are all context-insensitive because they have
26 * delimited arguments, whereas the message headers are (semi-) context-
27 * sensitive and the messages themselves are, well, RFC82[12] delimited.
28 * This mixture seems to originate from the time that ms and ibm were
29 * good friends and developing os/2 according to the "compatibility"
30 * switch and reading some comments here and there.
31 *
32 * I'll ignore most of the complications and concentrate on the concept
33 * which allows me to use yacc. Basically, everything is context-
34 * insensitive now, with the exception of the message-text itself and
35 * the preceding language declaration.
36 *
37 */
38
39 %{
40
41 #include "config.h"
42
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <assert.h>
46
47 #include "utils.h"
48 #include "wmc.h"
49 #include "lang.h"
50
51 static const char err_syntax[] = "Syntax error";
52 static const char err_number[] = "Number expected";
53 static const char err_ident[] = "Identifier expected";
54 static const char err_assign[] = "'=' expected";
55 static const char err_popen[] = "'(' expected";
56 static const char err_pclose[] = "')' expected";
57 static const char err_colon[] = "':' expected";
58 static const char err_msg[] = "Message expected";
59
60 /* Scanner switches */
61 int want_nl = 0; /* Request next newlinw */
62 int want_line = 0; /* Request next complete line */
63 int want_file = 0; /* Request next ident as filename */
64
65 node_t *nodehead = NULL; /* The list of all parsed elements */
66 static node_t *nodetail = NULL;
67 lan_blk_t *lanblockhead; /* List of parsed elements transposed */
68
69 static int base = 16; /* Current printout base to use (8, 10 or 16) */
70 static WCHAR *cast = NULL; /* Current typecast to use */
71
72 static int last_id = 0; /* The last message ID parsed */
73 static int last_sev = 0; /* Last severity code parsed */
74 static int last_fac = 0; /* Last facility code parsed */
75 static WCHAR *last_sym = NULL;/* Last alias symbol parsed */
76 static int have_sev; /* Set if severity parsed for current message */
77 static int have_fac; /* Set if facility parsed for current message */
78 static int have_sym; /* Set is symbol parsed for current message */
79
80 static cp_xlat_t *cpxlattab = NULL; /* Codepage translation table */
81 static int ncpxlattab = 0;
82
83 /* Prototypes */
84 static WCHAR *merge(WCHAR *s1, WCHAR *s2);
85 static lanmsg_t *new_lanmsg(lan_cp_t *lcp, WCHAR *msg);
86 static msg_t *add_lanmsg(msg_t *msg, lanmsg_t *lanmsg);
87 static msg_t *complete_msg(msg_t *msg, int id);
88 static void add_node(node_e type, void *p);
89 static void do_add_token(tok_e type, token_t *tok, const char *code);
90 static void test_id(int id);
91 static int check_languages(node_t *head);
92 static lan_blk_t *block_messages(node_t *head);
93 static void add_cpxlat(int lan, int cpin, int cpout);
94 static cp_xlat_t *find_cpxlat(int lan);
95
96 %}
97
98 %union {
99 WCHAR *str;
100 unsigned num;
101 token_t *tok;
102 lanmsg_t *lmp;
103 msg_t *msg;
104 lan_cp_t lcp;
105 }
106
107
108 %token tSEVNAMES tFACNAMES tLANNAMES tBASE tCODEPAGE
109 %token tTYPEDEF tNL tSYMNAME tMSGEND
110 %token tSEVERITY tFACILITY tLANGUAGE tMSGID
111 %token <str> tIDENT tLINE tFILE tCOMMENT
112 %token <num> tNUMBER
113 %token <tok> tTOKEN
114
115 %type <str> alias lines
116 %type <num> optcp id msgid clan
117 %type <tok> token
118 %type <lmp> body
119 %type <msg> bodies msg
120 %type <lcp> lang
121
122 %%
123 file : items {
124 if(!check_languages(nodehead))
125 xyyerror("No messages defined\n");
126 lanblockhead = block_messages(nodehead);
127 }
128 ;
129
130 items : decl
131 | items decl
132 ;
133
134 decl : global
135 | msg { add_node(nd_msg, $1); }
136 | tCOMMENT { add_node(nd_comment, $1); }
137 | error { xyyerror(err_syntax); /* `Catch all' error */ }
138 ;
139
140 global : tSEVNAMES '=' '(' smaps ')'
141 | tSEVNAMES '=' '(' smaps error { xyyerror(err_pclose); }
142 | tSEVNAMES '=' error { xyyerror(err_popen); }
143 | tSEVNAMES error { xyyerror(err_assign); }
144 | tFACNAMES '=' '(' fmaps ')'
145 | tFACNAMES '=' '(' fmaps error { xyyerror(err_pclose); }
146 | tFACNAMES '=' error { xyyerror(err_popen); }
147 | tFACNAMES error { xyyerror(err_assign); }
148 | tLANNAMES '=' '(' lmaps ')'
149 | tLANNAMES '=' '(' lmaps error { xyyerror(err_pclose); }
150 | tLANNAMES '=' error { xyyerror(err_popen); }
151 | tLANNAMES error { xyyerror(err_assign); }
152 | tCODEPAGE '=' '(' cmaps ')'
153 | tCODEPAGE '=' '(' cmaps error { xyyerror(err_pclose); }
154 | tCODEPAGE '=' error { xyyerror(err_popen); }
155 | tCODEPAGE error { xyyerror(err_assign); }
156 | tTYPEDEF '=' tIDENT { cast = $3; }
157 | tTYPEDEF '=' error { xyyerror(err_number); }
158 | tTYPEDEF error { xyyerror(err_assign); }
159 | tBASE '=' tNUMBER {
160 switch(base)
161 {
162 case 8:
163 case 10:
164 case 16:
165 base = $3;
166 break;
167 default:
168 xyyerror("Numberbase must be 8, 10 or 16\n");
169 }
170 }
171 | tBASE '=' error { xyyerror(err_number); }
172 | tBASE error { xyyerror(err_assign); }
173 ;
174
175 /*----------------------------------------------------------------------
176 * SeverityNames mapping
177 */
178 smaps : smap
179 | smaps smap
180 | error { xyyerror(err_ident); }
181 ;
182
183 smap : token '=' tNUMBER alias {
184 $1->token = $3;
185 $1->alias = $4;
186 if($3 & (~0x3))
187 xyyerror("Severity value out of range (0x%08x > 0x3)\n", $3);
188 do_add_token(tok_severity, $1, "severity");
189 }
190 | token '=' error { xyyerror(err_number); }
191 | token error { xyyerror(err_assign); }
192 ;
193
194 /*----------------------------------------------------------------------
195 * FacilityNames mapping
196 */
197 fmaps : fmap
198 | fmaps fmap
199 | error { xyyerror(err_ident); }
200 ;
201
202 fmap : token '=' tNUMBER alias {
203 $1->token = $3;
204 $1->alias = $4;
205 if($3 & (~0xfff))
206 xyyerror("Facility value out of range (0x%08x > 0xfff)\n", $3);
207 do_add_token(tok_facility, $1, "facility");
208 }
209 | token '=' error { xyyerror(err_number); }
210 | token error { xyyerror(err_assign); }
211 ;
212
213 alias : /* Empty */ { $$ = NULL; }
214 | ':' tIDENT { $$ = $2; }
215 | ':' error { xyyerror(err_ident); }
216 ;
217
218 /*----------------------------------------------------------------------
219 * LanguageNames mapping
220 */
221 lmaps : lmap
222 | lmaps lmap
223 | error { xyyerror(err_ident); }
224 ;
225
226 lmap : token '=' tNUMBER setfile ':' tFILE optcp {
227 $1->token = $3;
228 $1->alias = $6;
229 $1->codepage = $7;
230 do_add_token(tok_language, $1, "language");
231 if(!find_language($3) && !find_cpxlat($3))
232 mcy_warning("Language 0x%x not built-in, using codepage %d; use explicit codepage to override\n", $3, WMC_DEFAULT_CODEPAGE);
233 }
234 | token '=' tNUMBER setfile ':' error { xyyerror("Filename expected\n"); }
235 | token '=' tNUMBER error { xyyerror(err_colon); }
236 | token '=' error { xyyerror(err_number); }
237 | token error { xyyerror(err_assign); }
238 ;
239
240 optcp : /* Empty */ { $$ = 0; }
241 | ':' tNUMBER { $$ = $2; }
242 | ':' error { xyyerror("Codepage-number expected\n"); }
243 ;
244
245 /*----------------------------------------------------------------------
246 * Codepages mapping
247 */
248 cmaps : cmap
249 | cmaps cmap
250 | error { xyyerror(err_ident); }
251 ;
252
253 cmap : clan '=' tNUMBER ':' tNUMBER {
254 static const char err_nocp[] = "Codepage %d not builtin; cannot convert\n";
255 if(find_cpxlat($1))
256 xyyerror("Codepage translation already defined for language 0x%x\n", $1);
257 if($3 && $3 != CP_UTF8 && !find_codepage($3))
258 xyyerror(err_nocp, $3);
259 if($5 && $5 != CP_UTF8 && !find_codepage($5))
260 xyyerror(err_nocp, $5);
261 add_cpxlat($1, $3, $5);
262 }
263 | clan '=' tNUMBER ':' error { xyyerror(err_number); }
264 | clan '=' tNUMBER error { xyyerror(err_colon); }
265 | clan '=' error { xyyerror(err_number); }
266 | clan error { xyyerror(err_assign); }
267 ;
268
269 clan : tNUMBER { $$ = $1; }
270 | tTOKEN {
271 if($1->type != tok_language)
272 xyyerror("Language name or code expected\n");
273 $$ = $1->token;
274 }
275 ;
276
277 /*----------------------------------------------------------------------
278 * Message-definition parsing
279 */
280 msg : msgid sevfacsym { test_id($1); } bodies { $$ = complete_msg($4, $1); }
281 ;
282
283 msgid : tMSGID '=' id {
284 if($3 & (~0xffff))
285 xyyerror("Message ID value out of range (0x%08x > 0xffff)\n", $3);
286 $$ = $3;
287 }
288 | tMSGID error { xyyerror(err_assign); }
289 ;
290
291 id : /* Empty */ { $$ = ++last_id; }
292 | tNUMBER { $$ = last_id = $1; }
293 | '+' tNUMBER { $$ = last_id += $2; }
294 | '+' error { xyyerror(err_number); }
295 ;
296
297 sevfacsym: /* Empty */ { have_sev = have_fac = have_sym = 0; }
298 | sevfacsym sev { if(have_sev) xyyerror("Severity already defined\n"); have_sev = 1; }
299 | sevfacsym fac { if(have_fac) xyyerror("Facility already defined\n"); have_fac = 1; }
300 | sevfacsym sym { if(have_sym) xyyerror("Symbolname already defined\n"); have_sym = 1; }
301 ;
302
303 sym : tSYMNAME '=' tIDENT { last_sym = $3; }
304 | tSYMNAME '=' error { xyyerror(err_ident); }
305 | tSYMNAME error { xyyerror(err_assign); }
306 ;
307
308 sev : tSEVERITY '=' token {
309 token_t *tok = lookup_token($3->name);
310 if(!tok)
311 xyyerror("Undefined severityname\n");
312 if(tok->type != tok_severity)
313 xyyerror("Identifier is not of class 'severity'\n");
314 last_sev = tok->token;
315 }
316 | tSEVERITY '=' error { xyyerror(err_ident); }
317 | tSEVERITY error { xyyerror(err_assign); }
318 ;
319
320 fac : tFACILITY '=' token {
321 token_t *tok = lookup_token($3->name);
322 if(!tok)
323 xyyerror("Undefined facilityname\n");
324 if(tok->type != tok_facility)
325 xyyerror("Identifier is not of class 'facility'\n");
326 last_fac = tok->token;
327 }
328 | tFACILITY '=' error { xyyerror(err_ident); }
329 | tFACILITY error { xyyerror(err_assign); }
330 ;
331
332 /*----------------------------------------------------------------------
333 * Message-text parsing
334 */
335 bodies : body { $$ = add_lanmsg(NULL, $1); }
336 | bodies body { $$ = add_lanmsg($1, $2); }
337 | error { xyyerror("'Language=...' (start of message text-definition) expected\n"); }
338 ;
339
340 body : lang setline lines tMSGEND { $$ = new_lanmsg(&$1, $3); }
341 ;
342
343 /*
344 * The newline is to be able to set the codepage
345 * to the language based codepage for the next
346 * message to be parsed.
347 */
348 lang : tLANGUAGE setnl '=' token tNL {
349 token_t *tok = lookup_token($4->name);
350 cp_xlat_t *cpx;
351 if(!tok)
352 xyyerror("Undefined language\n");
353 if(tok->type != tok_language)
354 xyyerror("Identifier is not of class 'language'\n");
355 if((cpx = find_cpxlat(tok->token)))
356 {
357 set_codepage($$.codepage = cpx->cpin);
358 }
359 else if(!tok->codepage)
360 {
361 const language_t *lan = find_language(tok->token);
362 if(!lan)
363 {
364 /* Just set default; warning was given while parsing languagenames */
365 set_codepage($$.codepage = WMC_DEFAULT_CODEPAGE);
366 }
367 else
368 {
369 /* The default seems to be to use the DOS codepage... */
370 set_codepage($$.codepage = lan->doscp);
371 }
372 }
373 else
374 set_codepage($$.codepage = tok->codepage);
375 $$.language = tok->token;
376 }
377 | tLANGUAGE setnl '=' token error { xyyerror("Missing newline\n"); }
378 | tLANGUAGE setnl '=' error { xyyerror(err_ident); }
379 | tLANGUAGE error { xyyerror(err_assign); }
380 ;
381
382 lines : tLINE { $$ = $1; }
383 | lines tLINE { $$ = merge($1, $2); }
384 | error { xyyerror(err_msg); }
385 | lines error { xyyerror(err_msg); }
386 ;
387
388 /*----------------------------------------------------------------------
389 * Helper rules
390 */
391 token : tIDENT { $$ = xmalloc(sizeof(token_t)); memset($$,0,sizeof(*$$)); $$->name = $1; }
392 | tTOKEN { $$ = $1; }
393 ;
394
395 setnl : /* Empty */ { want_nl = 1; }
396 ;
397
398 setline : /* Empty */ { want_line = 1; }
399 ;
400
401 setfile : /* Empty */ { want_file = 1; }
402 ;
403
404 %%
405
406 static WCHAR *merge(WCHAR *s1, WCHAR *s2)
407 {
408 int l1 = unistrlen(s1);
409 int l2 = unistrlen(s2);
410 s1 = xrealloc(s1, (l1 + l2 + 1) * sizeof(*s1));
411 unistrcpy(s1+l1, s2);
412 free(s2);
413 return s1;
414 }
415
416 static void do_add_token(tok_e type, token_t *tok, const char *code)
417 {
418 token_t *tp = lookup_token(tok->name);
419 if(tp)
420 {
421 if(tok->type != type)
422 mcy_warning("Type change in token\n");
423 if(tp != tok)
424 xyyerror("Overlapping token not the same\n");
425 /* else its already defined and changed */
426 if(tok->fixed)
427 xyyerror("Redefinition of %s\n", code);
428 tok->fixed = 1;
429 }
430 else
431 {
432 add_token(type, tok->name, tok->token, tok->codepage, tok->alias, 1);
433 free(tok);
434 }
435 }
436
437 static lanmsg_t *new_lanmsg(lan_cp_t *lcp, WCHAR *msg)
438 {
439 lanmsg_t *lmp = xmalloc(sizeof(lanmsg_t));
440 lmp->lan = lcp->language;
441 lmp->cp = lcp->codepage;
442 lmp->msg = msg;
443 lmp->len = unistrlen(msg) + 1; /* Include termination */
444 lmp->file = input_name;
445 lmp->line = line_number;
446 if(lmp->len > 4096)
447 mcy_warning("Message exceptionally long; might be a missing termination\n");
448 return lmp;
449 }
450
451 static msg_t *add_lanmsg(msg_t *msg, lanmsg_t *lanmsg)
452 {
453 int i;
454 if(!msg)
455 {
456 msg = xmalloc(sizeof(msg_t));
457 memset( msg, 0, sizeof(*msg) );
458 }
459 msg->msgs = xrealloc(msg->msgs, (msg->nmsgs+1) * sizeof(*(msg->msgs)));
460 msg->msgs[msg->nmsgs] = lanmsg;
461 msg->nmsgs++;
462 for(i = 0; i < msg->nmsgs-1; i++)
463 {
464 if(msg->msgs[i]->lan == lanmsg->lan)
465 xyyerror("Message for language 0x%x already defined\n", lanmsg->lan);
466 }
467 return msg;
468 }
469
470 static int sort_lanmsg(const void *p1, const void *p2)
471 {
472 return (*(const lanmsg_t * const *)p1)->lan - (*(const lanmsg_t * const*)p2)->lan;
473 }
474
475 static msg_t *complete_msg(msg_t *mp, int id)
476 {
477 assert(mp != NULL);
478 mp->id = id;
479 if(have_sym)
480 mp->sym = last_sym;
481 else
482 xyyerror("No symbolic name defined for message id %d\n", id);
483 mp->sev = last_sev;
484 mp->fac = last_fac;
485 qsort(mp->msgs, mp->nmsgs, sizeof(*(mp->msgs)), sort_lanmsg);
486 mp->realid = id | (last_sev << 30) | (last_fac << 16);
487 if(custombit)
488 mp->realid |= 1 << 29;
489 mp->base = base;
490 mp->cast = cast;
491 return mp;
492 }
493
494 static void add_node(node_e type, void *p)
495 {
496 node_t *ndp = xmalloc(sizeof(node_t));
497 memset( ndp, 0, sizeof(*ndp) );
498 ndp->type = type;
499 ndp->u.all = p;
500
501 if(nodetail)
502 {
503 ndp->prev = nodetail;
504 nodetail->next = ndp;
505 nodetail = ndp;
506 }
507 else
508 {
509 nodehead = nodetail = ndp;
510 }
511 }
512
513 static void test_id(int id)
514 {
515 node_t *ndp;
516 for(ndp = nodehead; ndp; ndp = ndp->next)
517 {
518 if(ndp->type != nd_msg)
519 continue;
520 if(ndp->u.msg->id == id && ndp->u.msg->sev == last_sev && ndp->u.msg->fac == last_fac)
521 xyyerror("MessageId %d with facility 0x%x and severity 0x%x already defined\n", id, last_fac, last_sev);
522 }
523 }
524
525 static int check_languages(node_t *head)
526 {
527 static const char err_missing[] = "Missing definition for language 0x%x; MessageID %d, facility 0x%x, severity 0x%x\n";
528 node_t *ndp;
529 int nm = 0;
530 msg_t *msg = NULL;
531
532 for(ndp = head; ndp; ndp = ndp->next)
533 {
534 if(ndp->type != nd_msg)
535 continue;
536 if(!nm)
537 {
538 msg = ndp->u.msg;
539 }
540 else
541 {
542 int i;
543 msg_t *m1;
544 msg_t *m2;
545 if(ndp->u.msg->nmsgs > msg->nmsgs)
546 {
547 m1 = ndp->u.msg;
548 m2 = msg;
549 }
550 else
551 {
552 m1 = msg;
553 m2 = ndp->u.msg;
554 }
555
556 for(i = 0; i < m1->nmsgs; i++)
557 {
558 if(i > m2->nmsgs)
559 error(err_missing, m1->msgs[i]->lan, m2->id, m2->fac, m2->sev);
560 else if(m1->msgs[i]->lan < m2->msgs[i]->lan)
561 error(err_missing, m1->msgs[i]->lan, m2->id, m2->fac, m2->sev);
562 else if(m1->msgs[i]->lan > m2->msgs[i]->lan)
563 error(err_missing, m2->msgs[i]->lan, m1->id, m1->fac, m1->sev);
564 }
565 }
566 nm++;
567 }
568 return nm;
569 }
570
571 #define MSGRID(x) ((*(const msg_t * const*)(x))->realid)
572 static int sort_msg(const void *p1, const void *p2)
573 {
574 return MSGRID(p1) > MSGRID(p2) ? 1 : (MSGRID(p1) == MSGRID(p2) ? 0 : -1);
575 /* return (*(msg_t **)p1)->realid - (*(msg_t **)p1)->realid; */
576 }
577
578 /*
579 * block_messages() basically transposes the messages
580 * from ID/language based list to a language/ID
581 * based list.
582 */
583 static lan_blk_t *block_messages(node_t *head)
584 {
585 lan_blk_t *lbp;
586 lan_blk_t *lblktail = NULL;
587 lan_blk_t *lblkhead = NULL;
588 msg_t **msgtab = NULL;
589 node_t *ndp;
590 int nmsg = 0;
591 int i;
592 int nl;
593 int factor = unicodeout ? 2 : 1;
594
595 for(ndp = head; ndp; ndp = ndp->next)
596 {
597 if(ndp->type != nd_msg)
598 continue;
599 msgtab = xrealloc(msgtab, (nmsg+1) * sizeof(*msgtab));
600 msgtab[nmsg++] = ndp->u.msg;
601 }
602
603 assert(nmsg != 0);
604 qsort(msgtab, nmsg, sizeof(*msgtab), sort_msg);
605
606 for(nl = 0; nl < msgtab[0]->nmsgs; nl++) /* This should be equal for all after check_languages() */
607 {
608 lbp = xmalloc(sizeof(lan_blk_t));
609 memset( lbp, 0, sizeof(*lbp) );
610 if(!lblktail)
611 {
612 lblkhead = lblktail = lbp;
613 }
614 else
615 {
616 lblktail->next = lbp;
617 lbp->prev = lblktail;
618 lblktail = lbp;
619 }
620 lbp->nblk = 1;
621 lbp->blks = xmalloc(sizeof(*lbp->blks));
622 lbp->blks[0].idlo = msgtab[0]->realid;
623 lbp->blks[0].idhi = msgtab[0]->realid;
624 /* The plus 4 is the entry header; (+3)&~3 is DWORD alignment */
625 lbp->blks[0].size = ((factor * msgtab[0]->msgs[nl]->len + 3) & ~3) + 4;
626 lbp->blks[0].msgs = xmalloc(sizeof(*lbp->blks[0].msgs));
627 lbp->blks[0].nmsg = 1;
628 lbp->blks[0].msgs[0] = msgtab[0]->msgs[nl];
629 lbp->lan = msgtab[0]->msgs[nl]->lan;
630
631 for(i = 1; i < nmsg; i++)
632 {
633 block_t *blk = &(lbp->blks[lbp->nblk-1]);
634 if(msgtab[i]->realid == blk->idhi+1)
635 {
636 blk->size += ((factor * msgtab[i]->msgs[nl]->len + 3) & ~3) + 4;
637 blk->idhi++;
638 blk->msgs = xrealloc(blk->msgs, (blk->nmsg+1) * sizeof(*blk->msgs));
639 blk->msgs[blk->nmsg++] = msgtab[i]->msgs[nl];
640 }
641 else
642 {
643 lbp->nblk++;
644 lbp->blks = xrealloc(lbp->blks, lbp->nblk * sizeof(*lbp->blks));
645 blk = &(lbp->blks[lbp->nblk-1]);
646 blk->idlo = msgtab[i]->realid;
647 blk->idhi = msgtab[i]->realid;
648 blk->size = ((factor * msgtab[i]->msgs[nl]->len + 3) & ~3) + 4;
649 blk->msgs = xmalloc(sizeof(*blk->msgs));
650 blk->nmsg = 1;
651 blk->msgs[0] = msgtab[i]->msgs[nl];
652 }
653 }
654 }
655 free(msgtab);
656 return lblkhead;
657 }
658
659 static int sc_xlat(const void *p1, const void *p2)
660 {
661 return ((const cp_xlat_t *)p1)->lan - ((const cp_xlat_t *)p2)->lan;
662 }
663
664 static void add_cpxlat(int lan, int cpin, int cpout)
665 {
666 cpxlattab = xrealloc(cpxlattab, (ncpxlattab+1) * sizeof(*cpxlattab));
667 cpxlattab[ncpxlattab].lan = lan;
668 cpxlattab[ncpxlattab].cpin = cpin;
669 cpxlattab[ncpxlattab].cpout = cpout;
670 ncpxlattab++;
671 qsort(cpxlattab, ncpxlattab, sizeof(*cpxlattab), sc_xlat);
672 }
673
674 static cp_xlat_t *find_cpxlat(int lan)
675 {
676 cp_xlat_t t;
677
678 if(!cpxlattab) return NULL;
679
680 t.lan = lan;
681 return (cp_xlat_t *)bsearch(&t, cpxlattab, ncpxlattab, sizeof(*cpxlattab), sc_xlat);
682 }
Maarten's multimedia branch