PageRenderTime 45ms CodeModel.GetById 15ms RepoModel.GetById 1ms app.codeStats 0ms

/IronPython_Main/Runtime/Tests/LinqDlrTests/testenv/perl/lib/unicode/mktables.pl

#
Perl | 447 lines | 337 code | 61 blank | 49 comment | 12 complexity | eb07017211fab8a5eb57bbd5f3835106 MD5 | raw file
Possible License(s): GPL-2.0, MPL-2.0-no-copyleft-exception, CPL-1.0, CC-BY-SA-3.0, BSD-3-Clause, ISC, AGPL-3.0, LGPL-2.1, Apache-2.0 
    

  1. #!../../miniperl

    2. 

  2. 

    3. 

  3. use bytes;

    4. 

  4. 

    5. 

  5. $UnicodeData = "Unicode.301";

    6. 

  6. $SyllableData = "syllables.txt";

    7. 

  7. $PropData = "PropList.txt";

    8. 

  8. 

    9. 

  9. 

    10. 

  10. # Note: we try to keep filenames unique within first 8 chars.  Using

    11. 

  11. # subdirectories for the following helps.

    12. 

  12. mkdir "In", 0755;

    13. 

  13. mkdir "Is", 0755;

    14. 

  14. mkdir "To", 0755;

    15. 

  15. 

    16. 

  16. @todo = (

    17. 

  17. # typical

    18. 

  18. 

    19. 

  19.     # 005F: SPACING UNDERSCROE

    20. 

  20.     ['IsWord',   '$cat =~ /^[LMN]/ or $code eq "005F"',	''],

    21. 

  21.     ['IsAlnum',  '$cat =~ /^[LMN]/',	''],

    22. 

  22.     ['IsAlpha',  '$cat =~ /^[LM]/',	''],

    23. 

  23.     # 0009: HORIZONTAL TABULATION

    24. 

  24.     # 000A: LINE FEED

    25. 

  25.     # 000B: VERTICAL TABULATION

    26. 

  26.     # 000C: FORM FEED

    27. 

  27.     # 000D: CARRIAGE RETURN

    28. 

  28.     # 0020: SPACE

    29. 

  29.     ['IsSpace',  '$cat  =~ /^Z/ ||

    30. 

  30.                   $code =~ /^(0009|000A|000B|000C|000D)$/',	''],

    31. 

  31.     ['IsSpacePerl',

    32. 

  32.                  '$cat  =~ /^Z/ ||

    33. 

  33.                   $code =~ /^(0009|000A|000C|000D)$/',		''],

    34. 

  34.     ['IsBlank',  '$code =~ /^(0020|0009)$/ ||

    35. 

  35. 		  $cat  =~ /^Z[^lp]$/',	''],

    36. 

  36.     ['IsDigit',  '$cat =~ /^Nd$/',	''],

    37. 

  37.     ['IsUpper',  '$cat =~ /^L[ut]$/',	''],

    38. 

  38.     ['IsLower',  '$cat =~ /^Ll$/',	''],

    39. 

  39.     ['IsASCII',  '$code le "007f"',	''],

    40. 

  40.     ['IsCntrl',  '$cat =~ /^C/',	''],

    41. 

  41.     ['IsGraph',  '$cat =~ /^([LMNPS]|Co)/',	''],

    42. 

  42.     ['IsPrint',  '$cat =~ /^([LMNPS]|Co|Zs)/',	''],

    43. 

  43.     ['IsPunct',  '$cat =~ /^P/',	''],

    44. 

  44.     # 003[0-9]: DIGIT ZERO..NINE, 00[46][1-6]: A..F, a..f

    45. 

  45.     ['IsXDigit', '$code =~ /^00(3[0-9]|[46][1-6])$/',	''],

    46. 

  46.     ['ToUpper',  '$up',			'$up'],

    47. 

  47.     ['ToLower',  '$down',		'$down'],

    48. 

  48.     ['ToTitle',  '$title',		'$title'],

    49. 

  49.     ['ToDigit',  '$dec ne ""',		'$dec'],

    50. 

  50. 

    51. 

  51. # Name

    52. 

  52. 

    53. 

  53.     ['Name',	'$name',		'$name'],

    54. 

  54. 

    55. 

  55. # Category

    56. 

  56. 

    57. 

  57.     ['Category', '$cat',		'$cat'],

    58. 

  58. 

    59. 

  59. # Normative

    60. 

  60. 

    61. 

  61.     ['IsM',	'$cat =~ /^M/',		''],	# Mark

    62. 

  62.     ['IsMn',	'$cat eq "Mn"',		''],	# Mark, Non-Spacing 

    63. 

  63.     ['IsMc',	'$cat eq "Mc"',		''],	# Mark, Combining

    64. 

  64.     ['IsMe',	'$cat eq "Me"',		''],    # Mark, Enclosing

    65. 

  65. 

    66. 

  66.     ['IsN',	'$cat =~ /^N/',		''],	# Number

    67. 

  67.     ['IsNd',	'$cat eq "Nd"',		''],	# Number, Decimal Digit

    68. 

  68.     ['IsNo',	'$cat eq "No"',		''],	# Number, Other

    69. 

  69.     ['IsNl',	'$cat eq "Nl"',		''],    # Number, Letter

    70. 

  70. 

    71. 

  71.     ['IsZ',	'$cat =~ /^Z/',		''],	# Separator

    72. 

  72.     ['IsZs',	'$cat eq "Zs"',		''],	# Separator, Space

    73. 

  73.     ['IsZl',	'$cat eq "Zl"',		''],	# Separator, Line

    74. 

  74.     ['IsZp',	'$cat eq "Zp"',		''],	# Separator, Paragraph

    75. 

  75. 

    76. 

  76.     ['IsC',	'$cat =~ /^C/',		''],	# Crazy

    77. 

  77.     ['IsCc',	'$cat eq "Cc"',		''],	# Other, Control or Format

    78. 

  78.     ['IsCo',	'$cat eq "Co"',		''],	# Other, Private Use

    79. 

  79.     ['IsCn',	'$cat eq "Cn"',		''],	# Other, Not Assigned

    80. 

  80.     ['IsCf',	'$cat eq "Cf"',		''],    # Other, Format

    81. 

  81.     ['IsCs',	'$cat eq "Cs"',		''],    # Other, Surrogate

    82. 

  82.     ['IsCn',	'Unassigned Code Value',$PropData],	# Other, Not Assigned

    83. 

  83.  

    84. 

  84. # Informative

    85. 

  85. 

    86. 

  86.     ['IsL',	'$cat =~ /^L/',		''],	# Letter

    87. 

  87.     ['IsLu',	'$cat eq "Lu"',		''],	# Letter, Uppercase

    88. 

  88.     ['IsLl',	'$cat eq "Ll"',		''],	# Letter, Lowercase

    89. 

  89.     ['IsLt',	'$cat eq "Lt"',		''],	# Letter, Titlecase 

    90. 

  90.     ['IsLm',	'$cat eq "Lm"',		''],	# Letter, Modifier

    91. 

  91.     ['IsLo',	'$cat eq "Lo"',		''],	# Letter, Other 

    92. 

  92. 

    93. 

  93.     ['IsP',	'$cat =~ /^P/',		''],	# Punctuation

    94. 

  94.     ['IsPd',	'$cat eq "Pd"',		''],	# Punctuation, Dash

    95. 

  95.     ['IsPs',	'$cat eq "Ps"',		''],	# Punctuation, Open

    96. 

  96.     ['IsPe',	'$cat eq "Pe"',		''],	# Punctuation, Close

    97. 

  97.     ['IsPo',	'$cat eq "Po"',		''],	# Punctuation, Other

    98. 

  98.     ['IsPc',	'$cat eq "Pc"',		''],	# Punctuation, Connector

    99. 

  99.     ['IsPi',	'$cat eq "Pi"',		''],	# Punctuation, Initial quote

    100. 

  100.     ['IsPf',	'$cat eq "Pf"',		''],	# Punctuation, Final quote

    101. 

  101. 

    102. 

  102.     ['IsS',	'$cat =~ /^S/',		''],	# Symbol

    103. 

  103.     ['IsSm',	'$cat eq "Sm"',		''],	# Symbol, Math

    104. 

  104.     ['IsSk',	'$cat eq "Sk"',		''],	# Symbol, Modifier

    105. 

  105.     ['IsSc',	'$cat eq "Sc"',		''],	# Symbol, Currency

    106. 

  106.     ['IsSo',	'$cat eq "So"',		''],	# Symbol, Other

    107. 

  107. 

    108. 

  108. # Combining class

    109. 

  109.     ['CombiningClass', '$comb',		'$comb'],

    110. 

  110. 

    111. 

  111. # BIDIRECTIONAL PROPERTIES

    112. 

  112.  

    113. 

  113.     ['Bidirectional', '$bid',		'$bid'],

    114. 

  114. 

    115. 

  115. # Strong types:

    116. 

  116. 

    117. 

  117.     ['IsBidiL',	'$bid eq "L"',		''],	# Left-Right; Most alphabetic,

    118. 

  118. 						# syllabic, and logographic

    119. 

  119. 						# characters (e.g., CJK

    120. 

  120. 						# ideographs)

    121. 

  121.     ['IsBidiR',	'$bid eq "R"',		''],	# Right-Left; Arabic, Hebrew,

    122. 

  122. 						# and punctuation specific to

    123. 

  123. 						# those scripts

    124. 

  124. 

    125. 

  125.     ['IsBidiLRE', '$bid eq "LRE"',       ''],    # Left-to-Right Embedding

    126. 

  126.     ['IsBidiLRO', '$bid eq "LRO"',       ''],    # Left-to-Right Override

    127. 

  127.     ['IsBidiAL', '$bid eq "AL"',         ''],    # Right-to-Left Arabic

    128. 

  128.     ['IsBidiRLE', '$bid eq "RLE"',       ''],    # Right-to-Left Embedding

    129. 

  129.     ['IsBidiRLO', '$bid eq "RLO"',       ''],    # Right-to-Left Override

    130. 

  130.     ['IsBidiPDF', '$bid eq "PDF"',       ''],    # Pop Directional Format

    131. 

  131.     ['IsBidiNSM', '$bid eq "NSM"',       ''],    # Non-Spacing Mark

    132. 

  132.     ['IsBidiBN', '$bid eq "BN"',         ''],    # Boundary Neutral

    133. 

  133. 

    134. 

  134. # Weak types:

    135. 

  135. 

    136. 

  136.     ['IsBidiEN','$bid eq "EN"',		''],	# European Number

    137. 

  137.     ['IsBidiES','$bid eq "ES"',		''],	# European Number Separator

    138. 

  138.     ['IsBidiET','$bid eq "ET"',		''],	# European Number Terminator

    139. 

  139.     ['IsBidiAN','$bid eq "AN"',		''],	# Arabic Number

    140. 

  140.     ['IsBidiCS','$bid eq "CS"',		''],	# Common Number Separator

    141. 

  141. 

    142. 

  142. # Separators:

    143. 

  143. 

    144. 

  144.     ['IsBidiB',	'$bid eq "B"',		''],	# Block Separator

    145. 

  145.     ['IsBidiS',	'$bid eq "S"',		''],	# Segment Separator

    146. 

  146. 

    147. 

  147. # Neutrals:

    148. 

  148. 

    149. 

  149.     ['IsBidiWS','$bid eq "WS"',		''],	# Whitespace

    150. 

  150.     ['IsBidiON','$bid eq "ON"',		''],	# Other Neutrals ; All other

    151. 

  151. 						# characters: punctuation,

    152. 

  152. 						# symbols

    153. 

  153. 

    154. 

  154. # Decomposition

    155. 

  155. 

    156. 

  156.     ['Decomposition',	'$decomp',	'$decomp'],

    157. 

  157.     ['IsDecoCanon',	'$decomp && $decomp !~ /^</',	''],

    158. 

  158.     ['IsDecoCompat',	'$decomp =~ /^</',		''],

    159. 

  159.     ['IsDCfont',	'$decomp =~ /^<font>/',		''],

    160. 

  160.     ['IsDCnoBreak',	'$decomp =~ /^<noBreak>/',	''],

    161. 

  161.     ['IsDCinitial',	'$decomp =~ /^<initial>/',	''],

    162. 

  162.     ['IsDCmedial',	'$decomp =~ /^<medial>/',	''],

    163. 

  163.     ['IsDCfinal',	'$decomp =~ /^<final>/',	''],

    164. 

  164.     ['IsDCisolated',	'$decomp =~ /^<isolated>/',	''],

    165. 

  165.     ['IsDCcircle',	'$decomp =~ /^<circle>/',	''],

    166. 

  166.     ['IsDCsuper',	'$decomp =~ /^<super>/',	''],

    167. 

  167.     ['IsDCsub',		'$decomp =~ /^<sub>/',		''],

    168. 

  168.     ['IsDCvertical',	'$decomp =~ /^<vertical>/',	''],

    169. 

  169.     ['IsDCwide',	'$decomp =~ /^<wide>/',		''],

    170. 

  170.     ['IsDCnarrow',	'$decomp =~ /^<narrow>/',	''],

    171. 

  171.     ['IsDCsmall',	'$decomp =~ /^<small>/',	''],

    172. 

  172.     ['IsDCsquare',	'$decomp =~ /^<square>/',	''],

    173. 

  173.     ['IsDCfraction',	'$decomp =~ /^<fraction>/',	''],

    174. 

  174.     ['IsDCcompat',	'$decomp =~ /^<compat>/',	''],

    175. 

  175. 

    176. 

  176. # Number

    177. 

  177. 

    178. 

  178.     ['Number', 	'$num ne ""',		'$num'],

    179. 

  179. 

    180. 

  180. # Mirrored

    181. 

  181. 

    182. 

  182.     ['IsMirrored', '$mir eq "Y"',	''],

    183. 

  183. 

    184. 

  184. # Arabic

    185. 

  185. 

    186. 

  186.     ['ArabLink', 	'1',		'$link'],

    187. 

  187.     ['ArabLnkGrp', 	'1',		'$linkgroup'],

    188. 

  188. 

    189. 

  189. # Jamo

    190. 

  190. 

    191. 

  191.     ['JamoShort',	'1',		'$short'],

    192. 

  192. 

    193. 

  193. # Syllables

    194. 

  194. 

    195. 

  195.     syllable_defs(),

    196. 

  196. 

    197. 

  197. # Line break properties - Normative

    198. 

  198. 

    199. 

  199.     ['IsLbrkBK','$brk eq "BK"',		''],	# Mandatory Break

    200. 

  200.     ['IsLbrkCR','$brk eq "CR"',		''],	# Carriage Return

    201. 

  201.     ['IsLbrkLF','$brk eq "LF"',		''],	# Line Feed

    202. 

  202.     ['IsLbrkCM','$brk eq "CM"',		''],	# Attached Characters and Combining Marks

    203. 

  203.     ['IsLbrkSG','$brk eq "SG"',		''],	# Surrogates

    204. 

  204.     ['IsLbrkGL','$brk eq "GL"',		''],	# Non-breaking (Glue)

    205. 

  205.     ['IsLbrkCB','$brk eq "CB"',		''],	# Contingent Break Opportunity

    206. 

  206.     ['IsLbrkSP','$brk eq "SP"',		''],	# Space

    207. 

  207.     ['IsLbrkZW','$brk eq "ZW"',		''],	# Zero Width Space

    208. 

  208. 

    209. 

  209. # Line break properties - Informative

    210. 

  210.     ['IsLbrkXX','$brk eq "XX"',		''],	# Unknown

    211. 

  211.     ['IsLbrkOP','$brk eq "OP"',		''],	# Opening Punctuation

    212. 

  212.     ['IsLbrkCL','$brk eq "CL"',		''],	# Closing Punctuation

    213. 

  213.     ['IsLbrkQU','$brk eq "QU"',		''],	# Ambiguous Quotation

    214. 

  214.     ['IsLbrkNS','$brk eq "NS"',		''],	# Non Starter

    215. 

  215.     ['IsLbrkEX','$brk eq "EX"',		''],	# Exclamation/Interrogation

    216. 

  216.     ['IsLbrkSY','$brk eq "SY"',		''],	# Symbols Allowing Breaks

    217. 

  217.     ['IsLbrkIS','$brk eq "IS"',		''],	# Infix Separator (Numeric)

    218. 

  218.     ['IsLbrkPR','$brk eq "PR"',		''],	# Prefix (Numeric)

    219. 

  219.     ['IsLbrkPO','$brk eq "PO"',		''],	# Postfix (Numeric)

    220. 

  220.     ['IsLbrkNU','$brk eq "NU"',		''],	# Numeric

    221. 

  221.     ['IsLbrkAL','$brk eq "AL"',		''],	# Ordinary Alphabetic and Symbol Characters

    222. 

  222.     ['IsLbrkID','$brk eq "ID"',		''],	# Ideographic

    223. 

  223.     ['IsLbrkIN','$brk eq "IN"',		''],	# Inseparable

    224. 

  224.     ['IsLbrkHY','$brk eq "HY"',		''],	# Hyphen

    225. 

  225.     ['IsLbrkBB','$brk eq "BB"',		''],	# Break Opportunity Before

    226. 

  226.     ['IsLbrkBA','$brk eq "BA"',		''],	# Break Opportunity After

    227. 

  227.     ['IsLbrkSA','$brk eq "SA"',		''],	# Complex Context (South East Asian)

    228. 

  228.     ['IsLbrkAI','$brk eq "AI"',		''],	# Ambiguous (Alphabetic or Ideographic)

    229. 

  229.     ['IsLbrkB2','$brk eq "B2"',		''],	# Break Opportunity Before and After

    230. 

  230. );

    231. 

  231. 

    232. 

  232. # This is not written for speed...

    233. 

  233. 

    234. 

  234. foreach $file (@todo) {

    235. 

  235.     my ($table, $wanted, $val) = @$file;

    236. 

  236.     next if @ARGV and not grep { $_ eq $table } @ARGV;

    237. 

  237.     print $table,"\n";

    238. 

  238.     if ($table =~ /^(Is|In|To)(.*)/) {

    239. 

  239. 	open(OUT, ">$1/$2.pl") or die "Can't create $1/$2.pl: $!\n";

    240. 

  240.     }

    241. 

  241.     else {

    242. 

  242. 	open(OUT, ">$table.pl") or die "Can't create $table.pl: $!\n";

    243. 

  243.     }

    244. 

  244.     print OUT <<EOH;

    245. 

  245. # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 

    246. 

  246. # This file is built by $0 from e.g. $UnicodeData.

    247. 

  247. # Any changes made here will be lost!

    248. 

  248. EOH

    249. 

  249.     print OUT <<"END";

    250. 

  250. return <<'END';

    251. 

  251. END

    252. 

  252.     print OUT proplist($table, $wanted, $val);

    253. 

  253.     print OUT "END\n";

    254. 

  254.     close OUT;

    255. 

  255. }

    256. 

  256. 

    257. 

  257. # Must treat blocks specially.

    258. 

  258. 

    259. 

  259. exit if @ARGV and not grep { $_ eq Block } @ARGV;

    260. 

  260. print "Block\n";

    261. 

  261. open(UD, 'Blocks.txt') or die "Can't open Blocks.txt: $!\n";

    262. 

  262. open(OUT, ">Block.pl") or die "Can't create Block.pl: $!\n";

    263. 

  263. print OUT <<EOH;

    264. 

  264. # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 

    265. 

  265. # This file is built by $0 from e.g. $UnicodeData.

    266. 

  266. # Any changes made here will be lost!

    267. 

  267. EOH

    268. 

  268. print OUT <<"END";

    269. 

  269. return <<'END';

    270. 

  270. END

    271. 

  271. 

    272. 

  272. while (<UD>) {

    273. 

  273.     next if /^#/;

    274. 

  274.     next if /^$/;

    275. 

  275.     chomp;

    276. 

  276.     ($code, $last, $name) = split(/; */);

    277. 

  277.     if ($name) {

    278. 

  278. 	print OUT "$code	$last	$name\n";

    279. 

  279. 	$name =~ s/\s+//g;

    280. 

  280. 	open(BLOCK, ">In/$name.pl");

    281. 

  281. 	print BLOCK <<EOH;

    282. 

  282. # !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 

    283. 

  283. # This file is built by $0 from e.g. $UnicodeData.

    284. 

  284. # Any changes made here will be lost!

    285. 

  285. EOH

    286. 

  286. 	print BLOCK <<"END2";

    287. 

  287. return <<'END';

    288. 

  288. $code	$last

    289. 

  289. END

    290. 

  290. END2

    291. 

  291. 	close BLOCK;

    292. 

  292.     }

    293. 

  293. }

    294. 

  294. 

    295. 

  295. print OUT "END\n";

    296. 

  296. close OUT;

    297. 

  297. 

    298. 

  298. ##################################################

    299. 

  299. 

    300. 

  300. sub proplist {

    301. 

  301.     my ($table, $wanted, $val) = @_;

    302. 

  302.     my @wanted;

    303. 

  303.     my $out;

    304. 

  304.     my $split;

    305. 

  305. 

    306. 

  306.     return listFromPropFile($wanted) if $val eq $PropData;

    307. 

  307. 

    308. 

  308.     if ($table =~ /^Arab/) {

    309. 

  309. 	open(UD, "ArabShap.txt") or warn "Can't open $table: $!";

    310. 

  310. 

    311. 

  311. 	$split = '($code, $name, $link, $linkgroup) = split(/; */);';

    312. 

  312.     }

    313. 

  313.     elsif ($table =~ /^Jamo/) {

    314. 

  314. 	open(UD, "Jamo.txt") or warn "Can't open $table: $!";

    315. 

  315. 

    316. 

  316. 	$split = '($code, $short, $name) = split(/; */); $code =~ s/^U\+//;';

    317. 

  317.     }

    318. 

  318.     elsif ($table =~ /^IsSyl/) {

    319. 

  319. 	open(UD, $SyllableData) or warn "Can't open $table: $!";

    320. 

  320. 

    321. 

  321. 	$split = '($code, $short, $syl) = split(/; */); $code =~ s/^U\+//;';

    322. 

  322.     }

    323. 

  323.     elsif ($table =~ /^IsLbrk/) {

    324. 

  324. 	open(UD, "LineBrk.txt") or warn "Can't open $table: $!";

    325. 

  325. 

    326. 

  326. 	$split = '($code, $brk, $name) = split(/;/);';

    327. 

  327.     }

    328. 

  328.     else {

    329. 

  329. 	open(UD, $UnicodeData) or warn "Can't open $UnicodeData: $!";

    330. 

  330. 

    331. 

  331. 	$split = '($code, $name, $cat, $comb, $bid, $decomp, $dec, $dig, $num, $mir, $uni1,

    332. 

  332. 		$comment, $up, $down, $title) = split(/;/);';

    333. 

  333.     }

    334. 

  334. 

    335. 

  335.     if ($table =~ /^(?:To|Is)[A-Z]/) {

    336. 

  336. 	eval <<"END";

    337. 

  337. 	    while (<UD>) {

    338. 

  338. 		next if /^#/;

    339. 

  339. 		next if /^\\s/;

    340. 

  340. 		s/\\s+\$//;

    341. 

  341. 		$split

    342. 

  342. 		if ($wanted) {

    343. 

  343. 		    push(\@wanted, [hex \$code, hex $val, \$name =~ /, First>\$/]);

    344. 

  344. 		}

    345. 

  345. 	    }

    346. 

  346. END

    347. 

  347. 	die $@ if $@;

    348. 

  348. 

    349. 

  349. 	while (@wanted) {

    350. 

  350. 	    $beg = shift @wanted;

    351. 

  351. 	    $last = $beg;

    352. 

  352. 	    while (@wanted and $wanted[0]->[0] == $last->[0] + 1 and

    353. 

  353. 		(not $val or $wanted[0]->[1] == $last->[1] + 1)) {

    354. 

  354. 		    $last = shift @wanted;

    355. 

  355. 	    }

    356. 

  356. 	    $out .= sprintf "%04x", $beg->[0];

    357. 

  357. 	    if ($beg->[2]) {

    358. 

  358. 		$last = shift @wanted;

    359. 

  359. 	    }

    360. 

  360. 	    if ($beg == $last) {

    361. 

  361. 		$out .= "\t";

    362. 

  362. 	    }

    363. 

  363. 	    else {

    364. 

  364. 		$out .= sprintf "\t%04x", $last->[0];

    365. 

  365. 	    }

    366. 

  366. 	    $out .= sprintf "\t%04x", $beg->[1] if $val;

    367. 

  367. 	    $out .= "\n";

    368. 

  368. 	}

    369. 

  369.     }

    370. 

  370.     else {

    371. 

  371. 	eval <<"END";

    372. 

  372. 	    while (<UD>) {

    373. 

  373. 		next if /^#/;

    374. 

  374. 		next if /^\\s*\$/;

    375. 

  375. 		chop;

    376. 

  376. 		$split

    377. 

  377. 		if ($wanted) {

    378. 

  378. 		    push(\@wanted, [hex \$code, $val, \$name =~ /, First>\$/]);

    379. 

  379. 		}

    380. 

  380. 	    }

    381. 

  381. END

    382. 

  382. 	die $@ if $@;

    383. 

  383. 

    384. 

  384. 	while (@wanted) {

    385. 

  385. 	    $beg = shift @wanted;

    386. 

  386. 	    $last = $beg;

    387. 

  387. 	    while (@wanted and $wanted[0]->[0] == $last->[0] + 1 and

    388. 

  388. 		($wanted[0]->[1] eq $last->[1])) {

    389. 

  389. 		    $last = shift @wanted;

    390. 

  390. 	    }

    391. 

  391. 	    $out .= sprintf "%04x", $beg->[0];

    392. 

  392. 	    if ($beg->[2]) {

    393. 

  393. 		$last = shift @wanted;

    394. 

  394. 	    }

    395. 

  395. 	    if ($beg == $last) {

    396. 

  396. 		$out .= "\t";

    397. 

  397. 	    }

    398. 

  398. 	    else {

    399. 

  399. 		$out .= sprintf "\t%04x", $last->[0];

    400. 

  400. 	    }

    401. 

  401. 	    $out .= sprintf "\t%s\n", $beg->[1];

    402. 

  402. 	}

    403. 

  403.     }

    404. 

  404.     $out;

    405. 

  405. }

    406. 

  406. 

    407. 

  407. sub listFromPropFile {

    408. 

  408.     my ($wanted) = @_;

    409. 

  409.     my $out;

    410. 

  410. 

    411. 

  411.     open (UD, $PropData) or die "Can't open $PropData: $!\n";

    412. 

  412.     local($/) = "\n" . '*' x 43 . "\n\nProperty dump for:";   # not 42?

    413. 

  413. 

    414. 

  414.     <UD>;

    415. 

  415.     while (<UD>) {

    416. 

  416.         chomp;

    417. 

  417.         if (s/0x[\d\w]+\s+\((.*?)\)// and $wanted eq $1) {

    418. 

  418.             s/\(\d+ chars\)//g;

    419. 

  419.             s/^\s+//mg;

    420. 

  420.             s/\s+$//mg;

    421. 

  421.             s/\.\./\t/g;

    422. 

  422. 	    $out = lc $_;

    423. 

  423. 	    last;

    424. 

  424.         }

    425. 

  425.     }

    426. 

  426.     close (UD);

    427. 

  427.     "$out\n";

    428. 

  428. }

    429. 

  429. 

    430. 

  430. sub syllable_defs {

    431. 

  431.     my @defs;

    432. 

  432.     my %seen;

    433. 

  433. 

    434. 

  434.     open (SD, $SyllableData) or die "Can't open $SyllableData: $!\n";

    435. 

  435.     while (<SD>) {

    436. 

  436.         next if /^\s*(#|$)/;

    437. 

  437.         s/\s+$//;

    438. 

  438.         ($code, $name, $syl) = split /; */;

    439. 

  439.         next unless $syl;

    440. 

  440.         push (@defs, ["IsSyl$syl", qq{\$syl eq "$syl"}, ''])

    441. 

  441.                                                      unless $seen{$syl}++;

    442. 

  442.     }

    443. 

  443.     close (SD);

    444. 

  444.     return (@defs);

    445. 

  445. }

    446. 

  446. 

    447. 

  447. # eof

    448. 

  448.