source: trunk/libs/newlib/src/newlib/libc/iconv/ccs/mktbl.pl @ 444

Last change on this file since 444 was 444, checked in by satin@…, 6 years ago

add newlib,libalmos-mkh, restructure shared_syscalls.h and mini-libc
File size: 38.7 KB
Line 
1#!/usr/bin/perl -w
2#
3#  Copyright (c) 2003-2004, Artem B. Bityuckiy, SoftMine Corporation.
4#
5#  Redistribution and use in source and binary forms, with or without
6#  modification, are permitted provided that the following conditions
7#  are met:
8#  1. Redistributions of source code must retain the above copyright
9#     notice, this list of conditions and the following disclaimer.
10#  2. Redistributions in binary form must reproduce the above copyright
11#     notice, this list of conditions and the following disclaimer in the
12#     documentation and/or other materials provided with the distribution.
13#
14#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15#  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17#  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18#  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19#  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20#  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21#  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22#  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23#  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24#  SUCH DAMAGE.
25#
26use integer;
27use Getopt::Std;
28use IO::Seekable;
29use strict;
30
31
32# ##############################################################################
33#
34# FUNCTION PROTOTYPES AND GLOBAL DATA DECLARATION SECTION
35#
36# ##############################################################################
37
38
39# SUPPLEMENTARY FUNCTIONS FORWARD DECLARATIONS
40sub ProcessOptions();
41sub Err($;$);
42sub Generate8bitToUCS();
43sub GenerateSpeed($);
44sub Generate16bitSize($);
45sub Output8bitToUCS(;$);
46sub Output8bitFromUCS(;$);
47sub OutputSpeed($;$);
48sub OutputSize($;$);
49
50# VARIABLES RELATING TO COMMAND-LINE OPTIONS
51my $Verbose;  # Be verbose if true
52my $Source;   # Output C source code instead of binary .cct file if true
53my $Plane;    # Use this plane if defined
54my $InFile;   # Use this file for input
55my $OutFile;  # Use this file for output
56my $CCSName;  # Use this CCS name
57my $NoSpeed;  # Don't generate speed-optimized tables (binary files only)
58my $NoSize;   # Don't generate size-optimized tables (binary files only)
59my $NoBE;     # Don't generate big-endian tables (binary files only)
60my $NoLE;     # Don't generate big-endian tables (binary files only)
61my $NoTo;     # Don't generate "to_ucs" table (binary files only)
62my $NoFrom;   # Don't generate "from_ucs" table (binary files only)
63my $CCSCol;   # CCS column number in source file
64my $UCSCol;   # UCS column number in source file
65
66
67# DATA STRUCTURES WITH "TO_UCS" AND "FROM_UCS" SPEED/SIZE -OPTIMIZED TABLES
68my (@FromSpeedTbl, @ToSpeedTbl, @FromSizeTbl, @ToSizeTbl);
69# "TO_UCS" AND "FROM_UCS" SPEED/SIZE -OPTIMIZED TABLES SIZE IN BYTES
70my ($FromSpeedBytes, $ToSpeedBytes, $FromSizeBytes, $ToSizeBytes) =
71   (0, 0, 0, 0);
72
73my (%CCSUCS, %UCSCCS); # CCS->UCS and UCS->CCS mappings
74my $Bits = 8;          # Table bits (8 or 16);
75
76# SPECIAL MARKER CODES
77my $InvCode  = 0xFFFF; # FFFF indicates 18 bit invalid codes
78my $InvBlock = 0xFFFF; # FFFF also mark empty blocks in speed-optimized tables
79my $LostCode = 0x3F;   # ASCII '?' marks codes lost during CCS->UCS mapping
80# To mark invalid codes in 8bit encodings 0xFF is used CCS's 0xFF mapping is saved
81# separately. $FFMap variable stores real 0xFF mapping if defined.
82my $InvCode8bit = 0xFF;
83my $FFMap;
84
85# 8 Bit "From UCS" table header size (bytes)
86my $Hdr8bitFromUCS = 2;
87# Binary table header size (bytes)
88my $HdrBinary = 8;
89
90# At first all lost CCS codes are marked by $TmpLost to distinguish between
91# code which is equivalent to $LostCode and lost codes. This is done in order to
92# output $MacroLostCode instead of $LostCode in source file.
93my $TmpLost = 0x1FFFF;
94
95# VARIABLES RELATING TO C SOURCE CODE
96my $MacroInvCode      = 'INVALC';
97my $MacroInvBlock     = 'INVBLK';
98my $MacroLostCode     = 'LOST_C';
99my $MacroCCSName      = 'ICONV_CCS_%s';
100my $GuardSize       = 'defined (TABLE_USE_SIZE_OPTIMIZATION)';
101my $GuardToUCS      = "ICONV_TO_UCS_CCS_%s";
102my $GuardFromUCS    = "ICONV_FROM_UCS_CCS_%s";
103my $MacroSpeedTable = 'TABLE_SPEED_OPTIMIZED';
104my $MacroSizeTable  = 'TABLE_SIZE_OPTIMIZED'; 
105my $Macro8bitTable  = 'TABLE_8BIT';
106my $Macro16bitTable = 'TABLE_16BIT';
107my $MacroVer1Table  = 'TABLE_VERSION_1';
108my $TypeBICCS       = 'iconv_ccs_t';
109my $VarToUCSSize    = "to_ucs_size_%s";
110my $VarToUCSSpeed   = "to_ucs_speed_%s";
111my $VarFromUCSSize  = "from_ucs_size_%s";
112my $VarFromUCSSpeed = "from_ucs_speed_%s";
113my $VarBICCS             = "_iconv_ccs_%s";
114# Text block that visually separates tables.
115my $Separator = '=' x 70;
116
117# ##############################################################################
118#
119# SCRIPT ENTRY POINT
120#
121# ##############################################################################
122
123
124# Parse command-line options, check them and set correspondent global variables
125ProcessOptions();
126
127# Initialize global variables tat depend on CCS name.
128$_ = sprintf $_, $CCSName foreach +($VarToUCSSpeed,
129                                    $VarToUCSSize,
130                                    $VarToUCSSpeed,
131                                    $VarFromUCSSpeed,
132                                    $VarFromUCSSize,
133                                    $VarBICCS);
134$_ = sprintf $_, "\U$CCSName" foreach +($GuardToUCS,
135                                        $GuardFromUCS,
136                                        $MacroCCSName);
137
138# Open input and output files
139Err "Can't open \"$InFile\" file for reading: $!.\n", 1
140unless open(INFILE, '<', $InFile);
141Err "Can't open \"$OutFile\" file for writing: $!.\n", 1
142unless open(OUTFILE, '>', $OutFile);
143
144# ==============================================================================
145# EXTRACT CODES MAP FROM INPUT FILE
146# ==============================================================================
147
148for (my $ln = 1; my $l = <INFILE>; $ln += 1)
149{
150  # Skip comment and empty lines, remove ending CR symbol
151  next if $l =~ /^#.*$/ or $l =~ /^\s*$/;
152  $l =~ s/^(.*)\n$/$1/, $l =~ s/^(.*)\r$/$1/;
153 
154  # Remove comment and extra spaces
155  $l =~ s/(.*)\s*#.*/$1/;
156  $l =~ s/\s+/ /g;
157  $l =~ s/(.*)\s*$/$1/;
158
159  # Split line into individual codes
160  my @codes = split / /, $l;
161
162  # Skip line if there is no needed columns
163  unless (defined $codes[$CCSCol])
164  {
165    print("Warning (line $ln): no CCS column, skip.\n") if $Verbose;
166    next;
167  }
168  unless (defined $codes[$UCSCol])
169  {
170    print("Warning (line $ln): no UCS column, skip.\n") if $Verbose;
171    next;
172  }
173
174  # Extract codes strings from needed columns
175  my ($ccs, $ucs) = ($codes[$CCSCol], $codes[$UCSCol]);
176  my $patt = qr/(0[xX])?[0-9a-fA-F]{1,8}/; # HEX digit regexp pattern.
177
178  # Check that CCS and UCS code strings has right format.
179  unless ($ccs =~ m/^$patt$/)
180  {
181    print("Warning (line $ln): $ccs CCS code isn't recognized, skip.\n")
182    if $Verbose;
183    next;
184  }
185  unless ($ucs =~ m/^($patt(,|\+))*$patt$/)
186  {
187    print("Warning (line $ln): $ucs UCS code isn't recognized, skip.\n")
188    if $Verbose;
189    next;
190  }
191
192  # Convert code to numeric format (assume hex).
193  $ccs = hex $ccs;
194
195  if ($ucs =~ m/,/ or $ucs =~ m/\+/)
196  {
197    # Mark CCS codes with "one to many" mappings as lost
198    printf "Warning (line $ln): only one to one mapping is supported, "
199         . "mark 0x%.4X CCS code as lost.\n", hex $ccs if $Verbose;
200    $ucs = $TmpLost;
201  }
202  else
203  {
204    # Convert code to numeric format
205    $ucs = hex $ucs;
206
207    # Check that UCS code isn't longer than 16 bits.
208    if ($ucs > 0xFFFF)
209    {
210      printf("Warning (line $ln): UCS code should fit 16 bits, "
211           . "mark 0x%.4X CCS code as lost.\n", hex $ccs) if $Verbose;
212      $ucs = $TmpLost;
213    }
214  }
215
216  # If CCS value > 0xFFFF user should specify plane number.
217  if ($ccs > 0xFFFF && !defined $Plane)
218  {
219    print("Warning (line $ln): $ccs is > 16 bit, plane number should be specified,"
220        . " skip this mapping.\n") if $Verbose;
221    next;
222  }
223 
224  if (defined $Plane)
225  {
226    next if (($ccs & 0xFFFF0000) >> 16) != hex $Plane; # Skip alien plane.
227    $ccs &= 0xFFFF;
228  }
229
230  # Check that reserved codes aren't used.
231  if ($ccs == $InvCode or $ucs == $InvCode)
232  {
233    print("Warning (line $ln): $InvCode is reserved to mark invalid codes and "
234       . "shouldn't be used in mappings, skip.\n") if $Verbose;
235    next;
236  }
237
238  # Save mapping in UCSCCS and CCSUCS hash arrays.
239  $UCSCCS{$ucs} = $ccs if $ucs != $TmpLost && !defined $UCSCCS{$ucs};
240  $CCSUCS{$ccs} = $ucs if !defined $CCSUCS{$ccs};
241
242  $Bits = 16 if $ccs > 0xFF;
243}
244
245if (not %CCSUCS)
246{
247  Err "Error: there is no plane $Plane in \"$0\".\n" if defined $Plane;
248  Err "Error: mapping wasn't found.\n";
249}
250
251
252# ==============================================================================
253# GENERATE TABLE DATA
254# ==============================================================================
255
256if ($Bits == 8)
257{
258  $FFMap = $CCSUCS{0xFF};
259  $FFMap = $InvCode if !defined $FFMap; 
260}
261
262if ($Bits == 8)
263{
264  Generate8bitToUCS() unless $NoTo;
265}
266else
267{
268  GenerateSpeed("to_ucs") unless $NoTo || $NoSpeed;
269  Generate16bitSize("to_ucs")  unless $NoTo || $NoSize;
270}
271
272GenerateSpeed("from_ucs") unless $NoFrom || $NoSpeed;
273Generate16bitSize("from_ucs")  unless $NoFrom || $NoSize;
274
275# ==============================================================================
276# OUTPUT ARRAYS
277# ==============================================================================
278
279if ($Source)
280{
281  # OUTPUT SOURCE
282  print OUTFILE
283"/*
284 * This file was generated automatically - don't edit it.
285 * File contains iconv CCS tables for $CCSName encoding.
286 */
287
288#include \"ccsbi.h\"
289
290#if defined ($GuardToUCS) \\
291 || defined ($GuardFromUCS)
292
293#include <_ansi.h>
294#include <sys/types.h>
295#include <sys/param.h>
296#include \"ccs.h\"
297#include \"ccsnames.h\"
298
299";
300
301  if ($Bits == 8)
302  {
303    print OUTFILE
304"#if (BYTE_ORDER == LITTLE_ENDIAN)
305#  define W(word) (word) & 0xFF, (word) >> 8
306#elif (BYTE_ORDER == BIG_ENDIAN)
307#  define W(word) (word) >> 8, (word) & 0xFF
308#else
309#  error \"Unknown byte order.\"
310#endif
311
312";
313  }
314
315  unless ($NoTo)
316  {
317    if ($Bits == 8) 
318    {
319      Output8bitToUCS();
320    }
321    else
322    {
323      OutputSpeed("to_ucs") unless $NoSpeed;
324      OutputSize("to_ucs")  unless $NoSize;
325    }
326  }
327  unless ($NoFrom)
328  {
329    if ($Bits == 8) 
330    {
331      Output8bitFromUCS();
332    }
333    else
334    {
335      OutputSpeed("from_ucs") unless $NoSpeed;
336      OutputSize("from_ucs")  unless $NoSize;
337    }
338  }
339
340  # OUTPUT TABLE DESCRIPTION STRUCTURE
341  print OUTFILE 
342"/*
343 * $CCSName CCS description table.
344 * $Separator
345 */
346const $TypeBICCS
347$VarBICCS =
348{
349\t$MacroVer1Table, /* Table version */
350\t$MacroCCSName, /* CCS name */
351";
352  if ($Bits == 8)
353  {
354    print OUTFILE
355"\t$Macro8bitTable, /* Table bits */
356\t0, /* Not Used */
357#if defined ($GuardFromUCS)
358\t(__uint16_t *)&$VarFromUCSSpeed, /* UCS -> $CCSName table */
359#else
360\t(__uint16_t *)NULL,
361#endif
362\t0, /* Not Used */
363#if defined ($GuardToUCS)
364\t(__uint16_t *)&$VarToUCSSpeed /* $CCSName -> UCS table */
365#else
366\t(__uint16_t *)NULL,
367#endif
368};\n";
369  }
370  else
371  {
372    print OUTFILE
373"\t$Macro16bitTable, /* Table bits */
374#if defined ($GuardFromUCS) \\
375 && ($GuardSize)
376\t$MacroSizeTable,
377\t(__uint16_t *)&$VarFromUCSSize, /* UCS -> $CCSName table size-optimized table */
378#elif defined ($GuardFromUCS) \\
379 && !($GuardSize)
380\t$MacroSpeedTable,
381\t(__uint16_t *)&$VarFromUCSSpeed, /* UCS -> $CCSName table speed-optimized table */
382#else
383\t$MacroSpeedTable,
384\t(__uint16_t *)NULL,
385#endif
386#if defined ($GuardToUCS) \\
387 && ($GuardSize)
388\t$MacroSizeTable,
389\t(__uint16_t *)&$VarToUCSSize /* $CCSName -> UCS table speed-optimized table */
390#elif defined ($GuardToUCS) \\
391 && !($GuardSize)
392\t$MacroSpeedTable,
393\t(__uint16_t *)&$VarToUCSSpeed /* $CCSName -> UCS table speed-optimized table */
394#else
395\t$MacroSpeedTable,
396\t(__uint16_t *)NULL,
397#endif
398};\n";
399  }
400  print OUTFILE "\n#endif /* $GuardToUCS) || ... */\n\n";
401}
402else
403{
404  # OUTPUT BINARY TABLES DESCRIPTION STRUCTURE (ALWAYS BIG ENDIAN)
405  print OUTFILE pack "n", 1;
406  print OUTFILE pack "n", $Bits;
407  my $len = length $CCSName;
408  print OUTFILE pack "N", $len;
409  print OUTFILE pack "a$len", $CCSName;
410 
411  my $pos = $HdrBinary + $len;
412  if ($pos & 3)
413  {
414    my $l = 4 - ($pos & 3);
415    print OUTFILE pack "a$l", 'XXX';
416    $pos += $l;
417  }
418 
419  $pos += 16*4;
420
421  my @tables;
422  for (my $i = 0; $i < 16; $i++)
423  {
424    $tables[$i] = 0;
425  }
426 
427  $tables[0] = $pos, $tables[1] = $FromSpeedBytes, $pos += $FromSpeedBytes
428  unless $NoFrom || $NoSpeed || $NoBE;
429  $tables[2] = $pos, $tables[3] = $FromSpeedBytes, $pos += $FromSpeedBytes
430  unless $NoFrom || $NoSpeed || $NoLE;
431  if ($Bits == 16)
432  {
433    $tables[4] = $pos, $tables[5] = $FromSizeBytes, $pos += $FromSizeBytes
434    unless $NoFrom || $NoSize || $NoBE;
435    $tables[6] = $pos, $tables[7] = $FromSizeBytes, $pos += $FromSizeBytes
436    unless $NoFrom || $NoSize || $NoLE;
437  }
438  $tables[8] = $pos, $tables[9] = $ToSpeedBytes, $pos += $ToSpeedBytes
439  unless $NoTo || $NoSpeed || $NoBE;
440  $tables[10] = $pos, $tables[11] = $ToSpeedBytes, $pos += $ToSpeedBytes
441  unless $NoTo || $NoSpeed || $NoLE;
442  if ($Bits == 16)
443  {
444    $tables[12] = $pos, $tables[13] = $ToSizeBytes, $pos += $ToSizeBytes
445    unless $NoTo || $NoSize || $NoBE;
446    $tables[14] = $pos, $tables[15] = $ToSizeBytes, $pos += $ToSizeBytes
447    unless $NoTo || $NoSize || $NoLE;
448  }
449
450  print OUTFILE pack("N", $_) foreach @tables;
451
452  print "Total bytes for output: $pos.\n" if $Verbose;
453 
454  # OUTPUT BINARY TABLES
455  unless ($NoFrom)
456  {
457    if ($Bits == 8) 
458    {
459      Output8bitFromUCS("n") unless $NoBE;
460      Output8bitFromUCS("v") unless $NoLE;
461    }
462    else
463    {
464      unless ($NoSpeed)
465      {
466        OutputSpeed("from_ucs", "n") unless $NoBE;
467        OutputSpeed("from_ucs", "v") unless $NoLE;
468      }
469      unless ($NoSize)
470      {
471        OutputSize("from_ucs", "n") unless $NoBE;
472        OutputSize("from_ucs", "v") unless $NoLE;
473      }
474    }
475  }
476  unless ($NoTo)
477  {
478    if ($Bits == 8) 
479    {
480      Output8bitToUCS("n") unless $NoBE;
481      Output8bitToUCS("v") unless $NoLE;
482    }
483    else
484    {
485      unless ($NoSpeed)
486      {
487        OutputSpeed("to_ucs", "n") unless $NoBE;
488        OutputSpeed("to_ucs", "v") unless $NoLE;
489      }
490      unless ($NoSize)
491      {
492        OutputSize("to_ucs", "n") unless $NoBE;
493        OutputSize("to_ucs", "v") unless $NoLE;
494      }
495    }
496  }
497}
498
499close INFILE;
500close OUTFILE;
501exit 0;
502
503
504# ##############################################################################
505#
506# SUPPLEMENTARY FUNCTIONS
507#
508# ##############################################################################
509
510
511# =============================================================================
512#
513# Generate 8bit "to_ucs" table. Store table data in %ToSpeedTbl hash.
514# Store table size in $ToSpeedBytes scalar.
515#
516# =============================================================================
517sub Generate8bitToUCS()
518{
519  for (my $i = 0; $i <= 255; $i++)
520  {
521    $ToSpeedTbl[$i] = defined $CCSUCS{$i} ? $CCSUCS{$i} : $InvCode;
522  }
523  $ToSpeedBytes = 256*2;
524}
525
526
527# =============================================================================
528#
529# Generate speed-optimized table.
530#
531# Parameter 1:
532#    "to_ucs"   - generate "to_ucs" table, store table data in @ToSpeedTbl
533#                 array, store table size in $ToSpeedBytes scalar.
534#    "from_ucs" - generate "from_ucs" table, store table data in @FromSpeedTbl
535#                 array, store table size in $FromSpeedBytes scalar.
536#
537# Data is written to @ToSpeedTbl or @FromSpeedTbl (@map) table and has the
538# following format:
539# $table[0] - 256-element array (control block);
540# $table[1 .. $#table] - 256-element arrays (data blocks).
541#
542# =============================================================================
543sub GenerateSpeed($)
544{
545  my $map;
546  my $tbl;
547  my $bytes;
548 
549  if ($_[0] eq "to_ucs")
550  {
551    $map = \%CCSUCS;
552    $tbl = \@ToSpeedTbl;
553    $bytes = \$ToSpeedBytes;
554  }
555  elsif ($_[0] eq "from_ucs")
556  {
557    $map = \%UCSCCS;
558    $tbl = \@FromSpeedTbl;
559    $bytes = \$FromSpeedBytes;
560  }
561  else
562  {
563    Err "Internal script error in GenerateSpeed()\n";
564  }
565 
566  # Identify unused blocks
567  my @busy_blocks;
568  $busy_blocks[$_ >> 8] = 1 foreach (keys %$map);
569
570  # GENERATE FIRST 256-ELEMENT CONTROL BLOCK
571  for (my $i = 0,
572       my $idx = $Bits == 16 ? 0 : 256 + $Hdr8bitFromUCS;
573       $i <= 0xFF; $i++)
574  {
575    $tbl->[0]->[$i] = $busy_blocks[$i] ? $idx += 256 : undef;
576  }
577
578  # GENERATE DATA BLOCKS
579  $$bytes = 0;
580  for (my $i = 0; $i <= 0xFF; $i++)
581  {
582    next unless $busy_blocks[$i];
583    $$bytes += 256;
584    for (my $j = 0; $j <= 0xFF; $j++)
585    {
586      $tbl->[$i+1]->[$j] = $map->{($i << 8) | $j};
587    }
588  } 
589  $$bytes *= 2 if $Bits == 16;
590  $$bytes += $Hdr8bitFromUCS if $Bits == 8;
591  $$bytes += 512;
592}
593
594
595# =============================================================================
596#
597# Generate 16bit size-optimized table.
598#
599# Parameter 1:
600#    "to_ucs"   - generate "to_ucs" table, store table data in @ToSizeTbl
601#                 array, store table size in $ToSizeBytes scalar.
602#    "from_ucs" - generate "from_ucs" table, store table data in @FromSizeTbl
603#                 array, store table size in $FromSizeBytes scalar.
604#
605# Data is written to @ToSizeTbl or @FromSizeTbl (@map) table and has the
606# following format:
607# $table[0] - number of ranges;
608# $table[1] - number of unranged codes;
609# $table[2] - unranged codes index in resulting array;
610# $table[3]->[0 .. $table[0]] - array of arrays of ranges:
611#     $table[3]->[x]->[0] - first code;
612#     $table[3]->[x]->[1] - last code;
613#     $table[3]->[x]->[2] - range index in resulting array;
614# $table[4]->[0 .. $table[0]] - array of arrays of ranges content;
615# $table[5]->[0 .. $table[1]] - array of arrays of unranged codes;
616#     $table[5]->[x]->[0] - CCS code;
617#     $table[5]->[x]->[0] - UCS code;
618#
619# =============================================================================
620sub Generate16bitSize($)
621{
622  my $map;
623  my $tbl;
624  my $bytes;
625 
626  if ($_[0] eq "to_ucs")
627  {
628    $map = \%CCSUCS;
629    $tbl = \@ToSizeTbl;
630    $bytes = \$ToSizeBytes;
631  }
632  elsif ($_[0] eq "from_ucs")
633  {
634    $map = \%UCSCCS;
635    $tbl = \@FromSizeTbl;
636    $bytes = \$FromSizeBytes;
637  }
638  else
639  {
640    Err "Internal script error  Generate16bitSize()\n";
641  }
642
643  # CREATE LIST OF RANGES.
644  my @codes = sort {$a <=> $b} keys %$map;
645  my @ranges;  # Code ranges
646  my @range;   # Current working range
647  foreach (@codes)
648  {
649    if (not @range or $_ - 1 == $range[$#range])
650    {
651      push @range, $_;
652    }
653    else
654    {
655      my @tmp = @range;
656      push @ranges, \@tmp;
657      undef @range;
658      redo;
659    }
660  }
661  # Add Last range too
662  if (@range)
663  {
664    my @tmp = @range;
665    push @ranges, \@tmp;
666  }
667
668  # OPTIMIZE LIST OF RANGES.
669  my $r = 0; # Working range number
670  while (1)
671  {
672    last if ($r == $#ranges);
673
674    my @r1 = @{$ranges[$r]};
675    my @r2 = @{$ranges[$r + 1]};
676
677    # Calculate how many array entries two ranges need
678    my ($s1, $s2);
679
680    if ($#r1 == 0)
681    { $s1 = 2; }
682    elsif ($#r1 == 1)
683    { $s1 = 4; }
684    else
685    { $s1 = $#r1 + 1 + 3; }
686   
687    if ($#r2 == 0)
688    { $s2 = 2; }
689    elsif ($#r2 == 1)
690    { $s2 = 4; }
691    else
692    { $s2 = $#r2 + 1 + 3; }
693
694    my $two = $s1 + $s2;
695
696    # Calculate how many array entries will be needed if we join them
697    my $one = $r2[$#r2] - $r1[0] + 1 + 3;
698
699    $r += 1, next if ($one > $two);
700   
701    # Join ranges
702    my @r; # New range.
703    push @r, $_ foreach (@r1);
704    for (my $i = $r1[$#r1]+1; $i < $r2[0]; $i++)
705    {
706      push @r, undef; 
707    }
708    push @r, $_ foreach (@r2);
709    $ranges[$r] = \@r;
710    splice @ranges, $r+1, 1;
711  }
712
713  # SEPARATE RANGED AND UNRANGED CODES. SPLIT 2-CODES RANGES ON 2 UNRANGED.
714  my @unranged;
715  foreach (@ranges)
716  {
717    if ($#$_ == 0)
718    {
719      push @unranged, $$_[0];
720      undef $_;
721    }
722    elsif ($#$_ == 1)
723    {
724      push @unranged, $$_[0];
725      push @unranged, $$_[1];
726      undef $_;
727    }
728  }
729
730  # DELETE UNUSED ELEMENTS
731  for (my $i = 0; $i <= $#ranges; $i++)
732  {
733    splice @ranges, $i--, 1 unless defined $ranges[$i];
734  }
735
736  # CALCULATE UNRANGED CODES ARRAY INDEX
737  my $idx = 3 + ($#ranges + 1)*3;
738  $idx += $#$_ + 1 foreach @ranges;
739
740  # COMPOSE TABLE
741  $tbl->[0] = $#ranges + 1;   # Number of ranges
742  $tbl->[1] = $#unranged + 1; # Number of unranged codes
743  $tbl->[2] = $idx;           # Array index of unranged codes
744 
745  # Generate ranges list
746  $idx = 3 + ($#ranges + 1)*3; # First range data index
747  $$bytes = $idx*2;
748  my $num = 0;
749  foreach (@ranges)
750  {
751    $tbl->[3]->[$num]->[0] = $_->[0];
752    $tbl->[3]->[$num]->[1] = $_->[$#$_];
753    $tbl->[3]->[$num]->[2] = $idx;
754    $idx += $#$_ + 1;
755    $num += 1;
756  }
757
758  # Generate ranges content
759  $num = 0;
760  foreach (@ranges)
761  {
762    for (my $i = 0; $i <= $#$_; $i++)
763    {
764      $tbl->[4]->[$num]->[$i] = defined $_->[$i] ? $map->{$_->[$i]} : undef;
765    }
766    $num += 1;
767    $$bytes += ($#$_ + 1)*2;
768  }
769
770  # Generate unranged codes list
771  $num = 0;
772  foreach (@unranged)
773  {
774    $tbl->[5]->[$num]->[0] = $_;
775    $tbl->[5]->[$num]->[1] = $map->{$_};
776    $num += 1;
777  }
778
779  $$bytes += ($#unranged + 1)*4;
780} 
781
782
783# =============================================================================
784#
785# Output 8bit "to UCS" table. Output table's source code if $Source
786# and table's binary data if !$Source.
787#
788# Parameter 1: Not used when sources are output. Output BE binary if 'n' and
789#              LE binary if 'v'.
790#
791# =============================================================================
792sub Output8bitToUCS(;$)
793{
794  my $endian = $_[0];
795  my $br = 0;
796
797  printf "Output%s 8-bit UCS -> $CCSName table ($ToSpeedBytes bytes).\n",
798         defined $endian ? ($endian eq 'n' ? 
799                 " Big Endian" : " Little Endian") : "" if $Verbose;
800  if ($Source)
801  {
802    # Output heading information
803    printf OUTFILE
804"/*
805 * 8-bit $CCSName -> UCS table ($ToSpeedBytes bytes).
806 * $Separator
807 */
808#if defined ($GuardToUCS)
809
810static const __uint16_t
811${VarToUCSSpeed}\[] =
812{\n\t";
813  }
814
815  if ($Source)
816  {
817    foreach (@ToSpeedTbl)
818    {
819      $br += 1;
820      if ($_ != $InvCode)
821      {
822        if ($_ != $TmpLost)
823        {
824          printf OUTFILE "0x%.4X,", $_;
825        }
826        else
827        {
828          print OUTFILE "$MacroLostCode,";
829        }
830      }
831      else
832      {
833        print OUTFILE "$MacroInvCode,";
834      }
835      print(OUTFILE "\n\t"), $br = 0 unless $br % 8;
836    }
837    print OUTFILE "\n};\n\n#endif /* $GuardToUCS */\n\n";
838  }
839  else
840  {
841    foreach (@ToSpeedTbl)
842    {
843      print OUTFILE pack($endian, $_ == $TmpLost ? $LostCode : $_);
844    }
845  }
846}
847
848
849# =============================================================================
850#
851# Output 8bit "from UCS" table. Output table's source code if $Source
852# and table's binary data if !$Source.
853#
854# Parameter 1: Not used when sources are output. Output BE binary if 'n' and
855#              LE binary if 'v'.
856#
857# =============================================================================
858sub Output8bitFromUCS(;$)
859{
860  my $endian = $_[0];
861
862  printf "Output%s 8-bit $CCSName -> UCS table ($FromSpeedBytes bytes).\n",
863         defined $endian ? ($endian eq 'n' ? 
864                 " Big Endian" : " Little Endian") : "" if $Verbose;
865  if ($Source)
866  {
867    print OUTFILE
868"/*
869 * 8-bit UCS -> $CCSName speed-optimized table ($FromSpeedBytes bytes).
870 * $Separator
871 */
872
873#if defined ($GuardFromUCS)
874
875static const unsigned char
876${VarFromUCSSpeed}\[] =
877{
878";
879  }
880
881  # SAVE 0xFF MAPPING.
882  if ($Source)
883  {
884    printf OUTFILE "\tW(0x%.4X), /* Real 0xFF mapping. 0xFF is used "
885                 . "to mark invalid codes */\n", $FFMap;
886  }
887  else
888  {
889    print OUTFILE pack($endian, $FFMap);
890  }
891
892  # OUTPUT HEADING BLOCK (ALWAYS 16 BIT)
893  if ($Source)
894  {
895    my $count = 0;
896    print OUTFILE "\t/* Heading Block */";
897    for (my $i = 0, my $br = 0; $i < 256; $br = ++$i % 4)
898    {
899      print OUTFILE "\n\t" unless $br;
900      if (defined $FromSpeedTbl[0]->[$i])
901      {
902        printf OUTFILE "W(0x%.4X),", $FromSpeedTbl[0]->[$i];
903      }
904      else
905      {
906        print OUTFILE "W($MacroInvBlock),";
907      }
908    }
909  }
910  else
911  {
912    print OUTFILE pack($endian, defined $_ ? $_ : $InvBlock)
913    foreach @{$FromSpeedTbl[0]};
914  }
915
916  if ($Source)
917  {
918    my $index = 512 + $Hdr8bitFromUCS;
919    for (my $blk = 1; $blk <= $#FromSpeedTbl; $blk++)
920    {
921      next unless defined $FromSpeedTbl[$blk];
922      printf OUTFILE "\n\t/* Block $blk, Array index 0x%.4X */", $index;
923      $index += 256;
924      for (my $i = 0, my $br = 0; $i < 256; $i++, $br = $i % 8)
925      {
926        print OUTFILE "\n\t" unless $br;
927        my $code = $FromSpeedTbl[$blk]->[$i];
928        if (!defined $code)
929        {
930          printf OUTFILE "0x%.2X,", $InvCode8bit;
931        }
932        else
933        {
934          printf OUTFILE "0x%.2X,", $code == $TmpLost ? $LostCode : $code;
935        }
936      }
937    }
938    print OUTFILE "\n};\n\n#endif /* $GuardFromUCS */\n\n";
939  }
940  else
941  {
942    for (my $blk = 1; $blk <= $#FromSpeedTbl; $blk++)
943    {
944      next unless defined $FromSpeedTbl[$blk];
945      for (my $i = 0, my $br = 0; $i < 256; $br = ++$i % 8)
946      {
947        my $code = $FromSpeedTbl[$blk]->[$i];
948        if (!defined $code)
949        {
950          printf OUTFILE pack 'C', $InvCode8bit;
951        }
952        else
953        {
954          print OUTFILE $code == $TmpLost ? pack('C', $LostCode) 
955                                          : pack('C', $code);
956        }
957      }
958    }
959  }
960}
961
962
963# =============================================================================
964#
965# Output 16bit Speed-optimized table. Output table's source code if $Source
966# and table's binary data if !$Source.
967#
968# Parameter 1:
969#    "to_ucs"   - Output "to_ucs" table.
970#    "from_ucs" - Output "from_ucs" table.
971# Parameter 2:    Not used when sources are output. Output BE binary if 'n' and
972#                 LE binary if 'v'.
973#
974# =============================================================================
975sub OutputSpeed($;$)
976{
977  my $endian = $_[1];
978  my $tbl;
979  my ($direction, $optimiz, $e, $bytes);
980  $optimiz = $Bits == 16 ? " speed-optimized" : "";
981  $e = $endian ? ($endian eq 'n' ? " Big Endian" : " Little Endian") : "";
982  if ($_[0] eq "to_ucs")
983  {
984    $tbl = \@ToSpeedTbl;
985    $direction = " $CCSName -> UCS";
986    $bytes = $ToSpeedBytes;
987
988    if ($Source)
989    {
990      print OUTFILE
991"/*
992 * 16-bit $CCSName -> UCS speed-optimized table ($ToSpeedBytes bytes).
993 * $Separator
994 */
995#if defined ($GuardToUCS) \\
996 && !($GuardSize)
997
998static const __uint16_t
999${VarToUCSSpeed}\[] =
1000{
1001";
1002    }
1003  }
1004  elsif ($_[0] eq "from_ucs")
1005  {
1006    $tbl = \@FromSpeedTbl;
1007    $direction = " UCS -> $CCSName";
1008    $bytes = $FromSpeedBytes;
1009   
1010    if ($Source)
1011    {
1012      print OUTFILE
1013"/*
1014 * 16-bit UCS -> $CCSName speed-optimized table ($FromSpeedBytes bytes).
1015 * $Separator
1016 */
1017
1018#if defined ($GuardFromUCS) \\
1019 && !($GuardSize)
1020
1021static const __uint16_t
1022${VarFromUCSSpeed}\[] =
1023{
1024";
1025    }
1026  }
1027  else
1028  {
1029    Err "Internal script error  Output16bitSpeed()\n";
1030  }
1031
1032  printf "Output%s 16-bit%s%s table (%d bytes).\n",
1033  $e, $direction, $optimiz, $bytes if $Verbose;
1034
1035  # OUTPUT HEADING BLOCK (ALWAYS 16 BIT)
1036  if ($Source)
1037  {
1038    my $count = 0;
1039    print OUTFILE "\t/* Heading Block */";
1040    for (my $i = 0, my $br = 0; $i < 256; $br = ++$i % 8)
1041    {
1042      print OUTFILE "\n\t" unless $br;
1043      if (defined $tbl->[0]->[$i])
1044      {
1045        printf OUTFILE "0x%.4X,", $tbl->[0]->[$i];
1046      }
1047      else
1048      {
1049        print OUTFILE "$MacroInvBlock,";
1050      }
1051    }
1052  }
1053  else
1054  {
1055    print OUTFILE pack($endian, defined $_ ? $_ : $InvBlock)
1056    foreach @{$tbl->[0]};
1057  }
1058
1059  # OUTPUT OTHER BLOCKS
1060  if ($Source)
1061  {
1062    my $index = 256;
1063    for (my $blk = 1; $blk <= $#$tbl; $blk++)
1064    {
1065      next unless defined $tbl->[$blk];
1066      printf OUTFILE "\n\t/* Block $blk, Array index 0x%.4X */", $index;
1067      $index += 256;
1068      for (my $i = 0, my $br = 0; $i < 256; $br = ++$i % 8)
1069      {
1070        print OUTFILE "\n\t" unless $br;
1071        my $code = $tbl->[$blk]->[$i];
1072        print OUTFILE defined $code ? 
1073            ($code == $TmpLost ? $MacroLostCode : sprintf "0x%.4X", $code)
1074                                     : $MacroInvCode, ",";
1075      }
1076    }
1077  }
1078  else
1079  {
1080    for (my $blk = 1; $blk <= $#$tbl; $blk++)
1081    {
1082      next unless defined $tbl->[$blk];
1083      for (my $i = 0, my $br = 0; $i < 256; $br = ++$i % 8)
1084      {
1085        my $code = $tbl->[$blk]->[$i];
1086        print OUTFILE pack($endian, 
1087          defined $code ? ($code == $TmpLost ? $LostCode : $code) : $InvCode);
1088      }
1089    }
1090  }
1091
1092  if ($Source)
1093  {
1094    if ($_[0] eq "to_ucs")
1095    {
1096      print OUTFILE
1097"
1098};
1099
1100#endif /* $GuardToUCS && !$GuardSize */
1101
1102";
1103    }
1104    else
1105    {
1106      print OUTFILE
1107"
1108};
1109
1110#endif /* $GuardFromUCS && !$GuardSize */
1111
1112";
1113    }
1114  }
1115}
1116
1117# =============================================================================
1118#
1119# Output 16bit Size-optimized table. Output table's source code if $Source
1120# and table's binary data if !$Source.
1121#
1122# Parameter 1:
1123#    "to_ucs"   - Output "to_ucs" table.
1124#    "from_ucs" - Output "from_ucs" table.
1125# Parameter 2:    Not used when sources are output. Output BE binary if 'n' and
1126#                 LE binary if 'v'.
1127#
1128# =============================================================================
1129sub OutputSize($;$)
1130{
1131  my $endian = $_[1];
1132  my $tbl;
1133  my ($direction, $optimiz, $e, $bytes);
1134  $optimiz = $Bits == 16 ? " size-optimized" : "";
1135  $e = $endian ? ($endian eq 'n' ? " Big Endian" : " Little Endian") : "";
1136  if ($_[0] eq "to_ucs")
1137  {
1138    $tbl = \@ToSizeTbl;
1139    $direction = " $CCSName -> UCS";
1140    $bytes = $ToSizeBytes;
1141
1142    if ($Source)
1143    {
1144      print OUTFILE
1145"/*
1146 * 16-bit $CCSName -> UCS size-optimized table ($ToSizeBytes bytes).
1147 * $Separator
1148 */
1149#if defined ($GuardToUCS) \\
1150 && ($GuardSize)
1151
1152static const __uint16_t
1153${VarToUCSSize}\[] =
1154{
1155";
1156    }
1157  }
1158  elsif ($_[0] eq "from_ucs")
1159  {
1160    $tbl = \@FromSizeTbl;
1161    $direction = " UCS -> $CCSName";
1162    $bytes = $FromSizeBytes;
1163    if ($Source)
1164    {
1165      print OUTFILE
1166"/*
1167 * 16-bit UCS -> $CCSName size-optimized table ($FromSizeBytes bytes).
1168 * $Separator
1169 */
1170
1171#if defined ($GuardFromUCS) \\
1172 && ($GuardSize)
1173
1174static const __uint16_t
1175${VarFromUCSSize}\[] =
1176{
1177";
1178    }
1179  }
1180  else
1181  {
1182    Err "Internal script error  Output16bitSize()\n";
1183  }
1184
1185  printf "Output%s 16-bit%s%s table (%d bytes).\n",
1186  $e, $direction, $optimiz, $bytes if $Verbose;
1187
1188  # OUTPUT FIRST 3 ELEMENTS
1189  if ($Source)
1190  {
1191    printf OUTFILE "\t0x%.4X, /* Ranges number */\n", $tbl->[0];
1192    printf OUTFILE "\t0x%.4X, /* Unranged codes number */\n", $tbl->[1];
1193    printf OUTFILE "\t0x%.4X, /* First unranged code index */\n", $tbl->[2];
1194  }
1195  else
1196  {
1197    printf OUTFILE pack $endian, $tbl->[0];
1198    printf OUTFILE pack $endian, $tbl->[1];
1199    printf OUTFILE pack $endian, $tbl->[2];
1200  }
1201
1202  my $idx = 0;
1203  # OUTPUT RANGES
1204  if ($Source)
1205  {
1206    print OUTFILE "\t/* Ranges list: first code, last Code, array index. */\n";
1207    for (my $range = 0; $range <= $#{$tbl->[3]}; $range++)
1208    {
1209      printf OUTFILE "\t/* Array index: 0x%.4X */ 0x%.4X, 0x%.4X, 0x%.4X,\n",
1210             $idx += 3,
1211             $tbl->[3]->[$range]->[0],
1212             $tbl->[3]->[$range]->[1],
1213             $tbl->[3]->[$range]->[2];
1214    }
1215  }
1216  else
1217  {
1218    for (my $range = 0; $range <= $#{$tbl->[3]}; $range++)
1219    {
1220      print OUTFILE pack($endian, $tbl->[3]->[$range]->[0]),
1221                    pack($endian, $tbl->[3]->[$range]->[1]),
1222                    pack($endian, $tbl->[3]->[$range]->[2]);
1223    }
1224  }
1225  $idx += 3;
1226
1227  # OUTPUT RANGES CONTENT
1228  if ($Source)
1229  {
1230    print OUTFILE "\t/* Ranges content */";
1231    for (my $range = 0; $range <= $#{$tbl->[3]}; $range++)
1232    {
1233      printf OUTFILE "\n\t/* Range 0x%.4X - 0x%.4X, array index: 0x%.4X */",
1234             $tbl->[3]->[$range]->[0], $tbl->[3]->[$range]->[1], $idx;
1235             $idx += $tbl->[3]->[$range]->[1] - $tbl->[3]->[$range]->[0] + 1;
1236      for (my $elt = 0, my $br = 0;
1237           $elt <= $#{$tbl->[4]->[$range]};
1238           $br = ++$elt % 8)
1239      {
1240        print OUTFILE "\n\t" unless $br;
1241        if (defined $tbl->[4]->[$range]->[$elt])
1242        {
1243          if ($tbl->[4]->[$range]->[$elt] != $TmpLost)
1244          {
1245            printf OUTFILE "0x%.4X,", $tbl->[4]->[$range]->[$elt];
1246          }
1247          else
1248          {
1249            print OUTFILE "$MacroLostCode,";
1250          }
1251        }
1252        else
1253        {
1254          print OUTFILE "$MacroInvCode,";
1255        }
1256      }
1257    }
1258  }
1259  else
1260  {
1261    for (my $range = 0; $range <= $#{$tbl->[3]}; $range++)
1262    {
1263      for (my $elt = 0; $elt <= $#{$tbl->[4]->[$range]}; $elt++)
1264      {
1265        if (defined $tbl->[4]->[$range]->[$elt])
1266        {
1267          if ($tbl->[4]->[$range]->[$elt] != $TmpLost)
1268          {
1269            print OUTFILE pack $endian, $tbl->[4]->[$range]->[$elt];
1270          }
1271          else
1272          {
1273            print OUTFILE pack $endian, $LostCode;
1274          }
1275        }
1276        else
1277        {
1278          print OUTFILE pack $endian, $InvCode;
1279        }
1280      }
1281    }
1282  }
1283
1284  # OUTPUT UNRANGED CODES
1285  if ($Source)
1286  {
1287    printf OUTFILE "\n\t/* Unranged codes (%d codes) */", $#{$tbl->[4]} + 1;
1288    for (my $i = 0; $i <= $#{$tbl->[5]}; $i++)
1289    {
1290      printf OUTFILE "\n\t/* Array index: 0x%.4X */ 0x%.4X,0x%.4X,",
1291             $idx, $tbl->[5]->[$i]->[0], $tbl->[5]->[$i]->[1];
1292    }
1293  }
1294  else
1295  {
1296    for (my $i = 0; $i <= $#{$tbl->[5]}; $i++)
1297    {
1298      print OUTFILE pack($endian, $tbl->[5]->[$i]->[0]),
1299                    pack($endian, $tbl->[5]->[$i]->[1]);
1300    }
1301  }
1302
1303  if ($Source)
1304  {
1305    if ($_[0] eq "to_ucs")
1306    {
1307      print OUTFILE
1308"
1309};
1310
1311#endif /* $GuardToUCS && $GuardSize */
1312
1313";
1314    }
1315    else
1316    {
1317      print OUTFILE
1318"
1319};
1320
1321#endif /* $GuardFromUCS && $GuardSize */
1322
1323";
1324    }
1325  }
1326}
1327
1328
1329# =============================================================================
1330#
1331# Parse command line options
1332#
1333# =============================================================================
1334sub ProcessOptions()
1335{
1336  my $help_opt    = 'h'; # Print help option
1337  my $input_opt   = 'i'; # Input file name option
1338  my $output_opt  = 'o'; # Output file name option
1339  my $source_opt  = 'S'; # Generate C source file option
1340  my $enc_opt     = 'N'; # Encoding name
1341  my $plane_opt   = 'p'; # Plane number
1342  my $verbose_opt = 'v'; # Verbose output
1343  my $ccscol_opt  = 'x'; # Encoding's column number
1344  my $ucscol_opt  = 'y'; # UCS column number
1345  my $nosize_opt  = 'l'; # Don't generate size-optimized tables
1346  my $nospeed_opt = 'b'; # Don't generate speed-optimized tables
1347  my $nobe_opt    = 'B'; # Don't generate big-endian tables
1348  my $nole_opt    = 'L'; # Don't generate big-endian tables
1349  my $noto_opt    = 't'; # Don't generate "to_ucs" table
1350  my $nofrom_opt  = 'f'; # Don't generate "from_ucs" table
1351
1352  my %args;              # Command line arguments found by getopts()
1353
1354  my $getopts_string = 
1355     "$help_opt$source_opt$enc_opt:$verbose_opt$input_opt:$output_opt:$plane_opt:"
1356   . "$nosize_opt$nospeed_opt$nobe_opt$nole_opt$noto_opt$nofrom_opt$ccscol_opt:"
1357   . "$ucscol_opt:";
1358
1359  getopts($getopts_string, \%args) || Err "getopts() failed: $!.\n", 1;
1360
1361  # Print usage rules and exit.
1362  if ($args{$help_opt})
1363  {
1364    print<<END
1365Usage:
1366     -$help_opt - this help message;
1367     -$input_opt - input file name (required);
1368     -$output_opt - output file name;
1369     -$enc_opt - CCS or encoding name;
1370     -$plane_opt - plane number (high 16 bits) to use (in hex);
1371     -$source_opt - generate C source file;
1372     -$nospeed_opt - don't generate speed-optimized tables (binary files only);
1373     -$nosize_opt - don't generate size-optimized tables (binary files only);
1374     -$nobe_opt - don't generate Big Endian tables (binary files only);
1375     -$nole_opt - don't generate Little Endian tables (binary files only);
1376     -$noto_opt - don't generate "to_ucs" table;
1377     -$nofrom_opt - don't generate "from_ucs" table;
1378     -$ccscol_opt - encoding's column number;
1379     -$ucscol_opt - UCS column number;
1380     -$verbose_opt - verbose output.
1381
1382If output file name isn't specified, <infile>.c (for sources) or
1383<infile>.cct (for binaries) is assumed.
1384If encoding name isn't specified <infile> is assumed.
1385<infile> is normalized (small letters, "-" are substituted by "_") input file
1386name base (no extension). For example, for Koi8-r.txt input file, <infile>
1387is koi8_r.           
1388END
1389;
1390    exit 0;
1391  }
1392
1393  $Verbose   = $args{$verbose_opt};
1394  $Source    = $args{$source_opt};
1395  $NoSpeed   = $args{$nospeed_opt};
1396  $NoSize    = $args{$nosize_opt};
1397  $NoBE      = $args{$nobe_opt};
1398  $NoLE      = $args{$nole_opt}; 
1399  $NoFrom    = $args{$nofrom_opt};
1400  $NoTo      = $args{$noto_opt};
1401  $CCSCol    = $args{$ccscol_opt};
1402  $UCSCol    = $args{$ucscol_opt};
1403  $Plane     = $args{$plane_opt};
1404  $InFile    = $args{$input_opt};
1405  $OutFile   = $args{$output_opt};
1406  $CCSName   = $args{$enc_opt};
1407
1408  Err "Error: input file isn't defined. Use -$help_opt for help.\n", 1
1409  unless $InFile;
1410 
1411  unless ($OutFile)
1412  {
1413    # Construct output file name
1414    $OutFile = $InFile;
1415    $OutFile =~ s/(.*\/)*([0-9a-zA-Z-_]*)(\..*)$/\L$2/;
1416    $OutFile =~ tr/-/_/;
1417    if ($Source)
1418    {
1419      $OutFile = "$OutFile.c";
1420    }
1421    else
1422    {
1423      $OutFile = "$OutFile.cct"
1424    }
1425  }
1426 
1427  unless ($CCSName)
1428  {
1429    # Construct CCS name
1430    $CCSName = $InFile;
1431    $CCSName =~ s/(.*\/)*([0-9a-zA-Z-_]*)(\..*)$/\L$2/;
1432    $CCSName =~ tr/-/_/;
1433  }
1434
1435  Err "-$nosize_opt option can't be used with -$nospeed_opt option "
1436    . "simultaniously.\n", 1 if $NoSpeed && $NoSize;
1437
1438  Err "-$nobe_opt option can't be used with -$nole_opt option "
1439    . "simultaniously.\n", 1 if $NoBE && $NoLE;
1440 
1441  Err "-$noto_opt option can't be used with -$nofrom_opt option"
1442    . "simultaniously.\n", 1 if $NoTo && $NoFrom;
1443
1444  Err "-$nosize_opt, -$nospeed_opt, -$nobe_opt -$nole_opt "
1445    . "-$noto_opt and -$nofrom_opt "
1446    . "options can't be used with -$source_opt option.\n"
1447    . "Source code always contains both speed- and size-optimized "
1448    . "tables in System Endian. Use -$help_opt for help.\n", 1
1449  if $Source and $NoSpeed || $NoSize || $NoBE || $NoLE || $NoTo || $NoFrom;
1450 
1451  if (!$CCSCol && !$UCSCol)
1452  {
1453    $CCSCol = 0;
1454    $UCSCol = 1;
1455  }
1456  elsif ($CCSCol && $UCSCol)
1457  {
1458    Err "Column number should be >= 0\n", 1 if ($CCSCol <= 0 or $UCSCol <= 0);
1459    $CCSCol -= 1;
1460    $UCSCol -= 1;
1461  }
1462  else
1463  {
1464    Err "Please, define both CCS and UCS column numbers\n", 1;
1465  }
1466
1467  if ($Verbose)
1468  {
1469    print  "Use $InFile file for input.\n",
1470           "Use $OutFile file for output.\n",
1471           "Use $CCSName as CCS name.\n";
1472    print  "Generate C source file.\n"                if $Source;
1473    print  "Generate binary file.\n"                  if !$Source;
1474    printf "Use plane N 0x%.4X.\n", hex $Plane if defined $Plane;
1475    printf "Use column N $CCSCol for $CCSName.\n";
1476    printf "Use column N $UCSCol for UCS.\n";
1477    print  "Don't generate size-optimized tables.\n"  if $NoSize;
1478    print  "Don't generate speed-optimized tables.\n" if $NoSpeed;
1479    print  "Don't generate big-endian tables.\n"      if $NoBE;
1480    print  "Don't generate little-endian tables.\n"   if $NoLE;
1481    print  "Don't generate \"to_ucs\" table.\n"       if $NoTo;
1482    print  "Don't generate \"from_ucs\" table.\n"     if $NoFrom;
1483  }
1484 
1485  return;
1486}
1487
1488
1489# =============================================================================
1490#
1491# Print error message, close all and exit
1492#
1493# Parameter 1: error message
1494# Parameter 2: don't delete output file if > 1
1495#
1496# =============================================================================
1497sub Err($;$)
1498{
1499  print STDERR "$_[0]";
1500  close INFILE;
1501  close OUTFILE;
1502  unlink $OutFile unless $_[1];
1503 
1504  exit 1;
1505}
Note: See TracBrowser for help on using the repository browser.