perlebcdic - Online nel cloud

PROGRAMMA:

NOME

perlebcdic - Considerazioni per l'esecuzione di Perl su piattaforme EBCDIC

DESCRIZIONE

Un'esplorazione di alcuni dei problemi che devono affrontare i programmatori Perl sui computer basati su EBCDIC.

Le parti di questo documento che sono ancora incomplete sono contrassegnate con XXX.

Le prime versioni di Perl funzionavano su alcune macchine EBCDIC, ma l'ultima versione conosciuta che funzionava su
EBCDIC era v5.8.7, fino a v5.22, quando il core Perl funziona di nuovo su z/OS. In teoria, è
potrebbe funzionare su OS/400 o BS2000 di Siemens (o sui loro successori), ma questo non è stato testato. In
v5.22, non tutti i moduli trovati su CPAN ma forniti con core Perl funzionano su z/OS.

Se desideri utilizzare Perl su una macchina EBCDIC non z/OS, faccelo sapere inviando una mail
a [email protected]

Scrivere Perl su una piattaforma EBCDIC non è davvero diverso dallo scrivere su una piattaforma "ASCII",
ma con sottostanti diversi, come vedremo tra poco. Dovrai sapere
qualcosa su quelle piattaforme "ASCII" perché la documentazione è parziale e lo farà
usa spesso numeri di esempio che non si applicano a EBCDIC. Ci sono anche pochissimi CPAN
moduli che sono scritti per EBCDIC e che non funzionano su ASCII; invece il vasto
la maggior parte dei moduli CPAN sono scritti per ASCII e alcuni potrebbero funzionare su EBCDIC,
mentre alcuni sono stati progettati per funzionare in modo portatile su entrambi.

Se il tuo codice utilizza solo le 52 lettere AZ e az, più SPAZIO, le cifre 0-9 e il
caratteri di punteggiatura utilizzati da Perl, più alcuni controlli indicati con escape
sequenze come "\n" e "\t", quindi non c'è niente di speciale nell'usare Perl e il tuo codice
può benissimo funzionare su una macchina ASCII senza modifiche.

Ma se scrivi un codice che usa "\005" per indicare un TAB o "\xC1" per indicare una "A" o "\xDF"
per indicare una "y" (piccola "y" con una dieresi), allora il tuo codice potrebbe funzionare bene sul tuo EBCDIC
piattaforma, ma non su una ASCII. Va bene se nessuno vorrà mai eseguire il tuo
codice su piattaforma ASCII; ma il pregiudizio in questo documento sarà nello scrivere codice portabile
tra i sistemi EBCDIC e ASCII. Di nuovo, se ogni personaggio a cui tieni è facile
inseribile dalla tastiera, non devi sapere nulla di ASCII, ma molti
le tastiere non ti consentono di inserire direttamente, ad esempio, il carattere "\xDF", quindi hai
per specificarlo indirettamente, ad esempio utilizzando la sequenza di escape "\xDF". In quei casi
è più facile sapere qualcosa sui set di caratteri ASCII/Unicode. Se lo sai
il piccolo "ye" è "U+00FF", quindi puoi invece specificarlo come "\N{U+FF}", e avere il
il computer lo traduce automaticamente in "\xDF" sulla tua piattaforma e lo lascia come "\xFF" acceso
quelli ASCII. Oppure puoi specificarlo per nome, "\N{LATIN SMALL LETTER Y WITH DIAERESIS" e
non c'è bisogno di conoscere i numeri. In entrambi i casi funziona, ma richiede familiarità con Unicode.

COMUNI CARATTERE CODICE SETS

ASCII
Il codice standard americano per lo scambio di informazioni (ASCII o US-ASCII) è un insieme di
interi che vanno da 0 a 127 (decimale) che hanno interpretazioni standardizzate dal
computer che utilizzano ASCII. Ad esempio, 65 significa la lettera "A". L'intervallo 0..127 può essere
coperto impostando i bit in una cifra binaria a 7 bit, quindi l'insieme viene talvolta indicato
come "ASCII a 7 bit". ASCII è stato descritto dall'American National Standards Institute
documento ANSI X3.4-1986. È stato anche descritto dalla ISO 646:1991 (con localizzazione per
simboli di valuta). Il set ASCII completo è indicato nella tabella seguente come primo 128
elementi. Le lingue che possono essere scritte adeguatamente con i caratteri in ASCII includono
Inglese, hawaiano, indonesiano, swahili e alcune lingue dei nativi americani.

La maggior parte dei set di caratteri non EBCDIC sono superset di ASCII. Questo è il significato degli interi 0-127
cosa ASCII dice che significano. Ma i numeri interi 128 e superiori sono specifici del set di caratteri.

Molti di questi si adattano interamente a 8 bit, utilizzando ASCII come 0-127, specificando cosa
128-255 significano e non usano nulla al di sopra di 255. Quindi, questi sono a byte singolo (o ottetto se
si preferisce) set di caratteri. Uno importante (poiché Unicode ne è un superset) è il
Set di caratteri ISO 8859-1.

ISO 8859
La ISO 8859-$n sono una raccolta di set di codici di caratteri dall'International
Organization for Standardization (ISO), ognuna delle quali aggiunge caratteri al set ASCII
che si trovano tipicamente in varie lingue, molte delle quali sono basate sul romano, o
latino, alfabeto. La maggior parte sono per le lingue europee, ma ce ne sono anche per l'arabo,
greco, ebraico e tailandese. Ci sono buoni riferimenti sul web su tutti questi.

latino 1 (Iso 8859-1)
Una particolare estensione a 8 bit dell'ASCII che include il latino con accenti gravi e acuti
caratteri. Le lingue che possono utilizzare ISO 8859-1 includono tutte le lingue coperte da
ASCII così come afrikaans, albanese, basco, catalano, danese, faroese, finlandese,
norvegese, portoghese, spagnolo e svedese. L'olandese è coperto anche se senza l'ij
legatura. Anche il francese è coperto ma senza la legatura oe. Il tedesco può utilizzare ISO 8859-1
ma deve farlo senza virgolette in stile tedesco. Questo set è basato su Western
Estensioni europee ad ASCII ed è comunemente riscontrato nel lavoro sul World Wide Web. In IBM
terminologia di identificazione del set di codici di caratteri, ISO 8859-1 è anche noto come CCSID 819 (o
a volte 0819 o anche 00819).

EBCDIC
Il codice di interscambio decimale codificato binario esteso si riferisce a un'ampia raccolta di
e set di caratteri codificati a più byte che sono molto diversi da ASCII e ISO 8859-1,
e sono tutte leggermente diverse l'una dall'altra; in genere vengono eseguiti su computer host. Il
Le codifiche EBCDIC derivano da estensioni di byte a 8 bit delle codifiche delle schede perforate Hollerith,
che precedono a lungo l'ASCII. Il layout delle carte era tale che i bit alti erano impostati per
i caratteri alfabetici maiuscoli e minuscoli "[az]" e "[AZ]", ma c'erano delle lacune
all'interno di ogni intervallo di alfabeto latino, visibile nella tabella sottostante. Queste lacune possono causare
complicazioni.

Alcuni set di caratteri IBM EBCDIC possono essere conosciuti dai numeri di identificazione del set di codici di caratteri
(numeri CCSID) o numeri di code page.

Perl può essere compilato su piattaforme che eseguono uno dei tre caratteri EBCDIC comunemente usati
set, elencati di seguito.

Il 13 variante caratteri

Tra i set di codici di caratteri IBM EBCDIC ci sono 13 caratteri che sono spesso mappati a
valori interi diversi. Questi caratteri sono conosciuti come i 13 caratteri "varianti" e
siamo:

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

Quando Perl viene compilato per una piattaforma, guarda tutti questi caratteri per indovinare quale
Il set di caratteri EBCDIC utilizzato dalla piattaforma e si adatta di conseguenza a tale piattaforma.
Se la piattaforma utilizza un set di caratteri che non è uno dei tre che Perl conosce, Perl
non riuscirà a compilare o sceglierà erroneamente e silenziosamente uno dei tre.

EBCDIC codice set riconosciuto by Perl

0037
Il set di codici di caratteri ID 0037 è una mappatura dei caratteri ASCII più Latin-1 (cioè ISO
8859-1) a un set EBCDIC. 0037 è utilizzato nelle versioni locali dell'inglese nordamericano sul
Sistema operativo OS/400 che gira su computer AS/400. CCSID 0037 differisce da ISO
8859-1 in 236 posti; in altre parole concordano solo su 20 valori di code point.

1047
Il set di codici di caratteri ID 1047 è anche una mappatura dei caratteri ASCII più Latin-1
(cioè ISO 8859-1) a un set EBCDIC. 1047 è utilizzato in Unix System Services per
OS/390 oz/OS e OpenEdition per VM/ESA. CCSID 1047 differisce da CCSID 0037 in
otto posti e dalla ISO 8859-1 in 236.

POSIX-BC
La code page EBCDIC in uso sul sistema BS2000 di Siemens è diversa da 1047 e 0037.
Di seguito è identificato come il set POSIX-BC. Come 0037 e 1047, è lo stesso di ISO
8859-1 in 20 valori di punti di codice.

Unicode codice punti EBCDIC codice punti
Nella terminologia Unicode a codice punto è il numero assegnato a un carattere: per esempio, in
EBCDIC al carattere "A" viene solitamente assegnato il numero 193. In Unicode, il carattere
Ad "A" viene assegnato il numero 65. Tutti i punti di codice in ASCII e Latin-1 (ISO 8859-1) hanno
lo stesso significato in Unicode. Tutti e tre i set di codici EBCDIC riconosciuti hanno 256 codici
punti, e in ogni set di codici, tutti i 256 punti di codice sono mappati al codice Latin1 equivalente
punti. Ovviamente, "A" verrà mappato su "A", "B" => "B", "%" => "%", ecc., per tutti i stampabili
caratteri in Latin1 e queste code page.

Si scopre anche che EBCDIC ha equivalenti quasi precisi per ASCII/Latin1 C0
controlli e il controllo DELETE. (I controlli C0 sono quelli i cui punti di codice ASCII sono
0..0x1F; cose come TAB, ACK, BEL, ecc.) Viene impostata una mappatura tra questi ASCII/EBCDIC
controlli. Non esiste una mappatura così precisa tra i controlli C1 sulle piattaforme ASCII
e i restanti controlli EBCDIC. Ciò che è stato fatto è mappare questi controlli, principalmente
arbitrariamente, a qualche carattere altrimenti non corrispondente nell'altro set di caratteri. La maggior parte
questi sono usati molto molto raramente al giorno d'oggi in EBCDIC comunque, e i loro nomi sono stati
caduto, senza troppe lamentele. Ad esempio il controllo EO (Eight Ones) EBCDIC
(composto da otto bit da uno = 0xFF) è mappato al controllo C1 APC (0x9F) e tu
non è possibile utilizzare il nome "EO".

I controlli EBCDIC forniscono tre possibili caratteri di terminazione di riga, CR (0x0D), LF
(0x25) e NL (0x15). Sulle piattaforme ASCII, i simboli "NL" e "LF" si riferiscono allo stesso
carattere, ma nella rigorosa terminologia EBCDIC sono diversi. L'EBCDIC NL è
mappato al controllo C1 chiamato "NEL" ("Next Line"; ecco un caso in cui la mappatura rende
un po' di buon senso, e quindi non è solo arbitrario). Su alcune piattaforme EBCDIC, questo NL
o NEL è il tipico terminatore di linea. Questo è vero per z/OS e BS2000. In questi
piattaforme, i compilatori C scambieranno i punti di codice LF e NEL, in modo che "\n" sia 0x15 e
si riferisce a NL. Perl fa anche questo; puoi vederlo nella tabella dei codici qui sotto. Questo fa
le cose generalmente "funzionano" senza che tu debba nemmeno essere consapevole che c'è uno scambio.

Unicode e UTF
UTF sta per "Unicode Transformation Format". UTF-8 è una codifica di Unicode in a
sequenza di blocchi di byte da 8 bit, basata su ASCII e Latin-1. La lunghezza di una sequenza
richiesto per rappresentare un punto di codice Unicode dipende dal numero ordinale di quel codice
punto, con numeri più grandi che richiedono più byte. UTF-EBCDIC è come UTF-8, ma basato su
EBCDIC. Sono abbastanza simili che spesso, l'uso casuale fonderà i due termini e
utilizzare "UTF-8" per indicare sia l'UTF-8 trovato su piattaforme ASCII, sia l'UTF-EBCDIC trovato su
quelli EBCDIC.

Potresti vedere il termine carattere "invariante" o punto di codice. Questo significa semplicemente che il
carattere ha lo stesso valore numerico e rappresentazione quando è codificato in UTF-8 (o UTF-
EBCDIC) come quando no. (Nota che questo è un concetto molto diverso da "La variante 13
caratteri" di cui sopra. Un'attenta prosa utilizzerà il termine "UTF-8 invariante" invece di
solo "invariante", ma molto spesso vedrai solo "invariante".) Ad esempio, l'ordinale
il valore di "A" è 193 nella maggior parte delle code page EBCDIC ed è anche 193 quando è codificato in UTF-EBCDIC.
Tutti i punti di codice variante UTF-8 (o UTF-EBCDIC) occupano almeno due byte quando codificati in
UTF-8 (o UTF-EBCDIC); per definizione, i punti di codice invarianti UTF-8 (o UTF-EBCDIC) sono
esattamente un byte se codificato in UTF-8 (o UTF-EBCDIC) o meno. (Ormai capisci perché
le persone in genere dicono solo "UTF-8" quando significano anche "UTF-EBCDIC". Per il resto
documento, saremo per lo più casuali anche su questo.) In ASCII UTF-8, il codice punta
corrispondenti ai 128 numeri ordinali più bassi (0 - 127: i caratteri ASCII) sono
invariante. In UTF-EBCDIC, ci sono 160 caratteri invarianti. (Se ti interessa, l'EBCDIC
invarianti sono quei caratteri che hanno equivalenti ASCII, più quelli che corrispondono
ai controlli C1 (128 - 159 su piattaforme ASCII).)

Una stringa codificata in UTF-EBCDIC può essere più lunga (ma mai più corta) di una codificata in
UTF-8. Perl estende UTF-8 in modo che possa codificare punti di codice al di sopra del massimo Unicode di
U+10FFFF. Estende anche UTF-EBCDIC, ma a causa delle limitazioni intrinseche di UTF-
EBCDIC, il punto di codice massimo esprimibile è U+7FFF_FFFF, anche se la dimensione della parola è maggiore
di 32 bit.

UTF-EBCDIC è definito da Unicode Technical Report #16
<http://www.unicode.org/reports/tr16>. È definito in base a CCSID 1047, non permettendo
per le differenze per altre tabelle codici. Ciò consente un facile interscambio di testo
tra computer che eseguono codepage diverse, ma lo rende inutilizzabile, senza adattamento,
per Perl su quelle altre pagine di codice.

La ragione di questa inutilizzabilità è che un presupposto fondamentale di Perl è che il
i caratteri a cui tiene per l'analisi e l'analisi lessicale sono gli stessi indipendentemente dal fatto che
il testo è in UTF-8. Ad esempio, Perl si aspetta che il carattere "[" abbia lo stesso
rappresentazione, non importa se la stringa che la contiene (o il testo del programma) è codificata in UTF-8
o no. Per garantire ciò, Perl adatta UTF-EBCDIC alla particolare code page in modo che tutto
i caratteri che si aspetta siano invarianti UTF-8 sono in realtà invarianti UTF-8. Ciò significa che
il testo generato su un computer che esegue una versione di UTF-EBCDIC di Perl deve essere tradotto
essere comprensibile a un computer che ne esegue un altro.

utilizzando Codificare
A partire da Perl 5.8 puoi usare il modulo standard Encode per tradurre da EBCDIC a
Punti di codice Latin-1. Encode conosce più set di caratteri EBCDIC di quanti ne possa Perl
attualmente essere compilato per l'esecuzione.

usa Encode 'from_to';

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

# $a è in punti di codice EBCDIC
from_to($a, $ebcdic{ord '^'}, 'latin1');
# $a è il codice ISO 8859-1 punti

e dai punti di codice Latin-1 a punti di codice EBCDIC

usa Encode 'from_to';

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

# $a è il codice ISO 8859-1 punti
from_to($a, 'latin1', $ebcdic{ord '^'});
# $a è in punti di codice EBCDIC

Per eseguire l'I/O si consiglia di utilizzare le funzionalità di traduzione automatica di PerlIO, vedere
perluniintro.

Dalla versione 5.8 Perl usa la libreria PerlIO I/O. Ciò consente di utilizzare diversi
codifiche per canale IO. Ad esempio puoi usare

usa Codifica;
open($f, ">:encoding(ascii)", "test.ascii");
print $f "Ciao mondo!\n";
open($f, ">:encoding(cp37)", "test.ebcdic");
print $f "Ciao mondo!\n";
open($f, ">:encoding(latin1)", "test.latin1");
print $f "Ciao mondo!\n";
open($f, ">:encoding(utf8)", "test.utf8");
print $f "Ciao mondo!\n";

per ottenere quattro file contenenti "Hello World!\n" in ASCII, CP 0037 EBCDIC, ISO 8859-1
(Latin-1) (in questo esempio identico ad ASCII poiché sono stati stampati solo caratteri ASCII),
e UTF-EBCDIC (in questo esempio identico al normale EBCDIC poiché solo i caratteri che
non differiscono tra EBCDIC e UTF-EBCDIC sono stati stampati). Consulta la documentazione di
Encode::PerlIO per i dettagli.

Poiché il livello PerlIO utilizza internamente l'IO grezzo (byte), tutto ciò ignora totalmente cose come
il tipo di filesystem (ASCII o EBCDIC).

SINGLE BYTE TABELLE

Le tabelle seguenti elencano gli insiemi ordinati ASCII e Latin 1 inclusi i sottoinsiemi: C0
controlli (0..31), grafica ASCII (32..7e), elimina (7f), controlli C1 (80..9f) e Latin-1
(alias ISO 8859-1) (a0..ff). Nella tabella i nomi delle estensioni Latin 1 ad ASCII hanno
stato etichettato con nomi di personaggi approssimativamente corrispondenti a Il Unicode standard, Versione
6.1 anche se con sostituzioni come "s/LATIN//" e "s/VULGAR//" in tutti i casi;
"s/LETTERA MAIUSCOLA//" in alcuni casi; e "s/LETTERA PICCOLA ([AZ])/\l$1/" in qualche altro
casi. I controlli sono elencati utilizzando le loro abbreviazioni Unicode 6.2. Le differenze
tra i set 0037 e 1047 sono contrassegnati con "**". Le differenze tra il 1047
e i set POSIX-BC sono contrassegnati con "##". Tutti i numeri "ord()" elencati sono decimali. Se tu
preferirei vedere questa tabella che elenca i valori ottali, quindi eseguire la tabella (cioè il pod
testo sorgente di questo documento, poiché questa ricetta potrebbe non funzionare con un pod2_other_format
traduzione) attraverso:

ricetta 0

perl -ne 'if(/(.{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

Se vuoi mantenere i punti di codice UTF-x, in forma di script potresti voler scrivere:

ricetta 1

aperto(FH,"
mentre ( ) {
if (/(.{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);
}
}
}

Se preferisci vedere questa tabella che elenca i valori esadecimali, esegui la tabella attraverso:

ricetta 2

perl -ne 'if(/(.{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

Oppure, per mantenere i punti del codice UTF-x in esadecimale:

ricetta 3

aperto(FH,"
mentre ( ) {
if (/(.{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
car 0819 0037 1047 BC 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
" 34 127 127 127 34 127
N. 35 123 123 123 35 123
$ 36 91 91 91 36 91
% 37 108 108 108 37 108
& 38 80 80 80 38 80
'39 125 125 125 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 107 107 44 107
-45 96 96 96 45 96
. 46
/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 122
; 59
< 60 76 76 76 60 76
= 61
> 62 110 110 110 62 110
? 63 111 111 111 63 111
@ 64 124 124 124 64 124
UN 65 193 193 193 65 193
B66 194 194 194 66 194
C 67 195 195 195 67 195
D68 196 196 196 68 196
E 69 197 197 197 69 197
F70 198 198 198 70 198
G71 199 199 199 71 199
H72
Io 73 201 201 201 73 201
J74 209 209 209 74 209
K75 210 210 210 75 210
L76 211 211 211 76 211
M77 212 212 212 77 212
N. 78 213 213 213 78 213
O79 214 214 214 79 214
P80 215 215 215 80 215
D 81 216 216 216 81 216
R 82 217 217 217 82 217
S83 226 226 226 83 226
T84 227 227 227 84 227
U85 228 228 228 85 228
V86 229 229 229 86 229
L 87 230 230 230 87 230
X88 231 231 231 88 231
Sì 89 232 232 232 89 232
Z90 233 233 233 90 233
[ 91 186 173 187 91 173 ** ##
\92 224 224 188 92 224 ##
] 93 187 189 189 93 189 **
^ 94 176 95 106 94 95 ** ##
_95
`96 121 121 74 96 121 ##
un 97 129 129 129 97 129
b98 130 130 130 98 130
c99
d100
e101 133 133 133 101 133
f 102 134 134 134 102 134
103 135 135 135 103 135
ore 104 136 136 136 104 136
io 105 137 137 137 105 137
106 145 145 145 106 145
k 107 146 146 146 107 146
108 147 147 147 108 147
milioni 109 148 148 148 109 148
110 149 149 149 110 149
o 111 150 150 150 111 150
pagina 112 151 151 151 112 151
113 152 152 152 113 152
114 153 153 153 114 153
s 115 162 162 162 115 162
116 163 163 163 116 163
117 164 164 164 117 164
v118 165 165 165 118 165
w119 166 166 166 119 166
x120 167 167 167 120 167
e 121 168 168 168 121 168
122 169 169 169 122 169
{ 123 192 192 251 123 192 ##
| 124
} 125 208 208 253 125 208 ##
~ 126 161 161 255 126 161 ##
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 95 194.159 255 ##
160 65 65 65 194.160 128.65
161 170 170 170 194.161 128.66
162 74 74 176 194.162 128.67 ##
163 177 177 177 194.163 128.68
164 159 159 159 194.164 128.69
165 178 178 178 194.165 128.70
166 106 106 208 194.166 128.71 ##
167 181 181 181 194.167 128.72
168 189 187 121 194.168 128.73 ** ##
169 180 180 180 194.169 128.74
170 154 154 154 194.170 128.81
171 138 138 138 194.171 128.82
172 95 176 186 194.172 128.83 ** ##
173 202 202 202 194.173 128.84
174 175 175 175 194.174 128.85
175 188 188 161 194.175 128.86 ##
176 144 144 144 194.176 128.87
177 143 143 143 194.177 128.88
178 234 234 234 194.178 128.89
179 250 250 250 194.179 128.98
180 190 190 190 194.180 128.99
181 160 160 160 194.181 128.100
182 182 182 182 194.182 128.101
183 179 179 179 194.183 128.102
184 157 157 157 194.184 128.103
185 218 218 218 194.185 128.104
186 155 155 155 194.186 128.105
187 139 139 139 194.187 128.106
188 183 183 183 194.188 128.112
189 184 184 184 194.189 128.113
190 185 185 185 194.190 128.114
191 171 171 171 194.191 128.115
192 100 100 100 195.128 138.65
193 101 101 101 195.129 138.66
194 98 98 98 195.130 138.67
195 102 102 102 195.131 138.68
196 99 99 99 195.132 138.69
197 103 103 103 195.133 138.70
198 158 158 158 195.134 138.71
199 104 104 104 195.135 138.72
200 116 116 116 195.136 138.73
201 113 113 113 195.137 138.74
202 114 114 114 195.138 138.81
203 115 115 115 195.139 138.82
204 120 120 120 195.140 138.83
205 117 117 117 195.141 138.84
206 118 118 118 195.142 138.85
207 119 119 119 195.143 138.86
208 172 172 172 195.144 138.87
209 105 105 105 195.145 138.88
210 237 237 237 195.146 138.89
211 238 238 238 195.147 138.98
212 235 235 235 195.148 138.99
213 239 239 239 195.149 138.100
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 138.104 ##
218 254 254 254 195.154 138.105
219 251 251 221 195.155 138.106 ##
220 252 252 252 195.156 138.112
221 173 186 173 195.157 138.113 ** ##
222 174 174 174 195.158 138.114
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 156 156 195.166 139.71
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
241 73 73 73 195.177 139.88
242 205 205 205 195.178 139.89
243 206 206 206 195.179 139.98
244 203 203 203 195.180 139.99
245 207 207 207 195.181 139.100
246 204 204 204 195.182 139.101
247 225 225 225 195.183 139.102
248 112 112 112 195.184 139.103
249 221 221 192 195.185 139.104 ##
250 222 222 222 195.186 139.105
251 219 219 219 195.187 139.106
252 220 220 220 195.188 139.112
253 141 141 141 195.189 139.113
254 142 142 142 195.190 139.114
255 223 223 223 195.191 139.115

Se preferisci vedere la tabella sopra nell'ordine CCSID 0037 anziché ASCII + Latin-1
ordina quindi esegui la tabella attraverso:

ricetta 4

perla \
-ne 'se(/.{29}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}/)'\
-e '{push(@l,$_)}' \
-e 'END{stampa mappa{$_->[0]}' \
-e ' ordina{$a->[1] <=> $b->[1]}' \
-e ' map{[$_,substr($_,34,3)]}@l;}' perlebcdic.pod

Se preferisci vederlo nell'ordine CCSID 1047, cambia il numero 34 nell'ultima riga
a 39, così:

ricetta 5

perla \
-ne 'se(/.{29}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}/)'\
-e '{push(@l,$_)}' \
-e 'END{stampa mappa{$_->[0]}' \
-e ' ordina{$a->[1] <=> $b->[1]}' \
-e ' map{[$_,substr($_,39,3)]}@l;}' perlebcdic.pod

Se preferisci vederlo nell'ordine POSIX-BC, cambia il numero 34 nell'ultima riga in
44, così:

ricetta 6

perla \
-ne 'se(/.{29}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}\s{2,4}\d{1,3}/)'\
-e '{push(@l,$_)}' \
-e 'END{stampa mappa{$_->[0]}' \
-e ' ordina{$a->[1] <=> $b->[1]}' \
-e ' map{[$_,substr($_,44,3)]}@l;}' perlebcdic.pod

Table in esadecimale, ordinati in 1047 minimo
Da quando questo documento è stato scritto per la prima volta, la convenzione è diventata sempre più da usare
notazione esadecimale per i punti di codice. Fare questo con le ricette e anche ordinare è un
processo in più fasi, quindi ecco, per comodità, la tabella dall'alto, riordinata per essere in
Code Page 1047 ordine e usando la notazione esadecimale.

ISO
8859-1 POS-CCSID
CCSID CCSID CCSID IX-1047
car 0819 0037 1047 BC 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
1CH 1CH 1CH 1CH 1CH 1CH
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
8CH 2CH 2CH 2CH 2.8 2CH
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
1LA 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
< 3CH 4CH 4CH 4CH 3CH
(28 4D 4D 4D 28 4D
+2B4E4E4E2B4E
| 7CH 4F 4F 4F 7CH 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
CE 58 58 58 C3.AC 8B.53
DF 59 59 59 C3.9F 8A.73
! 21 5A 5A 5A 21 5A
$ 24 5 miliardi 5 miliardi 5 miliardi 24 5 miliardi
*2A 5CH 5CH 5CH 2A 5CH
) 29 5D 5D 5D 29 5D
; 3B 5E 5E 5E 3B 5E
^ 5E SI0 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 6CH 6CH 6CH 25 6CH
_ 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
N. 23 7B 7B 7B 23 7B
@ 40 7°C 7°C 7°C 40°7°C
' 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
un 61 81 81 81 61 81
b62 82 82 82 62 82
c63
d64
e65 85 85 85 65 85
f 66 86 86 86 66 86
67 87 87 87 67 87
ore 68 88 88 88 68 88
io 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
j 6A 91 91 91 6A 91
k6B92B92
l6C 93 93 93 6C 93
m6D 94 94 94 6D 94
n6E 95 95 95 6E 95
o 6F 96 96 96 6F 96
pagina 70 97 97 97 70 97
71 98 98 98 71 98
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
LA4 9FA 9FA 9FA DO2.LA4 80.45
B5 A0 A0 A0 C2.B5 80.64
~ 7E LA1 LA1 FF 7E LA1 ##
s 73 LA2 LA2 LA2 73 LA2
t74 A3 A3 A3 74 A3
u75 A4 A4 A4 75 A4
v76 A5 A5 A5 76 A5
w 77 LA6 LA6 LA6 77 LA6
x 78 LA7 LA7 LA7 78 LA7
e 79 LA8 LA8 LA8 79 LA8
z7A 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
CA 5F B0 BA C2.CA 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 SI 79 DO2.A8 80.49 ** ##
AF BC BC A1 C2.AF 80.56 ##
] 5D BB BD BD 5D BD **
B4 ESSERE ESSERE C2.B4 80.63
D7 BF BF BF C3.97 8A.66
{ 7B DO 0 DO FB 0B DO ##
LA 41 C1 C1 C1 41 C1
SI 42 C2 C2 C2 42 C2
DO 43 DO3 DO3 DO3 43 DO3
RE 44 DO4 DO4 DO4 44 DO4
MI 45 DO5 DO5 DO5 45 DO5
FA 46 DO6 DO6 DO6 46 DO6
SOL 47 DO7 DO7 DO7 47 DO7
H48 C8 C8 C8 48 C8
I 49 DO9 DO9 DO9 49 DO9
ANNUNCIO 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 RE0 D0 FD 7D RE0 ##
J4A D1 D1 D1A D4
RE 4B RE2 RE2 RE2 4B RE2
L 4C RE3 RE3 RE3 4DO RE3
M4D D4 D4 D4 4D D4
N4E D5 D5 D5 4E D5
O 4F D6 D6 D6 4F D6
P50 D7 D7 D7 50 D7
D 51 D8 D8 D8 51 D8
R52 D9 D9 D9 52 D9
B9 DA DA DA C2.B9 80.68
FB DB DB DB C3.BB 8B.6A
FC CC CC CC 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 BC 5C E0 ##
FA7 MI1 MI1 MI1 DO3.B7 8B.66
SI 53 MI2 MI2 MI2 53 MI2
V 54 E3 E3 E3 54 E3
U55 E4 E4 E4 55 E4
V56 E5 E5 E5 56 E5
B57 Mi6 Mi6 E6 57 Mi6
X 58 MI7 MI7 MI7 58 MI7
Sì 59 E8 E8 E8 59 E8
Z5A E9 E9 E9 5A E9
B2 EA EA EA C2.B2 80.59
D4 EB EB EB C3.94 8A.63
D6 CE CE CE 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 ##

IDENTIFICARE CARATTERE CODICE SETS

È possibile determinare con quale set di caratteri si sta operando. Ma prima tu
devi essere davvero davvero sicuro di aver bisogno di farlo. Il tuo codice sarà più semplice e probabilmente
altrettanto portatile se non devi testare il set di caratteri e fare cose diverse,
dipendente. In realtà ci sono solo pochissime circostanze in cui non è facile scrivere
codice lineare portabile a tutti i set di caratteri. Vedere "Unicode ed EBCDIC" in
perluniintro per come specificare i caratteri in modo portabile.

Ma ci sono alcuni casi in cui potresti voler sapere quale set di caratteri stai utilizzando
sotto. Un possibile esempio è l'ordinamento nei cicli interni in cui le prestazioni sono
critica.

Per determinare se stai eseguendo in ASCII o EBCDIC, puoi utilizzare il valore restituito di
"ord()" o "chr()" per testare uno o più valori dei caratteri. Per esempio:

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

C'è ancora meno bisogno di distinguere tra le code page EBCDIC, ma per farlo prova a cercare
ad uno o più dei caratteri che differiscono tra loro.

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

Tuttavia, non sarebbe saggio scrivere test come:

$is_ascii = "\r" nuovo chr(13); # SBAGLIATO
$is_ascii = "\n" nuovo chr(10); # MAL CONSIGLIATO

Ovviamente il primo di questi non riuscirà a distinguere la maggior parte delle piattaforme ASCII da a
CCSID 0037, una piattaforma 1047 o POSIX-BC EBCDIC poiché ""\r" eq chr(13)" sotto tutti
quei set di caratteri codificati. Ma nota anche che poiché "\n" è "chr(13)" e "\r" è
"chr(10)" sul vecchio Macintosh (che è una piattaforma ASCII) il secondo test $is_ascii lo farà
portare guai lì.

Per determinare se perl è stato compilato o meno in una codepage EBCDIC puoi usare il
Modulo di configurazione in questo modo:

usa Configurazione;
$is_ebcdic = $Config{'ebcdic'} eq 'definire';

CONVERSIONI

"utf8::unicode_to_native()" e "utf8::native_to_unicode()"
Queste funzioni prendono un punto di codice numerico di input in una codifica e restituiscono ciò che è
il valore equivalente è nell'altro.

Vedi utf8.

tr///
Per convertire una stringa di caratteri da un set di caratteri a un altro un semplice elenco
di numeri, come nelle colonne di destra nella tabella sopra, insieme a "tr///" di Perl
l'operatore è tutto ciò che serve. I dati nella tabella sono in ordine ASCII/Latin1, quindi
le colonne EBCDIC forniscono operazioni da ASCII/Latin1 a EBCDIC di facile utilizzo che sono anche
facilmente invertita.

Ad esempio, per convertire ASCII/Latin1 in code page 037 prendi l'output del secondo
colonna numeri dall'output della ricetta 2 (modificata per aggiungere caratteri "\") e usarla in
"tr///" in questo modo:

$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 $stringa_ebcdic = $stringa_ascii;
eval '$stringa_ebcdic =~ tr/\000-\377/' . $cp_037. '/';

Per convertire da EBCDIC 037 ad ASCII basta invertire l'ordine degli argomenti tr/// in questo modo:

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

Allo stesso modo si potrebbe prendere l'output della terza colonna di numeri dalla ricetta 2 per ottenere a
$cp_1047 tabella. La quarta colonna di numeri dell'output della ricetta 2 potrebbe fornire a
$cp_posix_bc tabella adatta anche per la transcodifica.

Se volessi vedere le tabelle inverse, dovresti prima ordinare in base al desiderato
colonna numeri come nelle ricette 4, 5 o 6, quindi prendi l'output della prima colonna numeri.

iconv
L'operatività dell'XPG spesso implica la presenza di un iconv utility disponibile dalla shell o
dalla biblioteca C. Consultare la documentazione del sistema per informazioni su iconv.

Su OS/390 oz/OS vedere il iconv(1) pagina man. Un modo per invocare l'utilità della shell "iconv"
dall'interno di perl sarebbe:

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

o la mappa inversa:

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

Per altre opzioni di conversione basate su Perl, vedere i moduli "Convert::*" su CPAN.

C RTL
Le librerie runtime OS/390 ez/OS C forniscono le funzioni "_atoe()" e "_etoa()".

OPERATORE DIFFERENZE

L'operatore di intervallo ".." tratta con attenzione determinati intervalli di caratteri sulle piattaforme EBCDIC.
Ad esempio, il seguente array avrà ventisei elementi su una piattaforma EBCDIC
o una piattaforma ASCII:

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

Gli operatori bit a bit come & ^ | può restituire risultati diversi quando si opera su stringa
o dati di carattere in un programma Perl in esecuzione su una piattaforma EBCDIC rispetto a quando eseguito su un
piattaforma ASCII. Ecco un esempio adattato da quello in perlop:

# Esempi basati su EBCDIC
print "jp \n" ^ " ah"; # stampa "JAPH\n"
stampa "JA" | "p\n"; # stampa "japh\n"
print "JAPH\nPosta indesiderata" & "\277\277\277\277\277"; # stampa "japh\n";
print 'p N$' ^ " E

Una proprietà interessante dei 32 caratteri di controllo C0 nella tabella ASCII è che essi
possono essere costruiti "letteralmente" come caratteri di controllo in Perl, ad esempio "(chr(0)" eq "\c@")>
"(chr(1)" eq "\cA")>, e così via. Perl sulle piattaforme EBCDIC è stato portato per prendere "\c@"
a chr(0) e "\cA" per chr(1), ecc., ma i caratteri che risultano dipendono da
quale pagina codici stai utilizzando. La tabella seguente utilizza gli acronimi standard per
controlli. I set POSIX-BC e 1047 sono identici in tutta questa gamma e differiscono da
lo 0037 fissato a un solo punto (21 decimale). Nota che il carattere del terminatore di riga potrebbe
essere generato da "\cJ" su piattaforme ASCII ma da "\cU" su piattaforme 1047 o POSIX-BC e
non può essere generato come "\c.lettera." carattere di controllo sulle piattaforme 0037. Nota anche che
"\c\" non può essere l'elemento finale in una stringa o in una regex, poiché assorbirà il terminatore.
Ma "\c\X" è un "FILE SEPARATOR" concatenato con X per tutti X. Il valore anomalo "\c?" Su
ASCII, che produce un controllo "DEL" non C0, produce il controllo anomalo "APC" su EBCDIC,
quello che non è nel blocco dei controlli contigui. Nota che una sottigliezza di questo è
quel "\c?" sulle piattaforme ASCII è un carattere ASCII, mentre non è equivalente a nessuno
Carattere ASCII nelle piattaforme 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?" mappa all'ordinale 127 ("DEL") su piattaforme ASCII, ma poiché l'ordinale 127 è a
non un carattere di controllo su macchine EBCDIC, "\c?" invece mappa su di essi su "APC", che è
255 in 0037 e 1047 e 95 in POSIX-BC.

FUNZIONE DIFFERENZE

A "chr()" "chr()" deve essere assegnato un argomento del numero di codice EBCDIC per ottenere il carattere desiderato
restituire valore su una piattaforma EBCDIC. Per esempio:

$MAIUSCOLA_A = chr(193);

Il punto di codice più grande che è rappresentabile in UTF-EBCDIC è U+7FFF_FFFF. Se tu
fai "chr()" su un valore più grande, un errore di runtime (simile alla divisione per 0) lo farà
accadere.

"ord()" "ord()" restituirà i valori del numero di codice EBCDIC su una piattaforma EBCDIC. Per esempio:

$il_numero_193 = ord("A");

"pacchetto()"
I modelli "c" e "C" per "pack()" dipendono dalla codifica del set di caratteri.
Esempi di utilizzo su EBCDIC includono:

$pippo = pack("CCCC",193,194,195,196);
# $pippo eq "ABCD"
$pippo = pack("C4",193,194,195,196);
# stessa cosa

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

Il modello "U" è stato portato per significare "Unicode" su tutte le piattaforme in modo che

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

è vero su tutte le piattaforme. Se vuoi punti di codice nativi per i 256 bassi, usa il
modello "W". Ciò significa che le equivalenze

pack("W", ord($carattere)) eq $carattere
unpack("W", $carattere) == ord $carattere

terrà.

Il punto di codice più grande che è rappresentabile in UTF-EBCDIC è U+7FFF_FFFF. Se tu
prova a racchiudere un valore più grande in un carattere, un errore di runtime (simile alla divisione
da 0) accadrà.

"Stampa()"
Bisogna stare attenti con scalari e stringhe che vengono passati alla stampa che contengono
Codifiche ASCII. Un luogo comune in cui ciò si verifica è nell'output del MIME
digitare l'intestazione per la scrittura di script CGI. Ad esempio, molte guide alla programmazione Perl
consiglia qualcosa di simile a:

print "Tipo di contenuto:\ttext/html\015\012\015\012";
# questo potrebbe essere sbagliato su EBCDIC

Puoi invece scrivere

print "Tipo di contenuto:\ttext/html\r\n\r\n"; # OK per DGW e altri

e farlo funzionare in modo portatile.

Questo perché la traduzione da EBCDIC ad ASCII viene eseguita dal server web in
questo caso. Consulta la documentazione del tuo server web per ulteriori dettagli.

"printf()"
I formati che possono convertire i caratteri in numeri e viceversa saranno
diversi dalle loro controparti ASCII quando eseguiti su una piattaforma EBCDIC.
Gli esempi includono:

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

"ordinare()"
I risultati dell'ordinamento EBCDIC possono differire dai risultati dell'ordinamento ASCII soprattutto per i casi misti
stringhe. Questo è discusso più dettagliatamente di seguito.

"sprintf()"
Vedi la discussione su "printf()" sopra. Un esempio dell'uso di sprintf sarebbe
essere:

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

"decomprimi()"
Vedi la discussione su "pack()" sopra.

Nota che è possibile scrivere codice portabile per questi specificando le cose in Unicode
numeri e utilizzando una funzione di conversione:

printf("%c",utf8::unicode_to_nativo(65)); # stampe A su tutto
# piattaforme
print utf8::native_to_unicode(ord("A")); # Allo stesso modo, stampa 65

Vedere "Unicode ed EBCDIC" in perluniintro e "CONVERSIONI" per altre opzioni.

REGOLARE ESPRESSIONE DIFFERENZE

Puoi scrivere le tue espressioni regolari proprio come farebbe qualcuno su una piattaforma ASCII.
Ma tieni presente che l'uso della notazione ottale o esadecimale per specificare un particolare punto di codice sarà
darti il ​​carattere che la code page EBCDIC mappa in modo nativo ad esso. (Anche questo è vero
di tutte le stringhe tra virgolette.) Se vuoi scrivere in modo portabile, usa semplicemente "\N{U+...}"
notazione ovunque dove avresti usato "\x{...}", e non usare la notazione ottale a
tutti.

A partire da Perl v5.22, questo si applica agli intervalli nelle classi di caratteri tra parentesi. Se tu
diciamo, ad esempio, "qr/[\N{U+20}-\N{U+7F}]/", significa i caratteri "\N{U+20}",
"\N{U+21}", ..., "\N{U+7F}". Questo intervallo è costituito da tutti i caratteri stampabili che l'ASCII
contiene il set di caratteri.

Prima della v5.22, non era possibile specificare alcun intervallo in modo portabile, eccetto (a partire da Perl v5.5.3)
tutti i sottoinsiemi degli intervalli "[AZ]" e "[az]" sono appositamente codificati per non rilevare il gap
caratteri. Ad esempio, caratteri come "o" ("o CON CIRCUMFLEX") che si trovano tra
"I" e "J" non verrebbero trovati nell'intervallo di espressioni regolari "/[HK]/". Ma se neanche
dei punti finali dell'intervallo è esplicitamente numerico (e nessuno dei due è specificato da "\N{U+...}"),
i caratteri gap sono abbinati:

/[\x89-\x91]/

corrisponderà a "\x8e", anche se "\x89" è "i" e "\x91 " è "j" e "\x8e" è uno spazio vuoto
carattere, dal punto di vista alfabetico.

Un altro costrutto di cui diffidare è l'uso inappropriato di esadecimale (a meno che tu non usi
"\N{U+...}") o costanti ottali nelle espressioni regolari. Considera il seguente insieme di
sottotitoli:

sub è_c0 {
mio $char = substr(shift,0,1);
$carattere =~ /[\000-\037]/;
}

sub is_print_ascii {
mio $char = substr(shift,0,1);
$carattere =~ /[\040-\176]/;
}

sub è_elimina {
mio $char = substr(shift,0,1);
$car eq "\177";
}

sub è_c1 {
mio $char = substr(shift,0,1);
$carattere =~ /[\200-\237]/;
}

sub is_latin_1 { # Ma non ASCII; non C1
mio $char = substr(shift,0,1);
$carattere =~ /[\240-\377]/;
}

Questi sono validi solo su piattaforme ASCII. A partire da Perl v5.22, semplicemente cambiando il
costanti ottali a valori equivalenti "\N{U+...}" li rendono portatili:

sub è_c0 {
mio $char = substr(shift,0,1);
$car =~ /[\N{U+00}-\N{U+1F}]/;
}

sub is_print_ascii {
mio $char = substr(shift,0,1);
$car =~ /[\N{U+20}-\N{U+7E}]/;
}

sub è_elimina {
mio $char = substr(shift,0,1);
$car eq "\N{U+7F}";
}

sub è_c1 {
mio $char = substr(shift,0,1);
$car =~ /[\N{U+80}-\N{U+9F}]/;
}

sub is_latin_1 { # Ma non ASCII; non C1
mio $char = substr(shift,0,1);
$car =~ /[\N{U+A0}-\N{U+FF}]/;
}

Ed ecco alcuni modi portatili alternativi per scriverli:

sub Is_c0 {
mio $char = substr(shift,0,1);
return $char =~ /[[:cntrl:]]/a && ! Is_delete($carattere);

# In alternativa:
# ritorna $carattere =~ /[[:cntrl:]]/
# && $char =~ /[[:ascii:]]/
# && ! Is_delete($carattere);
}

sub Is_print_ascii {
mio $char = substr(shift,0,1);

restituisce $car =~ /[[:stampa:]]/a;

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

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

sub Is_delete {
mio $char = substr(shift,0,1);
ritorna utf8::native_to_unicode(ord $char) == 0x7F;
}

sub Is_c1 {
usa la funzione 'unicode_strings';
mio $char = substr(shift,0,1);
return $char =~ /[[:cntrl:]]/ && $char !~ /[[:ascii:]]/;
}

sub Is_latin_1 { # Ma non ASCII; non C1
usa la funzione 'unicode_strings';
mio $char = substr(shift,0,1);
ordine di ritorno ($carattere) < 256
&& $char !~ /[[:ascii:]]/
&& $char !~ /[[:cntrl:]]/;
}

Un altro modo per scrivere "Is_latin_1()" sarebbe usare i caratteri nell'intervallo
esplicitamente:

sub Is_latino_1 {
mio $char = substr(shift,0,1);
$car =~ /[ XXXXXXXXXXXXXXXXXXXXXXXXXXXAAAA~AeAaAECEEEEeIIIIe]
[‐N~OOOO~OeXOUUUUeYPssaaaa~aeaaaeceeeeeiiiie`n~oooo~oeXouuuueypye]/x;
}

Sebbene tale modulo possa incorrere in problemi nel transito di rete (a causa della presenza di 8 bit
caratteri) o su set di caratteri non latini ISO. Ma consente la riscrittura di "Is_c1"
quindi funziona su Perls che non hanno 'unicode_strings' (prima della v5.14):

sub Is_latin_1 { # Ma non ASCII; non C1
mio $char = substr(shift,0,1);
ordine di ritorno ($carattere) < 256
&& $char !~ /[[:ascii:]]/
&&! Is_latin1($carattere);
}

PRESE

La maggior parte della programmazione socket presuppone la codifica dei caratteri ASCII nell'ordine dei byte di rete.
Le eccezioni possono includere la scrittura di script CGI sotto un server Web host in cui il server può
prendersi cura della traduzione per te. La maggior parte dei server web host converte i dati EBCDIC in ISO-8859-1
o Unicode in uscita.

ORDINAMENTO

Una grande differenza tra i set di caratteri basati su ASCII e quelli EBCDIC sono i relativi
posizioni dei caratteri quando sono ordinati in ordine nativo. Di maggior preoccupazione sono i superiori
e minuscole, le cifre e il carattere di sottolineatura ("_"). Sulle piattaforme ASCII il
l'ordinamento nativo prevede che le cifre vengano prima delle lettere maiuscole che precedono il
carattere di sottolineatura che precede le lettere minuscole. Su EBCDIC, arriva il carattere di sottolineatura
prima, poi le lettere minuscole, poi quelle maiuscole e per ultime le cifre. Se
ordinato su una piattaforma basata su ASCII, viene fornita l'abbreviazione di due lettere per un medico
prima dell'abbreviazione di due lettere per unità; questo è:

@sorted = sort(qw(Dr. dr.)); # @sorted mantiene ('Dr.','dr.') su ASCII,
# ma ('dr.','Dr.') su EBCDIC

La proprietà delle lettere minuscole prima delle maiuscole in EBCDIC è anche portata al latino
1 pagine EBCDIC come 0037 e 1047. Un esempio potrebbe essere che "Ee" ("E CON DIERESI",
203) viene prima di "ee" ("e WITH DIAERESIS", 235) su una piattaforma ASCII, ma quest'ultimo (83)
precede il primo (115) su piattaforma EBCDIC. (I lettori più attenti noteranno che il
la versione maiuscola di "ss" "SMALL LETTER SHARP S" è semplicemente "SS" e che la maiuscola
le versioni di "ye" (piccola "y CON DIAERESIS") e "X" ("MICRO SIGN") non sono nel 0..255
range ma sono in Unicode, in un Perl abilitato per Unicode).

L'ordinamento causerà differenze tra i risultati ottenuti su piattaforme ASCII rispetto a
piattaforme EBCDIC. Quelli che seguono sono alcuni suggerimenti su come affrontarli
differenze.

ignorare ASCII vs. EBCDIC sorta differenze.
Questa è la strategia meno costosa dal punto di vista computazionale. Potrebbe richiedere una certa formazione dell'utente.

Usa il a sorta aiutante funzione
Questa è una strategia del tutto generale, ma è la più costosa dal punto di vista computazionale. Scegline uno
o l'altro set di caratteri e trasformarlo in quello per ogni confronto di ordinamento. Ecco un
esempio completo che si trasforma in ordinamento ASCII:

sub nativo_a_uni($) {
mia $stringa = shift;

# Risparmia tempo su una piattaforma ASCII
restituisce $stringa se ord 'A' == 65;

mio $output = "";
per il mio $i (0 .. lunghezza($stringa) - 1) {
$ output
.= chr(utf8::native_to_unicode(ord(substr($stringa, $i, 1)))));
}

# Preserva l'utf8ness dell'input sull'output, anche se non è necessario
# essere utf8
utf8::upgrade($output) se utf8::is_utf8($stringa);

restituisce $output;
}

sub ascii_order { # Ordina l'assistente
return native_to_uni($a) cmp native_to_uni($b);
}

ordina ascii_order @lista;

MONO CASSA poi sorta dati (Per non cifre, senza trattino basso)
Se non ti interessa dove si mettono le cifre e il carattere di sottolineatura, puoi fare qualcosa del genere
questo

sub case_insensitive_order { # Ordina l'assistente
restituisce lc($a) cmp lc($b)
}

ordina case_insensitive_order @lista;

Se le prestazioni sono un problema e non ti interessa se l'output è nello stesso caso del
input, utilizzare "tr///" per trasformare nel caso più utilizzato all'interno dei dati. Se i dati
sono principalmente MAIUSCOLE non latine1, quindi applicare "tr/[az]/[AZ]/", e quindi "sort()". Se
i dati sono principalmente minuscoli non Latin1, quindi applicare "tr/[AZ]/[az]/" prima dell'ordinamento.
Se i dati sono principalmente MAIUSCOLI e includono caratteri Latin-1, applica:

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

quindi "ordina()". Se puoi scegliere, è meglio scrivere le lettere minuscole per evitare il
problemi dei due caratteri Latin-1 la cui maiuscola è al di fuori di Latin-1: "ye" (piccolo "y
CON DIAERESI") e "X" ("SEGNO MICRO"). Se è necessario scrivere in maiuscolo, è possibile; con un
Perl abilitato per Unicode, eseguire:

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

Eseguire ordinamento on prima Digitare of piattaforma solo.
Questa strategia può utilizzare una connessione di rete. In quanto tale sarebbe computazionalmente
caro.

TRASFORMAZIONE FORMATI

Esistono vari modi per trasformare i dati con una mappatura di un set di caratteri intra
servire una varietà di scopi. L'ordinamento è stato discusso nella sezione precedente e in alcuni di
le altre tecniche di mappatura più popolari verranno discusse in seguito.

URL decodifica e codifica
Nota che alcuni URL contengono punti di codice ASCII esadecimali nel tentativo di superarli
problemi di limitazione del carattere o del protocollo. Ad esempio, il carattere tilde non è su tutti
tastiera quindi un URL del modulo:

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

può anche essere espresso come uno di:

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

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

dove 7E è il punto di codice ASCII esadecimale per "~". Ecco un esempio di decodifica tale
un URL in qualsiasi codepage EBCDIC:

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

Al contrario, ecco una soluzione parziale per il compito di codificare un tale URL in qualsiasi EBCDIC
codice pagina:

$ url = "http://www.pvhp.com/~pvhp/';
# La seguente espressione regolare non affronta il
# mappature per: ('.' => '%2E', '/' => '%2F', ':' => '%3A')
$url =~ s/([\t "#%&\(\),;<=>\?\@\[\\\]^`{|}~])/
sprintf("%%%02X",utf8::native_to_unicode(ord($1)))/xge;

dove una soluzione più completa dividerebbe l'URL in componenti e applicherebbe un s/// completo
sostituzione solo alle parti appropriate.

uu codifica e decodifica
Il modello "u" per "pack()" o "unpack()" renderà i dati EBCDIC in caratteri EBCDIC
equivalenti alle loro controparti ASCII. Ad esempio, quanto segue stamperà "Sì
infatti\n" su un computer ASCII o EBCDIC:

$tutti_byte_chrs = '';
for (0..255) { $tutti_byte_chrs .= chr($_); }
$uuencode_byte_chrs = pack('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``
ENDOFHEREDDOC
if ($uuencode_byte_chrs eq $uu) {
stampa "Sì";
}
$uudecode_byte_chrs = unpack('u', $uuencode_byte_chrs);
if ($uudecode_byte_chrs eq $tutti_byte_chrs) {
stampa "anzi\n";
}

Ecco un uudecoder molto spartano che funzionerà su EBCDIC:

#! / usr / local / bin / perl
$_ = <> fino a ($modalità,$file) = /^inizio\s*(\d*)\s*(\S*)/;
open(OUT, "> $file") if $file ne "";
mentre(<>) {
ultimo se /^end/;
next if /[az]/;
next a meno che int((((utf8::native_to_unicode(ord()) - 32 ) & 077)
+2) / 3)
== int(lunghezza() / 4);
print OUT unpack("u", $_);
}
chiudere(OUT);
chmod oct($modalità), $file;

Quotato stampabile codifica e decodifica
Sulle piattaforme con codifica ASCII è possibile rimuovere i caratteri al di fuori del set stampabile
utilizzando:

# Questo codificatore QP funziona solo su ASCII
$stringa_qp =~ s/([=\x00-\x1F\x80-\xFF])/
sprintf("=%02X",ord($1))/xge;

A partire da Perl v5.22, questo è banalmente modificabile per funzionare in modo portabile sia su ASCII che su
piattaforme EBCDIC.

# Questo codificatore QP funziona sia su ASCII che su EBCDIC
$qp_stringa =~ s/([=\N{U+00}-\N{U+1F}\N{U+80}-\N{U+FF}])/
sprintf("=%02X",ord($1))/xge;

Per i Perls precedenti, sembrerebbe un codificatore QP che funzioni su piattaforme ASCII ed EBCDIC
un po' come il seguente:

$cancella = utf8::unicode_to_native(ord("\x7F"));
$stringa_qp =~
s/([^[:stampa:]$cancella])/
sprintf("=%02X",utf8::native_to_unicode(ord($1)))/xage;

(sebbene nel codice di produzione le sostituzioni possano essere effettuate nel ramo EBCDIC con il
chiamata di funzione e separatamente nel ramo ASCII senza la spesa della mappa identità;
in Perl v5.22, la mappa dell'identità è ottimizzata, quindi non ci sono spese, ma il
l'alternativa sopra è più semplice ed è disponibile anche in v5.22).

Tali stringhe QP possono essere decodificate con:

# Questo decodificatore QP è limitato al solo ASCII
$stringa =~ s/=([[:xdigit:][[:xdigit:])/chr hex $1/ge;
$stringa =~ s/=[\n\r]+$//;

Considerando che un decoder QP che funziona su entrambe le piattaforme ASCII ed EBCDIC sembrerebbe in qualche modo
come il seguente:

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

cesareo cifrari
Risale la pratica di spostare un alfabeto di uno o più caratteri per la cifratura
migliaia di anni ed è stato esplicitamente descritto da Gaio Giulio Cesare nel suo gallico Guerre
testo. Un singolo spostamento dell'alfabeto viene talvolta definito rotazione e importo dello spostamento
è dato come numero $n dopo la stringa 'rot' o "rot$n". Rot0 e rot26 designerebbero
mappe di identità sulla versione inglese di 26 lettere dell'alfabeto latino. Rot13 ha il
proprietà interessanti che alternano invocazioni successive sono le mappe di identità (quindi rot13
è il proprio inverso non banale nel gruppo di 26 rotazioni alfabetiche). Quindi il
di seguito è riportato un codificatore e decodificatore rot13 che funzionerà su piattaforme ASCII ed EBCDIC:

#! / usr / local / bin / perl

mentre(<>){
tr/n-za-mN-ZA-M/a-zA-Z/;
Stampa;
}

In forma di una riga:

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

hashing minimo e checksum

Perl randomizza deliberatamente l'ordine degli hash per motivi di sicurezza sia su ASCII che su EBCDIC
piattaforme.

I checksum EBCDIC differiranno per lo stesso file tradotto in ASCII e viceversa.

I18N E L10N

L'internazionalizzazione (I18N) e la localizzazione (L10N) sono supportate almeno in linea di principio
anche su piattaforme EBCDIC. I dettagli dipendono dal sistema e vengono discussi nella sezione "OS
PROBLEMI" di seguito.

MULTI-OTTETTO CARATTERE SETS

Perl funziona con UTF-EBCDIC, una codifica multi-byte. In Perls precedenti alla v5.22, potrebbe
essere vari bug in questo senso.

Codepage EBCDIC legacy a più byte XXX.

OS PROBLEMI

Potrebbero esserci alcuni problemi dipendenti dal sistema che preoccupano i programmatori Perl EBCDIC.

OS / 400
PASE L'ambiente PASE è un ambiente di runtime per OS/400 che può eseguire eseguibili
costruito per PowerPC AIX in OS/400; vedi perlos400. PASE è basato su ASCII, non su EBCDIC-
basato come ILE.

Accesso IFS
XXX.

OS / 390, z/OS
Perl funziona sotto Unix Systems Services o USS.

"sigazione"
"SA_SIGINFO" può avere errori di segmentazione.

"chcp" cap è supportato come un'utilità di shell per visualizzare e modificare la propria tabella codici.
Vedi anche cap(1).

accesso al set di dati
Per l'accesso sequenziale al set di dati, provare:

mio @ds_records = `cat //DSNAME`;

o:

mio @ds_records = `cat //'HLQ.DSNAME'`;

Vedere anche il modulo OS390::Stdio su CPAN.

"iconv" iconv è supportato sia come utilità della shell che come routine C RTL. Vedi anche il
iconv(1) e iconv(3) pagine di manuale.

locales Le impostazioni locali sono supportate. Potrebbero esserci problemi quando una locale è un altro codice EBCDIC
pagina che ha alcuni dei caratteri delle varianti della tabella codici in altre posizioni.

Al momento non ci sono locali UTF-8 reali, anche se alcuni nomi di locali
contengono la stringa "UTF-8".

Vedere perllocale per informazioni sulle localizzazioni. I file L10N sono in /usr/nls/locale.
$Config{d_setlocale} è 'definito' su OS/390 o z/OS.

POSIX-BC?
XXX.

Usa perlebcdic online usando i servizi onworks.net