perlebcdic - Online en la nube

PROGRAMA:

NOMBRE

perlebcdic - Consideraciones para ejecutar Perl en plataformas EBCDIC

DESCRIPCIÓN

Una exploración de algunos de los problemas que enfrentan los programadores de Perl en computadoras basadas en EBCDIC.

Las partes de este documento que aún están incompletas están marcadas con XXX.

Las primeras versiones de Perl funcionaron en algunas máquinas EBCDIC, pero la última versión conocida que se ejecutó en
EBCDIC fue v5.8.7, hasta v5.22, cuando el núcleo de Perl funciona nuevamente en z / OS. Teóricamente,
podría funcionar en OS / 400 o BS2000 de Siemens (o sus sucesores), pero esto no ha sido probado. En
v5.22, no todos los módulos que se encuentran en CPAN pero que se envían con el núcleo de Perl funcionan en z / OS.

Si desea utilizar Perl en una máquina EBCDIC que no sea z / OS, háganoslo saber enviando un correo
a [email protected]

Escribir Perl en una plataforma EBCDIC no es realmente diferente a escribir en una "ASCII",
pero con diferentes números subyacentes, como veremos en breve. Tendrás que saber
algo sobre esas plataformas "ASCII" porque la documentación está sesgada y
utilice con frecuencia números de ejemplo que no se aplican a EBCDIC. También hay muy pocos CPAN
módulos que están escritos para EBCDIC y que no funcionan en ASCII; en cambio el vasto
la mayoría de los módulos CPAN están escritos para ASCII, y algunos pueden funcionar en EBCDIC,
mientras que algunos han sido diseñados para funcionar de forma portátil en ambos.

Si su código solo usa las 52 letras AZ y az, más ESPACIO, los dígitos 0-9 y el
caracteres de puntuación que utiliza Perl, más algunos controles que se indican con escape
secuencias como "\ n" y "\ t", entonces no hay nada especial en el uso de Perl, y su código
muy bien puede funcionar en una máquina ASCII sin cambios.

Pero si escribe un código que usa "\ 005" para significar una TAB o "\ xC1" para significar una "A" o "\ xDF"
para significar un "y" ("y" pequeña con diéresis), entonces su código puede funcionar bien en su EBCDIC
plataforma, pero no en una ASCII. Eso está bien si nadie quiere ejecutar su
código en una plataforma ASCII; pero el sesgo en este documento será en la escritura de código portátil
entre los sistemas EBCDIC y ASCII. Nuevamente, si todos los personajes que te importan son
entrable desde su teclado, no tiene que saber nada sobre ASCII, pero muchos
Los teclados no te permiten ingresar directamente, digamos, el carácter "\ xDF", por lo que tienes
para especificarlo indirectamente, como mediante el uso de la secuencia de escape "\ xDF". En esos casos
es más fácil saber algo sobre los juegos de caracteres ASCII / Unicode. Si sabes eso
el pequeño "ye" es "U + 00FF", entonces puede especificarlo como "\ N {U + FF}", y tener el
la computadora lo traduce automáticamente a "\ xDF" en su plataforma y lo deja como "\ xFF" en
ASCII. O puede especificarlo por su nombre, "\ N {LETRA Y MINÚSCULA LATINA CON DIAERESIS" y
No hace falta saber los números. De cualquier manera funciona, pero requiere familiaridad con Unicode.

COMÚN PERSONAJE CÓDIGO CONJUNTOS

ASCII
El Código Estándar Americano para el Intercambio de Información (ASCII o US-ASCII) es un conjunto de
enteros que van de 0 a 127 (decimal) que tienen interpretaciones estandarizadas por el
computadoras que usan ASCII. Por ejemplo, 65 significa la letra "A". El rango 0..127 puede ser
cubierto estableciendo los bits en un dígito binario de 7 bits, por lo que a veces se hace referencia al conjunto
como "ASCII de 7 bits". ASCII fue descrito por el American National Standards Institute
documento ANSI X3.4-1986. También fue descrito por ISO 646: 1991 (con localización para
símbolos de moneda). El conjunto ASCII completo se muestra en la tabla siguiente como los primeros 128
elementos. Los idiomas que se pueden escribir adecuadamente con los caracteres en ASCII incluyen
Inglés, hawaiano, indonesio, swahili y algunos idiomas nativos americanos.

La mayoría de los juegos de caracteres que no son EBCDIC son superconjuntos de ASCII. Esa es la media de los enteros 0-127
lo que ASCII dice que quieren decir. Pero los números enteros 128 y superiores son específicos del juego de caracteres.

Muchos de estos encajan completamente en 8 bits, usando ASCII como 0-127, mientras se especifica qué
128-255 significan, y no usan nada por encima de 255. Por lo tanto, estos son de un solo byte (u octeto si
prefieres) conjuntos de caracteres. Uno importante (ya que Unicode es un superconjunto) es el
Conjunto de caracteres ISO 8859-1.

ISO 8859
La ISO 8859-$n son una colección de conjuntos de códigos de caracteres de la International
Organización para la estandarización (ISO), cada una de las cuales agrega caracteres al conjunto ASCII
que se encuentran típicamente en varios idiomas, muchos de los cuales se basan en el romano, o
Alfabeto latino. La mayoría son para idiomas europeos, pero también hay algunos para árabe,
Griego, hebreo y tailandés. Hay buenas referencias en la web sobre todos estos.

latín 1 (YO ASI 8859-1)
Una extensión particular de 8 bits para ASCII que incluye latín grave y con acento agudo
caracteres. Los idiomas que pueden emplear ISO 8859-1 incluyen todos los idiomas cubiertos por
ASCII, así como afrikáans, albanés, vasco, catalán, danés, feroés, finlandés,
Noruego, portugués, español y sueco. El holandés está cubierto aunque sin el ij
ligadura. El francés también está cubierto pero sin la ligadura original. El alemán puede usar ISO 8859-1
pero debe hacerlo sin comillas al estilo alemán. Este conjunto se basa en Western
Extensiones europeas de ASCII y se encuentra comúnmente en el trabajo de la World Wide Web. En IBM
terminología de identificación de conjuntos de códigos de caracteres, ISO 8859-1 también se conoce como CCSID 819 (o
a veces 0819 o incluso 00819).

EBCDIC
El código de intercambio decimal codificado en binario extendido se refiere a una gran colección de
y conjuntos de caracteres codificados de varios bytes que son bastante diferentes de ASCII e ISO 8859-1,
y son todos ligeramente diferentes entre sí; normalmente se ejecutan en equipos host. los
Las codificaciones EBCDIC se derivan de extensiones de bytes de 8 bits de codificaciones de tarjetas perforadas Hollerith,
que son anteriores a ASCII. El diseño de las tarjetas era tal que se establecieron bits altos para
los caracteres alfabéticos en mayúsculas y minúsculas "[az]" y "[AZ]", pero había espacios
dentro de cada rango de alfabeto latino, visible en la tabla a continuación. Estas brechas pueden causar
complicaciones.

Algunos juegos de caracteres EBCDIC de IBM pueden conocerse por números de identificación de juego de códigos de caracteres
(Números CCSID) o números de página de códigos.

Perl se puede compilar en plataformas que ejecuten cualquiera de los tres caracteres EBCDIC de uso común
conjuntos, que se enumeran a continuación.

Los 13 variante personajes

Entre los conjuntos de códigos de caracteres IBM EBCDIC hay 13 caracteres que a menudo se asignan a
diferentes valores enteros. Esos personajes se conocen como los 13 caracteres "variantes" y
son:

\ [] {} ^ ~! # | $ @ `

Cuando Perl se compila para una plataforma, observa todos estos caracteres para adivinar cuál
El juego de caracteres EBCDIC que utiliza la plataforma y se adapta en consecuencia a esa plataforma.
Si la plataforma utiliza un conjunto de caracteres que no es uno de los tres que conoce Perl, Perl
fallará al compilar, o elegirá por error y en silencio uno de los tres.

EBCDIC código conjuntos reconocido by Perl

0037
El conjunto de códigos de caracteres ID 0037 es una asignación de los caracteres ASCII más Latin-1 (es decir, ISO
8859-1) a un equipo EBCDIC. 0037 se utiliza en las configuraciones regionales de inglés norteamericano en la
Sistema operativo OS / 400 que se ejecuta en sistemas AS / 400. CCSID 0037 difiere de ISO
8859-1 en 236 lugares; en otras palabras, están de acuerdo en solo 20 valores de puntos de código.

1047
El conjunto de códigos de caracteres ID 1047 también es un mapeo de los caracteres ASCII más Latin-1
(es decir, ISO 8859-1) a un conjunto EBCDIC. 1047 se utiliza en los servicios del sistema Unix para
OS / 390 oz / OS y OpenEdition para VM / ESA. CCSID 1047 difiere de CCSID 0037 en
ocho lugares, y de ISO 8859-1 en 236.

POSIX-BC
La página de códigos EBCDIC que se utiliza en el sistema BS2000 de Siemens es distinta de 1047 y 0037.
Se identifica a continuación como el conjunto POSIX-BC. Como 0037 y 1047, es lo mismo que ISO
8859-1 en 20 valores de puntos de código.

Unicode código puntos y no EBCDIC código puntos
En terminología Unicode, un código punto es el número asignado a un carácter: por ejemplo, en
EBCDIC al carácter "A" se le suele asignar el número 193. En Unicode, el carácter
A "A" se le asigna el número 65. Todos los puntos de código en ASCII y Latin-1 (ISO 8859-1) tienen
el mismo significado en Unicode. Los tres conjuntos de códigos EBCDIC reconocidos tienen 256 códigos
puntos, y en cada conjunto de códigos, los 256 puntos de código se asignan al código Latin1 equivalente
puntos. Obviamente, "A" se asignará a "A", "B" => "B", "%" => "%", etc., para todas las
caracteres en Latin1 y estas páginas de códigos.

También resulta que EBCDIC tiene equivalentes casi precisos para ASCII / Latin1 C0
controles y el control DELETE. (Los controles C0 son aquellos cuyos puntos de código ASCII son
0..0x1F; cosas como TAB, ACK, BEL, etc.) Se establece un mapeo entre estos ASCII / EBCDIC
control S. No existe un mapeo tan preciso entre los controles C1 en plataformas ASCII
y los controles EBCDIC restantes. Lo que se ha hecho es mapear estos controles, principalmente
arbitrariamente, a algún personaje que de otro modo no coincidiría en el otro conjunto de caracteres. La mayoría de
estos se utilizan muy, muy raramente hoy en día en EBCDIC de todos modos, y sus nombres han sido
cayó, sin mucha queja. Por ejemplo, el control EBCDIC EO (ocho unos)
(que consta de ocho bits uno = 0xFF) se asigna al control C1 APC (0x9F), y usted
no puedo usar el nombre "EO".

Los controles EBCDIC proporcionan tres posibles caracteres de terminación de línea, CR (0x0D), LF
(0x25) y NL (0x15). En las plataformas ASCII, los símbolos "NL" y "LF" se refieren al mismo
carácter, pero en estricta terminología EBCDIC son diferentes. El EBCDIC NL es
mapeado al control C1 llamado "NEL" ("Próxima línea"; aquí hay un caso en el que el mapeo hace
bastante sentido, y por lo tanto no es simplemente arbitrario). En algunas plataformas EBCDIC, este NL
o NEL es el terminador de línea típico. Esto es cierto para z / OS y BS2000. En estos
plataformas, los compiladores de C intercambiarán los puntos de código LF y NEL, de modo que "\ n" sea 0x15, y
se refiere a NL. Perl también hace eso; puede verlo en la tabla de códigos a continuación. Esto hace
las cosas en general "simplemente funcionan" sin que ni siquiera tenga que ser consciente de que hay un intercambio.

Unicode y Utf
UTF significa "Formato de transformación Unicode". UTF-8 es una codificación de Unicode en un
secuencia de bloques de bytes de 8 bits, basada en ASCII y Latin-1. La longitud de una secuencia
requerido para representar un punto de código Unicode depende del número ordinal de ese código
punto, con números más grandes que requieren más bytes. UTF-EBCDIC es como UTF-8, pero basado en
EBCDIC. Son lo suficientemente parecidos que a menudo, el uso casual combinará los dos términos, y
use "UTF-8" para referirse tanto al UTF-8 que se encuentra en las plataformas ASCII como al UTF-EBCDIC que se encuentra en
EBCDIC.

Es posible que vea el término carácter "invariante" o punto de código. Esto simplemente significa que el
carácter tiene el mismo valor numérico y representación cuando se codifica en UTF-8 (o UTF-
EBCDIC) como cuando no. (Tenga en cuenta que este es un concepto muy diferente de "La variante 13
caracteres "mencionados anteriormente. Una prosa cuidadosa utilizará el término" invariante UTF-8 "en lugar de
simplemente "invariante", pero la mayoría de las veces verá simplemente "invariante"). Por ejemplo, el ordinal
El valor de "A" es 193 en la mayoría de las páginas de códigos EBCDIC, y también es 193 cuando se codifica en UTF-EBCDIC.
Todos los puntos de código de variante UTF-8 (o UTF-EBCDIC) ocupan al menos dos bytes cuando se codifican en
UTF-8 (o UTF-EBCDIC); por definición, los puntos de código invariantes UTF-8 (o UTF-EBCDIC) son
exactamente un byte ya sea codificado en UTF-8 (o UTF-EBCDIC), o no. (A estas alturas ya ves por qué
la gente normalmente solo dice "UTF-8" cuando también quiere decir "UTF-EBCDIC". Por el resto de esto
documento, también seremos casuales al respecto). En ASCII UTF-8, los puntos de código
correspondientes a los 128 números ordinales más bajos (0 - 127: los caracteres ASCII) son
invariante. En UTF-EBCDIC, hay 160 caracteres invariables. (Si le importa, el EBCDIC
invariantes son aquellos caracteres que tienen equivalentes ASCII, más los que corresponden
a los controles C1 (128-159 en plataformas ASCII).)

Una cadena codificada en UTF-EBCDIC puede ser más larga (pero nunca más corta) que una codificada en
UTF-8. Perl extiende UTF-8 para que pueda codificar puntos de código por encima del máximo Unicode de
U + 10FFFF. También extiende UTF-EBCDIC, pero debido a las limitaciones inherentes en UTF-
EBCDIC, el punto de código máximo expresable es U + 7FFF_FFFF, incluso si el tamaño de la palabra es mayor
de 32 bits.

UTF-EBCDIC se define en el Informe técnico de Unicode n. ° 16
<http://www.unicode.org/reports/tr16>. Se define en base a CCSID 1047, no permitiendo
para conocer las diferencias de otras páginas de códigos. Esto permite un fácil intercambio de texto.
entre computadoras que ejecutan diferentes páginas de códigos, pero lo hace inutilizable, sin adaptación,
para Perl en esas otras páginas de códigos.

La razón de esta inutilización es que una suposición fundamental de Perl es que el
Los caracteres que le interesan para el análisis sintáctico y léxico son los mismos independientemente de que
el texto está en UTF-8. Por ejemplo, Perl espera que el carácter "[" tenga el mismo
representación, no importa si la cadena que lo contiene (o el texto del programa) está codificado en UTF-8
o no. Para garantizar esto, Perl adapta UTF-EBCDIC a la página de códigos en particular para que todos
los caracteres que espera que sean invariantes UTF-8 son, de hecho, invariantes UTF-8. Esto significa que
el texto generado en una computadora que ejecuta una versión de UTF-EBCDIC de Perl debe ser traducido
para ser inteligible para una computadora que ejecuta otra.

Gracias a Codificar
A partir de Perl 5.8, puede utilizar el módulo estándar Encode para traducir de EBCDIC a
Puntos de código Latin-1. Encode conoce más conjuntos de caracteres EBCDIC de los que Perl puede
actualmente se compilará para ejecutarse.

use Encode 'from_to';

my% ebcdic = (176 => 'cp37', 95 => 'cp1047', 106 => 'posix-bc');

# $ a está en puntos de código EBCDIC
from_to ($ a, $ ebcdic {ord '^'}, 'latin1');
# $ a es puntos de código ISO 8859-1

y desde puntos de código Latin-1 a puntos de código EBCDIC

use Encode 'from_to';

my% ebcdic = (176 => 'cp37', 95 => 'cp1047', 106 => 'posix-bc');

# $ a es puntos de código ISO 8859-1
from_to ($ a, 'latin1', $ ebcdic {ord '^'});
# $ a está en puntos de código EBCDIC

Para realizar E / S, se sugiere que utilice las funciones de traducción automática de PerlIO, consulte
perluniintro.

Desde la versión 5.8, Perl usa la biblioteca de E / S de PerlIO. Esto le permite utilizar diferentes
codificaciones por canal IO. Por ejemplo, puede usar

usar Codificar;
open ($ f, ">: codificación (ascii)", "prueba.ascii");
print $ f "¡Hola mundo! \ n";
open ($ f, ">: codificación (cp37)", "test.ebcdic");
print $ f "¡Hola mundo! \ n";
open ($ f, ">: codificación (latin1)", "test.latin1");
print $ f "¡Hola mundo! \ n";
open ($ f, ">: codificación (utf8)", "test.utf8");
print $ f "¡Hola mundo! \ n";

para obtener cuatro archivos que contengan "Hello World! \ n" en ASCII, CP 0037 EBCDIC, ISO 8859-1
(Latin-1) (en este ejemplo idéntico a ASCII ya que solo se imprimieron caracteres ASCII),
y UTF-EBCDIC (en este ejemplo, idéntico al EBCDIC normal, ya que solo los caracteres que
no difieren entre EBCDIC y UTF-EBCDIC fueron impresos). Ver la documentación de
Encode :: PerlIO para más detalles.

Como la capa PerlIO usa IO (bytes) sin procesar internamente, todo esto ignora totalmente cosas como
el tipo de su sistema de archivos (ASCII o EBCDIC).

SOLTERO OCTETO TABLAS

Las siguientes tablas enumeran los conjuntos ordenados ASCII y Latin 1, incluidos los subconjuntos: C0
controles (0..31), gráficos ASCII (32..7e), eliminar (7f), controles C1 (80..9f) y Latin-1
(también conocido como ISO 8859-1) (a0..ff). En la tabla, los nombres de las extensiones latinas 1 de ASCII tienen
ha sido etiquetado con nombres de personajes que corresponden aproximadamente a Los Unicode estándar, Versión
6.1 aunque con sustituciones como "s / LATIN //" y "s / VULGAR //" en todos los casos;
"s / LETRA MAYÚSCULA //" en algunos casos; y "s / LETRA PEQUEÑA ([AZ]) / \ l $ 1 /" en alguna otra
casos. Los controles se enumeran utilizando sus abreviaturas Unicode 6.2. Las diferencias
entre 0037 y 1047 los conjuntos están marcados con "**". Las diferencias entre el 1047
y los conjuntos POSIX-BC se marcan con "##". Todos los números "ord ()" enumerados son decimales. Si tu
preferiría ver esta tabla con una lista de valores octales, luego ejecutar la tabla (es decir, el pod
texto fuente de este documento, ya que esta receta puede no funcionar con un pod2_other_format
traducción) a través de:

receta 0

perl -ne 'si (/ (. {29}) (\ d +) \ s + (\ d +) \ s + (\ d +) \ s + (\ d +) /)' \
-e '{printf("%s%-5.03o%-5.03o%-5.03o%.03o\n",$1,$2,$3,$4,$5)}' \
perlebcdic.pod

Si desea conservar los puntos de código UTF-x, en forma de script, es posible que desee escribir:

receta 1

abierto (FH, "
tiempo ( ) {
si (/(.{29})(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\.?(\d*)
\ s + (\ d +) \.? (\ d *) / x)
{
if ($ 7 ne '' && $ 9 ne '') {
printf
"%s%-5.03o%-5.03o%-5.03o%-5.03o%-3o.%-5o%-3o.%.03o\n",
$1,$2,$3,$4,$5,$6,$7,$8,$9);
}
elsif ($ 7 ne '') {
printf("%s%-5.03o%-5.03o%-5.03o%-5.03o%-3o.%-5o%.03o\n",
$1,$2,$3,$4,$5,$6,$7,$8);
}
else {
printf("%s%-5.03o%-5.03o%-5.03o%-5.03o%-5.03o%.03o\n",
$1,$2,$3,$4,$5,$6,$8);
}
}
}

Si prefiere ver esta tabla con una lista de valores hexadecimales, ejecute la tabla a través de:

receta 2

perl -ne 'si (/ (. {29}) (\ d +) \ s + (\ d +) \ s + (\ d +) \ s + (\ d +) /)' \
-e '{printf("%s%-5.02X%-5.02X%-5.02X%.02X\n",$1,$2,$3,$4,$5)}' \
perlebcdic.pod

O, para retener los puntos de código UTF-x en hexadecimal:

receta 3

abierto (FH, "
tiempo ( ) {
si (/(.{29})(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\.?(\d*)
\ s + (\ d +) \.? (\ d *) / x)
{
if ($ 7 ne '' && $ 9 ne '') {
printf
"%s%-5.02X%-5.02X%-5.02X%-5.02X%-2X.%-6.02X%02X.%02X\n",
$1,$2,$3,$4,$5,$6,$7,$8,$9);
}
elsif ($ 7 ne '') {
printf("%s%-5.02X%-5.02X%-5.02X%-5.02X%-2X.%-6.02X%02X\n",
$1,$2,$3,$4,$5,$6,$7,$8);
}
else {
printf("%s%-5.02X%-5.02X%-5.02X%-5.02X%-5.02X%02X\n",
$1,$2,$3,$4,$5,$6,$8);
}
}
}

ISO
8859-1 POS-CCSID
CCSID CCSID CCSID IX-1047
chr 0819 0037 1047 aC UTF-8 UTF-EBCDIC
-------------------------------------------------- -------------------
0 0 0 0 0 0
1 1 1 1 1 1
2 2 2 2 2 2
3 3 3 3 3 3
4 55 55 55 4 55
5 45 45 45 5 45
6 46 46 46 6 46
7 47 47 47 7 47
8 22 22 22 8 22
9 5 5 5 9 5
10 37 21 21 10 21 **
11 11 11 11 11 11
12 12 12 12 12 12
13 13 13 13 13 13
14 14 14 14 14 14
15 15 15 15 15 15
16 16 16 16 16 16
1 17 17 17 17 17
2 18 18 18 18 18
3 19 19 19 19 19
4 20 60 60 60 20
21 61 61 61 21 61
22 50 50 50 22 50
23 38 38 38 23 38
24 24 24 24 24 24
25 25 25 25 25 25
26 63 63 63 26 63
27 39 39 39 27 39
28 28 28 28 28 28
29 29 29 29 29 29
30 30 30 30 30 30
31 31 31 31 31 31
32 64 64 64 32 64
! 33 90 90 90 33 90
34 127 127 127 34 127
# 35 123 123 123 35 123
$36 91 91 91 36 91
% 37 108
& 38 80 80 80 38 80
39 125
(40 77 77 77 40 77
) 41 93 93 93 41 93
* 42 92 92 92 42 92
+ 43 78 78 78 43 78
, 44 107
- 45 96 96 96 45 96
. 46 75 75 75 46 75
/ 47 97 97 97 47 97
0 48 240 240 240 48 240
1 49 241 241 241 49 241
2 50 242 242 242 50 242
3 51 243 243 243 51 243
4 52 244 244 244 52 244
5 53 245 245 245 53 245
6 54 246 246 246 54 246
7 55 247 247 247 55 247
8 56 248 248 248 56 248
9 57 249 249 249 57 249
: 58 122 122 122 58
; 59 94 94 94 59 94
<60 76 76 76 60 76
= 61 126
> 62 110 110 110 62 110
? 63 111
@ 64 124
65 193 193 193 65 193
66 194 194 194 66 194
C 67 195 195 195 67 195
D 68 196 196 196 68 196
mi 69 197 197 197 69 197
F 70 198 198 198 70 198
G 71 199 199 199 71 199 XNUMX
72 200 200 200 72 200
Yo 73 201 201
J 74 209 209 209 74 209
K 75 210 210 210 75 210
L 76 211 211 211 76 211
M 77 212
N 78 213 213 213 78 213
O 79 214 214 214 79 214
P 80 215
Q 81 216
R 82
S 83 226 226 226 83 226
T 84 227 227 227 84 227
85 228 228 228 85 228
V 86 229 229 229
W 87 230
X 88 231 231 231
Y 89 232
Z 90 233 233 233 90
[91 186 173 187 91 173 ** ##
\ 92 224 ##
] 93 187 189 189 93 189 **
^ 94 176 95 106 94 95 **##
_ 95 109
`96 121 121 ##
a 97 129 129 129 97 129
b 98 130
c 99 131
d 100
e 101
f 102
g 103
hora 104 136 136 136 104 136
yo 105, 137, 137, 137, 105, 137
j 106, 145, 145, 145, 106, 145
k 107
l 108
m 109
n 110, 149, 149, 149, 110, 149
o 111
p. 112
q 113
r 114, 153, 153, 153, 114, 153
s 115, 162, 162, 162, 115, 162
t 116, 163, 163, 163, 116, 163
u 117
v 118
w 119
x 120 167
y 121
z 122, 169, 169, 169, 122, 169
{123 192 192 251 123 192 ##
| 124 79 79 79 124
} 125 208 208 253 125 208 ##
~ 126 ##
127 7 7 7 127 7
128 32 32 32 194.128 32
129 33 33 33 194.129 33
130 34 34 34 194.130 34
131 35 35 35 194.131 35
132 36 36 36 194.132 36
133 21 37 37 194.133 37 **
134 6 6 6 194.134 6
135 23 23 23 194.135 23
136 40 40 40 194.136 40
137 41 41 41 194.137 41
138 42 42 42 194.138 42
139 43 43 43 194.139 43
140 44 44 44 194.140 44
141 9 9 9 194.141 9
2 142 10 10 10 194.142
3 143 27 27 27 194.143
144 48 48 48 194.144 48
1 145 49 49 49 194.145
2 146 26 26 26 194.146
147 51 51 51 194.147 51
148 52 52 52 194.148 52
149 53 53 53 194.149 53
150 54 54 54 194.150 54
151 8 8 8 194.151 8
152 56 56 56 194.152 56
153 57 57 57 194.153 57
154 58 58 58 194.154 58
155 59 59 59 194.155 59
156 4 4 4 194.156 4
157 20 20 20 194.157 20
158 62 62 62 194.158 62
159 255 255 ##
160 65 65 65 194.160 128.65
161 170 170 170 194.161 128.66
162 74 74 176 194.162 ##
163 177 177 177 194.163 128.68
164 159
165 178 178 178 194.165 128.70
166 106 ##
167 181
168 189 187 ** ##
169 180 180 180 194.169 128.74
170 154 154
171 138 138
172 95 176 186 194.172 128.83 ** ##
173 202 202 202 194.173 128.84
174 175
175 188 ##
176 144
177 143 143 143 194.177 128.88
178 234 234 234 194.178 128.89
179 250 250
180 190 190 190 194.180 128.99 XNUMX
181 160 160
182 182
183, 179, 179, 179, 194.183 128.102
184 157 157
185 218 218 218 194.185 128.104
186 155 155 155 194.186 128.105
187 139 139
188 183 183 183 194.188 128.112 XNUMX
189 184
190 185 185 185 194.190 128.114
191 171 171 171 194.191
192 100 100 100 195.128 138.65
193 101 101
194 98 98 98 195.130 138.67
195 102
196 99 99 99 195.132 138.69
197, 103, 103, 103, 195.133 138.70
198 158 158
199 104
200 116 116
201, 113, 113, 113, 195.137, 138.74
202, 114, 114, 114, 195.138, 138.81
203 115 115
204 120 120
205 117
206, 118, 118, 118, 195.142, 138.85
207 119
208 172
209 105 105
210 237 237 237 195.146 138.89
211 238 238
212 235 235 235 195.148 138.99
213 239 239 239 195.149
214 236 236 236 195.150 138.101
215 191 191 191 195.151 138.102
216, 128, 128, 128, 195.152, 138.103
217 253 253 224 195.153 ##
218 254 254 254 195.154 138.105
219 251 251 ##
220 252 252 252 195.156 138.112
221 173 ** ##
222 174
223 89 89 89 195.159 138.115
224 68 68 68 195.160 139.65
225 69 69 69 195.161 139.66
226 66 66 66 195.162 139.67
227 70 70 70 195.163 139.68
228 67 67 67 195.164 139.69
229 71 71 71 195.165 139.70
230 156
231 72 72 72 195.167 139.72
232 84 84 84 195.168 139.73
233 81 81 81 195.169 139.74
234 82 82 82 195.170 139.81
235 83 83 83 195.171 139.82
236 88 88 88 195.172 139.83
237 85 85 85 195.173 139.84
238 86 86 86 195.174 139.85
239 87 87 87 195.175 139.86
240 140 140 140 195.176 139.87 XNUMX
241 73 73 73 195.177 139.88
242 205 205 205 195.178 139.89 XNUMX
243 206
244 203 203 203 195.180 139.99 XNUMX
245 207 207 207 195.181 139.100
246 204
247 225 225
248 112 112
249 221 221 ##
250 222 222
251 219 219 219 195.187
252 220 220 220 195.188
253 141 141 141 195.189 139.113 XNUMX
254 142
255 223 223 223 195.191 139.115

Si prefiere ver la tabla anterior en orden CCSID 0037 en lugar de ASCII + Latin-1
orden y luego ejecute la tabla a través de:

receta 4

perlas \
-ne 'si (/.{29}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}/)'\
-e '{empujar (@l, $ _)}' \
-e 'END {imprimir mapa {$ _-> [0]}' \
-e 'ordenar {$ a -> [1] <=> $ b -> [1]}' \
-e 'mapa {[$ _, substr ($ _, 34,3)]} @ l;}' perlebcdic.pod

Si prefiere verlo en el pedido CCSID 1047, cambie el número 34 en la última línea
a 39, así:

receta 5

perlas \
-ne 'si (/.{29}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}/)'\
-e '{empujar (@l, $ _)}' \
-e 'END {imprimir mapa {$ _-> [0]}' \
-e 'ordenar {$ a -> [1] <=> $ b -> [1]}' \
-e 'mapa {[$ _, substr ($ _, 39,3)]} @ l;}' perlebcdic.pod

Si prefiere verlo en orden POSIX-BC, cambie el número 34 en la última línea a
44, así:

receta 6

perlas \
-ne 'si (/.{29}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}/)'\
-e '{empujar (@l, $ _)}' \
-e 'END {imprimir mapa {$ _-> [0]}' \
-e 'ordenar {$ a -> [1] <=> $ b -> [1]}' \
-e 'mapa {[$ _, substr ($ _, 44,3)]} @ l;}' perlebcdic.pod

Mesa in maleficio, ordenados in 1047 solicite
Desde que se redactó este documento por primera vez, la convención se ha vuelto cada vez más de uso
notación hexadecimal para puntos de código. Hacer esto con las recetas y también ordenar es un
proceso de varios pasos, por lo que aquí, por conveniencia, está la tabla de arriba, reordenada para estar en
Página de códigos 1047 en orden y utilizando notación hexadecimal.

ISO
8859-1 POS-CCSID
CCSID CCSID CCSID IX-1047
chr 0819 0037 1047 aC UTF-8 UTF-EBCDIC
-------------------------------------------------- -------------------
00 00 00 00 00 00
01 01 01 01 01 01
02 02 02 02 02 02
03 03 03 03 03 03
9C 04 04 04 C2.9C 04
09 05 05 05 09 05
86 06 06 06 C2.86 06
7F 07 07 07 7F 07
97 08 08 08 C2.97 08
8D 09 09 09 C2.8D 09
2E 8A 0A 0A C0E 2.8A
0B 0B 0B 0B 0B 0B
0C 0C 0C 0C 0C 0C
0D 0D 0D 0D 0D 0D
0E 0E 0E 0E 0E 0E
0F 0F 0F 0F 0F 0F
10 10 10 10 10 10
1 11 11 11 11 11
2 12 12 12 12 12
3 13 13 13 13 13
9D 14 14 14 C2.9D 14
0A 25 15 15 0A 15 **
08 16 16 16 08 16
87 17 17 17 C2.87 17
18 18 18 18 18 18
19 19 19 19 19 19
2 92A 1A 1A C1 2.92A
3F 8B 1B 1B C1F 2.8B
1C 1C 1C 1C 1C 1C
1D 1D 1D 1D 1D 1D
1E 1E 1E 1E 1E 1E
1F 1F 1F 1F 1F 1F
80 20 20 20 C2.80 20
81 21 21 21 C2.81 21
82 22 22 22 C2.82 22
83 23 23 23 C2.83 23
84 24 24 24 C2.84 24
85 15 25 25 C2.85 25 **
17 26 26 26 17 26
1B 27 27 27 1B 27
88 28 28 28 C2.88 28
89 29 29 29 C2.89 29
8A 2A 2A 2A C2.8A 2A
8B 2B 2B 2B C2.8B 2B
8C 2C 2C 2C C2.8C 2C
05 2D 2D 2D 05 2D
06 2E 2E 2E 06 2E
07 2F 2F 2F 07 2F
90 30 30 30 C2.90 30
1 91 31 31 C31 2.91
16 32 32 32 16 32
93 33 33 33 C2.93 33
94 34 34 34 C2.94 34
95 35 35 35 C2.95 35
96 36 36 36 C2.96 36
04 37 37 37 04 37
98 38 38 38 C2.98 38
99 39 39 39 C2.99 39
9A 3A 3A 3A C2.9A 3A
9B 3B 3B 3B C2.9B 3B
4 14C 3C 3C 3 14C
15 3D 3D 3D 15 3D
9E 3E 3E 3E C2.9E 3E
1A 3F 3F 3F 1A 3F
20 40 40 40 20 40
A0 41 41 41 C2.A0 80.41
E2 42 42 42 C3.A2 8B.43
E4 43 43 43 C3.A4 8B.45
E0 44 44 44 C3.A0 8B.41
E1 45 45 45 C3.A1 8B.42
E3 46 46 46 C3.A3 8B.44
E5 47 47 47 C3.A5 8B.46
E7 48 48 48 C3.A7 8B.48
F1 49 49 49 C3.B1 8B.58
A2 4A 4A B0 C2.A2 80.43 ##
. 2E 4B 4B 4B 2E 4B
<3C 4C 4C 4C 3C 4C
(28 4D 4D 4D 28 4D
+ 2B 4E 4E 4E 2B 4E
| 7C 4F 4F 4F 7C 4F
& 26 50 50 50 26 50
E9 51 51 51 C3.A9 8B.4A
EA 52 52 52 C3.AA 8B.51
EB 53 53 53 C3.AB 8B.52
E8 54 54 54 C3.A8 8B.49
ED 55 55 55 C3.AD 8B.54
EE 56 56 56 C3.AE 8B.55
EF 57 57 57 C3.AF 8B.56
EC 58 58 58 C3.AC 8B.53
DF 59 59 59 C3.9F 8A.73
! 21 5A 5A 5A 21 5A
$ 24 5B 5B 5B 24 5B
* 2A 5C 5C 5C 2A 5C
) 29 5D 5D 5D 29 5D
; 3B 5E 5E 5E 3B 5E
^ 5E B0 5F 6A 5E 5F ** ##
- 2D 60 60 60 2D 60
/ 2F 61 61 61 2F 61
C2 62 62 62 C3.82 8A.43
C4 63 63 63 C3.84 8A.45
C0 64 64 64 C3.80 8A.41
C1 65 65 65 C3.81 8A.42
C3 66 66 66 C3.83 8A.44
C5 67 67 67 C3.85 8A.46
C7 68 68 68 C3.87 8A.48
D1 69 69 69 C3.91 8A.58
A6 6A 6A D0 C2.A6 80.47 ##
, 2C 6B 6B 6B 2C 6B
% 25 6C 6C 6C 25 6C
_ 5F 6D 6D 6D 5F 6D
> 3E 6E 6E 6E 3E 6E
? 3F 6F 6F 6F 3F 6F
F8 70 70 70 C3.B8 8B.67
C9 71 71 71 C3.89 8A.4A
CA 72 72 72 C3.8A 8A.51
CB 73 73 73 C3.8B 8A.52
C8 74 74 74 C3.88 8A.49
CD 75 75 75 C3.8D 8A.54
CE 76 76 76 C3.8E 8A.55
CF 77 77 77 C3.8F 8A.56
CC 78 78 78 C3.8C 8A.53
60 79 79 4A 60 79 ##
: 3A 7A 7A 7A 3A 7A
# 23 7B 7B 7B 23 7B
@ 40 7C 7C 7C 40 7C
'27 7D 7D 7D 27 7D
= 3D 7E 7E 7E 3D 7E
"22 7F 7F 7F 22 7F
D8 80 80 80 C3.98 8A,67
a 61 81 81 81 61 81
b 62 82
c 63 83
d 64
e 65
f 66
g 67
hora 68 88 88 88 68 88
yo 69, 89, 89, 89, 69, 89
AB 8A 8A 8A C2.AB 80.52
BB 8B 8B 8B C2.BB 80.6A
F0 8C 8C 8C C3.B0 8B.57
FD 8D 8D 8D C3.BD 8B.71
FE 8E 8E 8E C3.BE 8B.72
B1 8F 8F 8F C2.B1 80.58
B0 90 90 90 C2.B0 80.57
6A 91 91 91 6A 91
k 6B 92 92 92 6B 92
6C 93 93 93 6C 93
6D 94 94 94 6D 94
norte 6E 95 95 95 6E 95
6F 96 96 96 6F 96
p. 70
q 71
r 72, 99, 99, 99, 72, 99
AA 9A 9A 9A C2.AA 80.51
BA 9B 9B 9B C2.BA 80.69
E6 9C 9C 9C C3.A6 8B.47
B8 9D 9D 9D C2.B8 80.67
C6 9E 9E 9E C3.86 8A.47
A4 9F 9F 9F C2.A4 80.45
B5 A0 A0 A0 C2.B5 80.64
~ 7E A1 A1 FF 7E A1 ##
73 A2 A2 A2 73 A2
74 A3 A3 A3 74 A3
75 A4 A4 A4 75 A4
76 A5 A5 A5 76 A5
77 A6 A6 A6 77 A6
x 78 A7 A7 A7 78 A7
y 79 A8 A8 A8 79 A8
7A A9 A9 A9 7A A9
A1 AA AA AA C2.A1 80.42
BF AB AB AB C2.BF 80.73
D0 CA CA CA C3.90 8A.57
[5B BA AD BB 5B AD ** ##
DE AE AE AE C3.9E 8A.72
AE AF AF AF C2.AE 80.55
AC 5F B0 BA C2.AC 80.53 ** ##
A3 B1 B1 B1 C2.A3 80.44
A5 B2 B2 B2 C2.A5 80.46
B7 B3 B3 B3 C2.B7 80.66
A9 B4 B4 B4 C2.A9 80.4A
A7 B5 B5 B5 C2.A7 80.48
B6 B6 B6 B6 C2.B6 80.65
BC B7 B7 B7 C2.BC 80.70
BD B8 B8 B8 C2.BD 80.71
BE B9 B9 B9 C2.BE 80.72
DD AD BA AD C3.9D 8A.71 ** ##
A8 BD BB 79 C2.A8 80.49 ** ##
AF BC BC A1 C2.AF 80.56 ##
] 5D BD BD BD 5D BD **
B4 BE BE BE C2.B4 80.63
D7 BF BF BF C3.97 8A.66
{7B C0 C0 FB 7B C0 ##
Un 41 C1 C1 C1 41 C1
B 42 C2 C2 C2 42 C2
C 43 C3 C3 C3 43 C3
D 44 C4 C4 C4 44 C4
E 45 C5 C5 C5 45 C5
F 46 C6 C6 C6 46 C6
G 47 C7 C7 C7 47 C7
H 48 C8 C8 C8 48 C8
Yo 49 C9 C9 C9 49 C9
AD CA CA CA C2.AD 80.54
F4 CB CB CB C3.B4 8B.63
F6 CC CC CC C3.B6 8B.65
F2 CD CD CD C3.B2 8B.59
F3 CE CE CE C3.B3 8B.62
F5 CF CF CF C3.B5 8B.64
} 7D D0 D0 FD 7D D0 ##
J 4A D1 D1 D1 4A D1
K 4B D2 D2 D2 4B D2
L 4C D3 D3 D3 4C D3
4D D4 D4 D4 4D D4
4E D5 D5 D5 4E D5
4F D6 D6 D6 4F D6
P 50 D7 D7 D7 50 D7
Q 51 D8 D8 D8 51 D8
R 52 D9 D9 D9 52 D9
B9 DA DA DA C2.B9 80.68
FB DB DB DB C3.BB 8B.6A
FC DC DC DC C3.BC 8B.70
F9 DD DD C0 C3.B9 8B.68 ##
FA DE DE DE C3.BA 8B.69
FF DF DF DF C3.BF 8B.73
\ 5C E0 E0 antes de Cristo 5C E0 ##
F7 E1 E1 E1 C3.B7 8B.66
T 53 E2 E2 E2 53 E2
T 54 E3 E3 E3 54 E3
U 55 E4 E4 E4 55 E4
V 56 E5 E5 E5 56 E5
W 57 E6 E6 E6 57 E6
X 58 E7 E7 E7 58 E7
Y 59 E8 E8 E8 59 E8
Z 5A E9 E9 E9 5A E9
B2 EA EA EA C2.B2 80.59
D4 EB EB EB C3.94 8A.63
D6 EC EC EC C3.96 8A.65
D2 ED ED ED C3.92 8A.59
D3 EE EE EE C3.93 8A.62
D5 EF EF EF C3.95 8A.64
0 30 F0 F0 F0 30 F0
1 31 F1 F1 F1 31 F1
2 32 F2 F2 F2 32 F2
3 33 F3 F3 F3 33 F3
4 34 F4 F4 F4 34 F4
5 35 F5 F5 F5 35 F5
6 36 F6 F6 F6 36 F6
7 37 F7 F7 F7 37 F7
8 38 F8 F8 F8 38 F8
9 39 F9 F9 F9 39 F9
B3 FA FA FA C2.B3 80.62
DB FB FB DD C3.9B 8A.6A ##
CC FC FC FC C3.9C 8A.70
D9 FD FD E0 C3.99 8A.68 ##
DA FE FE FE C3.9A 8A.69
9F FF FF 5F C2.9F FF ##

IDENTIFICAR PERSONAJE CÓDIGO CONJUNTOS

Es posible determinar con qué juego de caracteres está operando. Pero primero tu
necesita estar realmente seguro de que necesita hacer esto. Tu código será más simple y probablemente
igual de portátil si no tienes que probar el conjunto de caracteres y hacer cosas diferentes,
dependiente. En realidad, hay muy pocas circunstancias en las que no sea fácil escribir
código de línea recta portátil para todos los juegos de caracteres. Consulte "Unicode y EBCDIC" en
perluniintro sobre cómo especificar caracteres de forma portátil.

Pero hay algunos casos en los que es posible que desee saber qué juego de caracteres está ejecutando
debajo. Un posible ejemplo es ordenar en bucles internos donde el rendimiento es
crítico.

Para determinar si está ejecutando en ASCII o EBCDIC, puede utilizar el valor de retorno de
"ord ()" o "chr ()" para probar uno o más valores de caracteres. Por ejemplo:

$ is_ascii = "A" eq chr(65);
$ is_ebcdic = "A" eq chr(193);
$ es_ascii = ord ("A") == 65;
$ es_ebcdic = ord ("A") == 193;

Hay incluso menos necesidad de distinguir entre páginas de códigos EBCDIC, pero para hacerlo, intente buscar
en uno o más de los personajes que difieren entre ellos.

$ es_ascii = ord ('[') == 91;
$ is_ebcdic_37 = ord ('[') == 186;
$ is_ebcdic_1047 = ord ('[') == 173;
$ is_ebcdic_POSIX_BC = ord ('[') == 187;

Sin embargo, no sería prudente escribir pruebas como:

$ is_ascii = "\ r" ne chr(13); # INCORRECTO
$ is_ascii = "\ n" ne chr(10); # ENFERMOS ACONSEJADOS

Obviamente, el primero de ellos no podrá distinguir la mayoría de las plataformas ASCII de una
CCSID 0037, una plataforma 1047 o POSIX-BC EBCDIC desde "" \ r "eq chr(13) "en todos los
esos conjuntos de caracteres codificados. Pero tenga en cuenta también que porque "\ n" es "chr(13) "y" \ r "es
"chr(10) "en Macintosh antiguo (que es una plataforma ASCII), la segunda prueba $ is_ascii
dar lugar a problemas allí.

Para determinar si perl fue construido bajo una página de códigos EBCDIC, puede usar el
Módulo de configuración así:

usar configuración;
$ is_ebcdic = $ Config {'ebcdic'} eq 'definir';

CONVERSIONES

"utf8 :: unicode_to_native ()" y "utf8 :: native_to_unicode ()"
Estas funciones toman un punto de código numérico de entrada en una codificación y devuelven lo que
el valor equivalente está en el otro.

Ver utf8.

tr ///
Para convertir una cadena de caracteres de un juego de caracteres a otro, una lista simple
de números, como en las columnas de la derecha en la tabla anterior, junto con "tr ///" de Perl
operador es todo lo que se necesita. Los datos de la tabla están en orden ASCII / Latin1, por lo tanto
las columnas EBCDIC proporcionan operaciones ASCII / Latin1 a EBCDIC fáciles de usar que también son
fácilmente invertido.

Por ejemplo, para convertir ASCII / Latin1 a la página de códigos 037, tome la salida del segundo
columna de números de la salida de la receta 2 (modificada para agregar caracteres "\"), y úsela en
"tr ///" así:

$ cp_037 =
'\x00\x01\x02\x03\x37\x2D\x2E\x2F\x16\x05\x25\x0B\x0C\x0D\x0E\x0F' .
'\x10\x11\x12\x13\x3C\x3D\x32\x26\x18\x19\x3F\x27\x1C\x1D\x1E\x1F' .
'\x40\x5A\x7F\x7B\x5B\x6C\x50\x7D\x4D\x5D\x5C\x4E\x6B\x60\x4B\x61' .
'\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\x7A\x5E\x4C\x7E\x6E\x6F' .
'\x7C\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xD1\xD2\xD3\xD4\xD5\xD6' .
'\xD7\xD8\xD9\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xBA\xE0\xBB\xB0\x6D' .
'\x79\x81\x82\x83\x84\x85\x86\x87\x88\x89\x91\x92\x93\x94\x95\x96' .
'\x97\x98\x99\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xC0\x4F\xD0\xA1\x07' .
'\x20\x21\x22\x23\x24\x15\x06\x17\x28\x29\x2A\x2B\x2C\x09\x0A\x1B' .
'\x30\x31\x1A\x33\x34\x35\x36\x08\x38\x39\x3A\x3B\x04\x14\x3E\xFF' .
'\x41\xAA\x4A\xB1\x9F\xB2\x6A\xB5\xBD\xB4\x9A\x8A\x5F\xCA\xAF\xBC' .
'\x90\x8F\xEA\xFA\xBE\xA0\xB6\xB3\x9D\xDA\x9B\x8B\xB7\xB8\xB9\xAB' .
'\x64\x65\x62\x66\x63\x67\x9E\x68\x74\x71\x72\x73\x78\x75\x76\x77' .
'\ xAC \ x69 \ xED \ xEE \ xEB \ xEF \ xEC \ xBF \ x80 \ xFD \ xFE \ xFB \ xFC \ xAD \ xAE \ x59'.
'\x44\x45\x42\x46\x43\x47\x9C\x48\x54\x51\x52\x53\x58\x55\x56\x57' .
'\x8C\x49\xCD\xCE\xCB\xCF\xCC\xE1\x70\xDD\xDE\xDB\xDC\x8D\x8E\xDF';

my $ ebcdic_string = $ ascii_string;
eval '$ cadena_ebcdic = ~ tr / \ 000- \ 377 /'. $ cp_037. '/';

Para convertir de EBCDIC 037 a ASCII simplemente invierta el orden de los argumentos tr /// así:

my $ ascii_string = $ ebcdic_string;
eval '$ cadena_ascii = ~ tr /'. $ cp_037. '/ \ 000- \ 377 /';

De manera similar, se podría tomar la salida de la tercera columna de números de la receta 2 para obtener una
$ cp_1047 tabla. La cuarta columna de números de la salida de la receta 2 podría proporcionar una
La tabla $ cp_posix_bc también es adecuada para la transcodificación.

Si quisiera ver las tablas inversas, primero tendría que ordenar las que desee.
columna de números como en las recetas 4, 5 o 6, luego tome la salida de la primera columna de números.

iconv
La operatividad de XPG a menudo implica la presencia de un iconv utilidad disponible desde el shell o
de la biblioteca C. Consulte la documentación de su sistema para obtener información sobre iconv.

En OS / 390 oz / OS, consulte la iconv(1) página de manual. Una forma de invocar la utilidad de shell "iconv"
desde dentro de perl sería:

# Ejemplo de OS / 390 o z / OS
$ ascii_data = `echo '$ ebcdic_data' | iconv -f IBM-1047 -t ISO8859-1`

o el mapa inverso:

# Ejemplo de OS / 390 o z / OS
$ ebcdic_data = `echo '$ ascii_data' | iconv -f ISO8859-1 -t IBM-1047`

Para otras opciones de conversión basadas en Perl, vea los módulos "Convert :: *" en CPAN.

C RTL
Las bibliotecas de tiempo de ejecución de OS / 390 yz / OS C proporcionan funciones "_atoe ()" y "_etoa ()".

OPERADOR DIFERENCIAS

El operador de rango ".." trata ciertos rangos de caracteres con cuidado en las plataformas EBCDIC.
Por ejemplo, la siguiente matriz tendrá veintiséis elementos en una plataforma EBCDIC
o una plataforma ASCII:

@alfabeto = ('A' .. 'Z'); # $ # alfabeto == 25

Los operadores bit a bit como & ^ | puede devolver resultados diferentes cuando se opera en una cuerda
o datos de caracteres en un programa Perl que se ejecuta en una plataforma EBCDIC que cuando se ejecuta en un
Plataforma ASCII. Aquí hay un ejemplo adaptado del de perlop:

# Ejemplos basados ​​en EBCDIC
imprimir "jp \ n" ^ "ah"; # imprime "JAPH \ n"
imprimir "JA" | "ph \ n"; # imprime "japh \ n"
imprimir "JAPH \ nJunk" & "\ 277 \ 277 \ 277 \ 277 \ 277"; # imprime "japh \ n";
imprimir 'p N $' ^ "E

Una propiedad interesante de los 32 caracteres de control C0 en la tabla ASCII es que
puede "literalmente" construirse como caracteres de control en Perl, por ejemplo, "(chr(0) "eq" \ c @ ")>
"(chr(1) "eq" \ cA ")>, y así sucesivamente. Perl en plataformas EBCDIC ha sido adaptado para tomar" \ c @ "
a chr(0) y "\ cA" para chr(1), etc.también, pero los caracteres que resultan dependen de
qué página de códigos está utilizando. La siguiente tabla utiliza los acrónimos estándar para
control S. Los conjuntos POSIX-BC y 1047 son idénticos en toda esta gama y se diferencian de
el 0037 se estableció en un solo lugar (21 decimal). Tenga en cuenta que el carácter de terminador de línea puede
ser generado por "\ cJ" en plataformas ASCII pero por "\ cU" en plataformas 1047 o POSIX-BC y
no se puede generar como una "\ c.letter". personaje de control en plataformas 0037. Tenga en cuenta también que
"\ c \" no puede ser el elemento final en una cadena o expresión regular, ya que absorberá el terminador.
Pero "\ c \X" es un "SEPARADOR DE ARCHIVOS" concatenado con X para todos X. El valor atípico "\ c?" sobre
ASCII, que produce un control no C0 "DEL", produce el control atípico "APC" en EBCDIC,
el que no está en el bloque de controles contiguos. Tenga en cuenta que una sutileza de esto es
¿esa c?" en plataformas ASCII es un carácter ASCII, mientras que no es equivalente a ningún
Carácter ASCII en plataformas EBCDIC.

chr ord 8859-1 0037 1047 && POSIX-BC
-------------------------------------------------- ---------------------
\ c @ 0
\ cA 1
\ cB 2
\ cC 3
\ cD 4
\ cE 5
\ cF 6
\ cG 7
\ cH 8
\ cI 9
\ cJ 10
\ cK 11
\ cL 12
\ cM 13
\ cN 14
\ cO 15
\ cP 16
\ cQ 17
\ cR 18
\ cS 19
\ cT 20
\ cU 21 **
\ cV 22
\ cW 23
\ cX 24
\ cY 25
\ cZ 26
\ c [27
\ c \ X 28 X X X
\ c] 29
\ c ^ 30
\ c_ 31
\¿C? *

"*" Nota: "\ c?" se asigna al ordinal 127 ("DEL") en plataformas ASCII, pero dado que el ordinal 127 es un
no es un carácter de control en máquinas EBCDIC, "\ c?" en su lugar, los asigna a "APC", que es
255 en 0037 y 1047, y 95 en POSIX-BC.

FUNCIÓN DIFERENCIAS

"chr ()" "chr ()" debe recibir un argumento de número de código EBCDIC para obtener un carácter deseado
valor de retorno en una plataforma EBCDIC. Por ejemplo:

$ CAPITAL_LETTER_A = chr(193);

El punto de código más grande que se puede representar en UTF-EBCDIC es U + 7FFF_FFFF. Si tu
hacer "chr ()" en un valor mayor, un error de tiempo de ejecución (similar a la división por 0)
suceder.

"ord ()" "ord ()" devolverá valores de número de código EBCDIC en una plataforma EBCDIC. Por ejemplo:

$ the_number_193 = ord ("A");

"paquete()"
Las plantillas "c" y "C" para "pack ()" dependen de la codificación del juego de caracteres.
Ejemplos de uso en EBCDIC incluyen:

$ foo = paquete ("CCCC", 193,194,195,196);
# $ foo eq "ABCD"
$ foo = paquete ("C4", 193,194,195,196);
# la misma cosa

$ foo = paquete ("ccxxcc", 193,194,195,196);
# $ foo eq "AB \ 0 \ 0CD"

La plantilla "U" se ha adaptado para que signifique "Unicode" en todas las plataformas, de modo que

paquete ("U", 65) eq 'A'

es cierto en todas las plataformas. Si desea puntos de código nativo para los 256 bajos, use el
Plantilla "W". Esto significa que las equivalencias

pack ("W", ord ($ carácter)) eq $ carácter
desempaquetar ("W", $ carácter) == ord $ carácter

sostendrá.

El punto de código más grande que se puede representar en UTF-EBCDIC es U + 7FFF_FFFF. Si tu
intente empaquetar un valor mayor en un carácter, un error de tiempo de ejecución (similar a la división
por 0) sucederá.

"impresión()"
Hay que tener cuidado con los escalares y las cadenas que se pasan a imprimir que contienen
Codificaciones ASCII. Un lugar común para que esto ocurra es en la salida del MIME
Tipo de encabezado para escritura de guiones CGI. Por ejemplo, muchas guías de programación de Perl
recomendar algo similar a:

print "Tipo de contenido: \ ttext / html \ 015 \ 012 \ 015 \ 012";
# esto puede estar mal en EBCDIC

En su lugar puedes escribir

imprimir "Tipo de contenido: \ ttext / html \ r \ n \ r \ n"; # OK para DGW et al

y hacer que funcione de forma portátil.

Esto se debe a que la traducción de EBCDIC a ASCII la realiza el servidor web en
este caso. Consulte la documentación de su servidor web para obtener más detalles.

"printf ()"
Los formatos que pueden convertir caracteres a números y viceversa serán
diferente de sus contrapartes ASCII cuando se ejecutan en una plataforma EBCDIC.
Algunos ejemplos son:

printf ("% c% c% c", 193,194,195); # imprime ABC

"clasificar()"
Los resultados de clasificación EBCDIC pueden diferir de los resultados de clasificación ASCII, especialmente para casos mixtos
instrumentos de cuerda. Esto es discutido con más detalle abajo.

"sprintf ()"
Vea la discusión de "printf ()" arriba. Un ejemplo del uso de sprintf sería
ser:

$ LETRA_CAPITAL_A = sprintf ("% c", 193);

"deshacer()"
Vea la discusión de "pack ()" arriba.

Tenga en cuenta que es posible escribir código portátil para estos especificando cosas en Unicode
números y usando una función de conversión:

printf ("% c", utf8 ::unicode_to_nativo(sesenta y cinco)); # imprime A en todos
# plataformas
imprimir utf8 :: native_to_unicode (ord ("A")); # Asimismo, imprime 65

Vea "Unicode y EBCDIC" en perluniintro y "CONVERSIONES" para otras opciones.

REGULAR EXPRESIÓN DIFERENCIAS

Puede escribir sus expresiones regulares como lo haría alguien en una plataforma ASCII.
Pero tenga en cuenta que el uso de notación octal o hexadecimal para especificar un punto de código en particular
darle el carácter que la página de códigos EBCDIC le asigna de forma nativa. (Esto también es cierto
de todas las cadenas entre comillas dobles.) Si desea escribir de forma portátil, simplemente use "\ N {U + ...}"
notación en todas partes donde habría usado "\ x {...}", y no use notación octal en
todas.

A partir de Perl v5.22, esto se aplica a rangos en clases de caracteres entre corchetes. Si tu
digamos, por ejemplo, "qr / [\ N {U + 20} - \ N {U + 7F}] /", significa los caracteres "\ N {U + 20}",
"\ N {U + 21}", ..., "\ N {U + 7F}". Este rango son todos los caracteres imprimibles que el ASCII
contiene el juego de caracteres.

Antes de v5.22, no podía especificar ningún rango de forma portátil, excepto (a partir de Perl v5.5.3)
todos los subconjuntos de los rangos "[AZ]" y "[az]" están codificados especialmente para no recoger espacios
caracteres. Por ejemplo, caracteres como "o" ("o CON CIRCUNFLEX") que se encuentran entre
"I" y "J" no coincidirían con el rango de expresión regular "/ [HK] /". Pero si cualquiera
de los puntos finales del rango es explícitamente numérico (y ninguno está especificado por "\ N {U + ...}"),
los caracteres de espacio coinciden:

/ [\ x89- \ x91] /

coincidirá con "\ x8e", aunque "\ x89" es "i" y "\ x91" es "j", y "\ x8e" es un espacio
carácter, desde el punto de vista alfabético.

Otra construcción de la que hay que tener cuidado es el uso inapropiado de hex (a menos que uses
"\ N {U + ...}") o constantes octales en expresiones regulares. Considere el siguiente conjunto de
sustitutos:

sub es_c0 {
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ 000- \ 037] /;
}

subis_print_ascii {
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ 040- \ 176] /;
}

sub is_delete {
my $ char = substr (cambio, 0,1);
$ char eq "\ 177";
}

sub es_c1 {
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ 200- \ 237] /;
}

sub is_latin_1 {# Pero no ASCII; no C1
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ 240- \ 377] /;
}

Estos son válidos solo en plataformas ASCII. A partir de Perl v5.22, simplemente cambiando el
Las constantes octales a valores equivalentes "\ N {U + ...}" las hacen portátiles:

sub es_c0 {
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ N {U + 00} - \ N {U + 1F}] /;
}

subis_print_ascii {
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ N {U + 20} - \ N {U + 7E}] /;
}

sub is_delete {
my $ char = substr (cambio, 0,1);
$ char eq "\ N {U + 7F}";
}

sub es_c1 {
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ N {U + 80} - \ N {U + 9F}] /;
}

sub is_latin_1 {# Pero no ASCII; no C1
my $ char = substr (cambio, 0,1);
$ char = ~ / [\ N {U + A0} - \ N {U + FF}] /;
}

Y aquí hay algunas formas portátiles alternativas de escribirlos:

sub es_c0 {
my $ char = substr (cambio, 0,1);
return $ char = ~ / [[: cntrl:]] / a &&! Is_delete ($ char);

# Alternativamente:
# return $ char = ~ / [[: cntrl:]] /
# && $ char = ~ / [[: ascii:]] /
# &&! Is_delete ($ char);
}

subIs_print_ascii {
my $ char = substr (cambio, 0,1);

return $ char = ~ / [[: print:]] / a;

# Alternativamente:
# return $ char = ~ / [[: print:]] / && $ char = ~ / [[: ascii:]] /;

# O
# return $ char
# = ~ / [! "\ # \ $% & '() * +, \ -. \ / 0-9:; <=>? \ @ AZ [\\\] ^ _` az {|} ~] /;
}

sub Es_borrar {
my $ char = substr (cambio, 0,1);
return utf8 :: native_to_unicode (ord $ char) == 0x7F;
}

sub es_c1 {
use la función 'unicode_strings';
my $ char = substr (cambio, 0,1);
return $ char = ~ / [[: cntrl:]] / && $ char! ~ / [[: ascii:]] /;
}

sub Is_latin_1 {# Pero no ASCII; no C1
use la función 'unicode_strings';
my $ char = substr (cambio, 0,1);
return ord ($ char) <256
&& $ char! ~ / [[: ascii:]] /
&& $ char! ~ / [[: cntrl:]] /;
}

Otra forma de escribir "Is_latin_1 ()" sería usar los caracteres en el rango
explícitamente:

sub es_latin_1 {
my $ char = substr (cambio, 0,1);
$ char = ~ / [XXXXXXXXXXXXXXXXXXXXXXXXXXXXAAAA ~ AeAaAECEEEEeIIIIe]
[‐N ~ OOOO ~ OeXOUUUUeYPssaaaa ~ aeaaaeceeeeeiiiie`n ~ oooo ~ oeXouuuueypye] / x;
}

Aunque esa forma puede tener problemas en el tránsito de la red (debido a la presencia de 8 bits
caracteres) o en conjuntos de caracteres no ISO-latinos. Pero sí permite reescribir "Is_c1"
por lo que funciona en Perls que no tienen 'unicode_strings' (anteriores a v5.14):

sub Is_latin_1 {# Pero no ASCII; no C1
my $ char = substr (cambio, 0,1);
return ord ($ char) <256
&& $ char! ~ / [[: ascii:]] /
&&! Is_latin1 ($ char);
}

ENCHUFES

La mayoría de la programación de sockets asume codificaciones de caracteres ASCII en el orden de bytes de la red.
Las excepciones pueden incluir la escritura de scripts CGI en un servidor web host donde el servidor puede
se encarga de la traducción por usted. La mayoría de los servidores web host convierten los datos EBCDIC a ISO-8859-1
o Unicode en la salida.

CLASIFICACIÓN

Una gran diferencia entre los juegos de caracteres basados ​​en ASCII y los de EBCDIC es la relativa
posiciones de los personajes cuando se ordenan en orden nativo. Lo más preocupante son los
y letras minúsculas, los dígitos y el subrayado ("_"). En las plataformas ASCII,
El orden de clasificación nativo tiene los dígitos antes de las letras mayúsculas que vienen antes de la
subrayado que viene antes de las letras minúsculas. En EBCDIC, el subrayado viene
primero, luego las letras minúsculas, luego las mayúsculas y los dígitos al final. Si
ordenados en una plataforma basada en ASCII, la abreviatura de dos letras para un médico viene
antes de la abreviatura de dos letras de drive; es decir:

@ordenados = ordenar (qw (Dr. dr.)); # @ retenciones clasificadas ('Dr.', 'dr.') en ASCII,
# pero ('dr.', 'Dr.') en EBCDIC

La propiedad de minúsculas antes de mayúsculas en EBCDIC se lleva incluso al latín
1 páginas EBCDIC como 0037 y 1047. Un ejemplo sería que "Ee" ("E CON DIAERESIS",
203) viene antes de "ee" ("e CON DIAERESIS", 235) en una plataforma ASCII, pero la última (83)
viene antes que el primero (115) en una plataforma EBCDIC. (Los lectores astutos notarán que el
La versión en mayúsculas de "ss" "LETRA MINÚSCULA S AFILADA" es simplemente "SS" y que las mayúsculas
las versiones de "ye" (pequeña "y CON DIAERESIS") y "X" ("MICRO SIGN") no están en el 0..255
rango pero están en Unicode, en un Perl habilitado para Unicode).

El orden de clasificación causará diferencias entre los resultados obtenidos en plataformas ASCII versus
Plataformas EBCDIC. A continuación se ofrecen algunas sugerencias sobre cómo abordar estos
Diferencias.

pasar por alto ASCII vs EBCDIC sort Diferencias.
Ésta es la estrategia menos costosa desde el punto de vista computacional. Puede requerir cierta educación del usuario.

Use a sort ayudante función
Esta es una estrategia completamente general, pero la más costosa desde el punto de vista computacional. Elige uno
o el otro juego de caracteres y transformarlo para cada tipo de comparación. Aquí está un
ejemplo completo que se transforma en orden de clasificación ASCII:

sub native_to_uni ($) {
my $ string = shift;

# Ahorra tiempo en una plataforma ASCII
devuelve $ cadena si ord 'A' == 65;

mi $ salida = "";
para mi $ i (0 .. longitud ($ cadena) - 1) {
$ salida
. = chr (utf8 :: native_to_unicode (ord (substr ($ cadena, $ i, 1))));
}

# Preservar la utilidad de la entrada en la salida, incluso si no es necesario
# ser utf8
utf8 :: actualización ($ salida) if utf8 :: is_utf8 ($ cadena);

devuelve $ output;
}

sub ascii_order {# Asistente de ordenación
return native_to_uni ($ a) cmp native_to_uni ($ b);
}

ordenar ascii_order @list;

MONO CASE después sort datos (solo para no dígitos, no subrayado)
Si no le importa dónde se ordenan los dígitos y el subrayado, puede hacer algo como
este vídeo

sub case_insensitive_order {# Asistente de ordenación
devolver lc ($ a) cmp lc ($ b)
}

ordenar case_insensitive_order @list;

Si el rendimiento es un problema y no le importa si la salida está en el mismo caso que el
input, Use "tr ///" para transformar al caso más empleado dentro de los datos. Si los datos
son principalmente MAYÚSCULAS no latinas1, luego aplican "tr / [az] / [AZ] /" y luego "sort ()". Si
los datos son principalmente minúsculas, no latin1, luego aplique "tr / [AZ] / [az] /" antes de ordenar.
Si los datos son principalmente MAYÚSCULAS e incluyen caracteres latinos 1, aplique:

tr / [az] / [AZ] /;
tr / [aaaa ~ aeaaaeceeeeeiiiie`n ~ oooo ~ oeouuuueyp] / [AAAA ~ AeAaAECEEEEeIIIIe-N ~ OOOO ~ OeOUUUUeYP /;
s / ss / SS / g;

luego "sort ()". Si tiene una opción, es mejor poner las cosas en minúsculas para evitar la
problemas de los dos caracteres Latin-1 cuya mayúscula está fuera del Latin-1: "ye" (pequeña "y
CON DIÉRESIS ") y" X "(" MICRO SIGNO "). Si necesita poner mayúsculas, puede hacerlo; con un
Perl habilitado para Unicode, haga lo siguiente:

tr / ye / \ x {178} /;
tr / X / \ x {39C} /;

Realizar clasificación on one tipo of gratuita. solamente.
Esta estrategia puede emplear una conexión de red. Como tal, sería computacionalmente
caro.

TRANSFORMACIÓN FORMATOS

Hay una variedad de formas de transformar datos con un mapeo dentro del juego de caracteres que
sirven para una variedad de propósitos. La clasificación se discutió en la sección anterior y algunas de las
las otras técnicas de mapeo más populares se discuten a continuación.

Enlance descodificación y codificación
Tenga en cuenta que algunas URL tienen puntos de código ASCII hexadecimal en un intento de superar
problemas de limitación de carácter o protocolo. Por ejemplo, el carácter de tilde no está en todos los
teclado, por lo tanto, una URL de la forma:

http://www.pvhp.com/~pvhp/

también se puede expresar como cualquiera de los siguientes:

http://www.pvhp.com/% 7Epvhp /

http://www.pvhp.com/% 7epvhp /

donde 7E es el punto de código ASCII hexadecimal para "~". Aquí hay un ejemplo de decodificación de tales
una URL en cualquier página de códigos EBCDIC:

$ url = 'http://www.pvhp.com/% 7Epvhp / ';
$ url = ~ s /% ([0-9a-fA-F] {2}) /
paquete ("c", utf8 :: unicode_to_native (hex ($ 1))) / xge;

Por el contrario, aquí hay una solución parcial para la tarea de codificar dicha URL en cualquier EBCDIC
página de código:

$ url = 'http://www.pvhp.com/~pvhp/';
# La siguiente expresión regular no aborda el
# asignaciones para: ('.' => '% 2E', '/' => '% 2F', ':' => '% 3A')
$ url = ~ s / ([\ t "#% & \ (\),; <=> \? \ @ \ [\\\] ^` {|} ~]) /
sprintf ("%%% 02X", utf8 :: native_to_unicode (ord ($ 1))) / xge;

donde una solución más completa dividiría la URL en componentes y aplicaría un s /// completo
sustitución solo a las partes apropiadas.

uu codificación y descodificación
La plantilla "u" para "pack ()" o "unpack ()" representará los datos EBCDIC en caracteres EBCDIC
equivalente a sus homólogos ASCII. Por ejemplo, lo siguiente imprimirá "Sí
de hecho \ n "en una computadora ASCII o EBCDIC:

$ all_byte_chrs = '';
para (0..255) {$ all_byte_chrs. = chr ($ _); }
$ uuencode_byte_chrs = paquete ('u', $ all_byte_chrs);
($ uu = << 'ENDOFHEREDOC') = ~ s / ^ \ s * // gm;
M``$"`P0%!@<("0H+#`T.#Q`1$A,4%187&!D:&QP='A\@(2(C)"4F)R@I*BLL
M+2XO,#$R,S0U-C<X.3H[/#T^/T!!0D-$149'2$E*2TQ-3D]045)35%565UA9
M6EM<75Y?8&%B8V1E9F=H:6IK;&UN;W!Q<G-T=79W>'EZ>WQ]?G^`@8*#A(6&
MAXB)BHN,C8Z/D)&2DY25EI>8F9J;G)V>GZ"AHJ.DI::GJ*FJJZRMKJ^PL;*S
MM+6VM[BYNKN\O;Z_P,'"P\3%QL?(R<K+S,W.S]#1TM/4U=;7V-G:V]S=WM_@
? X> + CY.7FY ^ CIZNOL [> [O \ / 'R \ _3U] O? X ^? K [_ / W ^ _P``
ENDOFHEREDOC
if ($ uuencode_byte_chrs eq $ uu) {
imprimir "Sí";
}
$ uudecode_byte_chrs = desempaquetar ('u', $ uuencode_byte_chrs);
if ($ uudecode_byte_chrs eq $ all_byte_chrs) {
imprimir "de hecho \ n";
}

Aquí hay un uudecoder muy espartano que funcionará en EBCDIC:

#! / usr / local / bin / perl
$ _ = <> hasta ($ modo, $ archivo) = / ^ comenzar \ s * (\ d *) \ s * (\ S *) /;
open (OUT, "> $ archivo") si $ archivo ne "";
while (<>) {
último si / ^ end /;
siguiente si / [az] /;
siguiente a menos que int ((((utf8 :: native_to_unicode (ord ()) - 32) & 077)
+ 2) / 3)
== int (longitud () / 4);
print OUT desempaquetar ("u", $ _);
}
cerrar);
chmod oct ($ modo), $ archivo;

Cotizado-Imprimible codificación y descodificación
En plataformas codificadas en ASCII, es posible quitar caracteres fuera del conjunto imprimible
mediante:

# Este codificador QP funciona solo en ASCII
$ qp_string = ~ s / ([= \ x00- \ x1F \ x80- \ xFF]) /
sprintf ("=% 02X", ord ($ 1)) / xge;

A partir de Perl v5.22, esto es trivialmente modificable para funcionar de forma portátil tanto en ASCII como en
Plataformas EBCDIC.

# Este codificador QP funciona tanto en ASCII como en EBCDIC
$ qp_string = ~ s / ([= \ N {U + 00} - \ N {U + 1F} \ N {U + 80} - \ N {U + FF}]) /
sprintf ("=% 02X", ord ($ 1)) / xge;

Para Perls anteriores, un codificador QP que funciona tanto en plataformas ASCII como EBCDIC se vería
algo parecido a lo siguiente:

$ borrar = utf8 :: unicode_to_native (ord ("\ x7F"));
$ qp_string = ~
s / ([^ [: imprimir:] $ eliminar]) /
sprintf ("=% 02X", utf8 :: native_to_unicode (ord ($ 1))) / xage;

(aunque en el código de producción las sustituciones se pueden hacer en la rama EBCDIC con el
llamada de función y por separado en la rama ASCII sin el gasto del mapa de identidad;
en Perl v5.22, el mapa de identidad está optimizado para que no haya gastos, pero el
La alternativa anterior es más simple y también está disponible en v5.22).

Estas cadenas QP se pueden decodificar con:

# Este decodificador QP está limitado solo a ASCII
$ cadena = ~ s / = ([[: xdigit:] [[: xdigit:]) / chr hex $ 1 / ge;
$ cadena = ~ s / = [\ n \ r] + $ //;

Mientras que un decodificador QP que funciona tanto en plataformas ASCII como EBCDIC se vería algo
como el siguiente:

$ cadena = ~ s / = ([[: xdigit:] [: xdigit:]]) /
chr utf8 :: native_to_unicode (hex $ 1) / xge;
$ cadena = ~ s / = [\ n \ r] + $ //;

cesariano sistemas de cifrado
La práctica de cambiar un alfabeto uno o más caracteres para cifrar se remonta a
miles de años y fue explícitamente detallado por Cayo Julio César en su gálico Guerras
texto. Un solo cambio alfabético a veces se denomina rotación y la cantidad de cambio
se da como un número $ n después de la cadena 'rot' o "rot $ n". Rot0 y rot26 designarían
mapas de identidad en la versión en inglés de 26 letras del alfabeto latino. Rot13 tiene el
propiedad interesante que alternan las invocaciones posteriores son mapas de identidad (por lo tanto, rot13
es su propia inversa no trivial en el grupo de 26 rotaciones alfabéticas). Por lo tanto, la
A continuación se muestra un codificador y decodificador rot13 que funcionará en plataformas ASCII y EBCDIC:

#! / usr / local / bin / perl

while (<>) {
tr / n-za-mN-ZA-M / a-zA-Z /;
impresión;
}

En forma de una sola línea:

perl -ne 'tr / n-za-mN-ZA-M / a-zA-Z /; imprimir'

Hashing solicite y sumas de comprobación

Perl aleatoriza deliberadamente el orden hash por motivos de seguridad tanto en ASCII como en EBCDIC
plataformas.

Las sumas de comprobación EBCDIC serán diferentes para el mismo archivo traducido a ASCII y viceversa.

I18N Y L10N

La internacionalización (I18N) y la localización (L10N) son compatibles al menos en principio
incluso en plataformas EBCDIC. Los detalles dependen del sistema y se describen en la sección "Sistema operativo
CUESTIONES "a continuación.

MULTI-OCTETO PERSONAJE CONJUNTOS

Perl funciona con UTF-EBCDIC, una codificación de varios bytes. En Perls anteriores a la v5.22, puede haber
ser varios errores en este sentido.

Páginas de códigos EBCDIC de varios bytes heredados XXX.

OS CUESTIONES

Puede haber algunos problemas dependientes del sistema que preocupen a los programadores de EBCDIC Perl.

OS / 400
PASE El entorno PASE es un entorno de ejecución para OS / 400 que puede ejecutar ejecutables
construido para PowerPC AIX en OS / 400; ver perlos400. PASE está basado en ASCII, no en EBCDIC-
basado como el ILE.

Acceso IFS
XXX.

OS / 390, z / OS
Perl se ejecuta bajo Unix Systems Services o USS.

"sigaction"
"SA_SIGINFO" puede tener fallos de segmentación.

"chcp" CHCP se admite como una utilidad de shell para mostrar y cambiar la página de códigos.
Vea también CHCP(1).

acceso al conjunto de datos
Para acceder al conjunto de datos secuenciales, intente:

my @ds_records = `cat // DSNAME`;

o bien:

my @ds_records = `gato // 'HLQ.DSNAME'`;

Consulte también el módulo OS390 :: Stdio en CPAN.

"iconv" iconv se admite como una utilidad de shell y una rutina C RTL. Ver también el
iconv(1) y iconv(3) páginas de manual.

locales Se admiten los entornos locales. Puede haber fallas cuando una configuración regional es otro código EBCDIC
página que tiene algunos de los caracteres variantes de la página de códigos en otras posiciones.

Actualmente no hay ninguna configuración regional UTF-8 real, aunque algunos nombres de configuración regional
contienen la cadena "UTF-8".

Consulte perllocale para obtener información sobre las configuraciones regionales. Los archivos L10N están en / usr / nls / locale.
$ Config {d_setlocale} es 'definir' en OS / 390 oz / OS.

¿POSIX-BC?
XXX.

Use perlebcdic en línea usando los servicios de onworks.net