Extraction d'enregistrements à largeur fixe sans délimiteur à partir d'une seule ligne

J'ai besoin d'extraire des chaînes de texte à partir d'un seul fichier contenant une très longue ligne de texte sans délimiteurs. En utilisant l'exemple de ligne ci-dessous, voici les faits connus suivants:

??????? A1XXXXXXXXXX ??????? B1XXXX ??????? A1XXXXXXXXXX ??????? C1XXXXXXX

1.  It contains 38 fixed width record types 
2.  The record marker is a 7 alphanumeric character followed by, for example, ‘A1’.
3.  Each record type has varying widths, for example, A1 record type will have 10 characters following it, if B1 then 4, and if C1 then 7.
4.  The record types aren’t clumped together and can be in any order. As in the example, its A1,B1,A1,C1
5.  The example above has 4 records and each record type needs to go to separate files. In this case 38 of them.

??????? A1XXXXXXXXXX

??????? B1XXXX

??????? A1XXXXXXXXXX

??????? C1XXXXXXX

6.  The record identifier, e.g. ????????A1, can appear in the body of the record so cannot use grep. 
7.  With the last point in mind, I was proposing 3 solutions but not sure on how to script this and of course would greatly appreciate some help. 
a. Traverse through the file from the beginning and sequentially strip out the record to the appropriate output file. For example, strip out first record type A1 to A1file which I know is 10 characters long then re-interrogate the file which will then have B1 which I know is 4 chars long, strip this out to B1file etc.. <<< this seems painful >>
b. Traverse through the file and append some obscure character to each record marker within the same file. Much like above but not strip out. I understand it still will use the same logic but seems more elegant
c. I did think of simply using the proposed grep -oE solution but then re-interrogate the output files to see if any of the 38 record markers exist anywhere other than at the beginning. But this might not always work.

Que diriez-vous grep

grep -oE 'A1.{10}|B1.{4}|C1.{7}' input.txt

Cela imprime chaque enregistrement de chaque type d'enregistrement sur une ligne distincte. Pour rediriger la grepsortie 3 fichiers nommés A1, B1, C1respectivement,

grep -oE 'A1.{10}|B1.{4}|C1.{7}' input.txt| 
awk -v OFS= -v FS= '{f=$1$2; $1=$2=""; print>f}'

Voici une solution possible en utilisant FPAT de Gawk

BEGIN { 
    FPAT="A1.{10}|B1.{4}|C1.{7}" #define field contents
} 
{
    for(i=1;i<=NF;i++) 
        print $i >> substr($i,0,2) #print the field to file A1,B1,etc
}

En une ligne:

gawk 'BEGIN{FPAT="A1.{10}|B1.{4}|C1.{7}"} {for(i=1;i<=NF;i++)print $i >> substr($i,0,2)}' < datafile

En Perl:

#!/usr/bin/env perl

use strict;
use warnings;
use re qw(eval);

my %field_widths = (
    A1 => 10,
    B1 =>  4,
    C1 =>  7,
    #...(fill this up with the widths of your 38 record types)
);

# Make a regex of record types; sort with longest first as appropriate for
# ... regex alternation:
my $record_type_regex = join '|', sort { length($b) <=> length($a) } keys %field_widths; 

my %records;
my $marker_length=7; #Assuming the marker is 7 characters long
while(<>){
    chomp;
    while( # Parse each line of input
      m!
        (.{$marker_length})          # Match the record marker (save in $1)
        ($record_type_regex)         # Match any record type (save in $2)
        (
         (??{'.'x$field_widths{$2})} # Match a field of correct width
        )                            # Save in $3
       !xg){
        $records{$2}.="$1$2$3\n";
      }
}
for my $file (sort keys %records){
    open my $OUT,'>',$file or die "Failed to open $file for writing: $!\n";
    print $OUT $records{$file};
    close $OUT
}

Appelez-le comme:

[user@host]$ ./myscript.pl file_of_data

Code testé et fonctionne avec votre entrée donnée.

Mise à jour

Dans vos commentaires, vous avez demandé un "équivalent Unix" de ce qui précède. Je doute fortement qu'il existe une telle chose, car l'expression Perl utilisée pour analyser votre ligne est une expression très irrégulière et je doute que les expressions régulières vanille puissent analyser votre format de données donné: il est trop similaire à un type d'expression célèbre que l'expression régulière peut 't parse (correspond à n'importe quel nombre de a' suivi du même nombre de b').

Dans tous les cas, l'approche "Unix" la plus proche que je puisse trouver est la généralisation de la réponse de 1_CR . Vous devez noter que cette approche est spécifique à l'implémentation GNU grepet ne fonctionnera donc pas sur la plupart des Unices. L'approche Perl, au contraire, devrait fonctionner de la même manière sur n'importe quelle plate-forme sur laquelle Perl fonctionne. Voici mon grepapproche GNU suggérée :

cat <<EOF \
| while read -r record width;do
    grep -oE ".{7}$record.{$width}" input_file\ #replace 7 with marker length
     >> "$record"
done
A1 10
B1 4
# enter your 38 record types
EOF

Mise à jour

Sur la base des demandes de l'OP dans les commentaires, au lieu de passer le nom de fichier comme argument de ligne de commande, il peut être ouvert dans le script comme suit:

open my $IN,'<',$input_file_name or die "Failed to open $input_file: $!\n";
while(<$IN>){ #instead of while(<>)
...

Cela suppose que vous avez déclaré que la variable $input_file_namecontient, eh bien, le nom du fichier d'entrée.

Quant à l'ajout d'un horodatage au nom du fichier de sortie, vous pouvez utiliser la qx{}syntaxe: entre les accolades, vous pouvez mettre n'importe quelle commande Unix que vous souhaitez et elle sera exécutée et sa sortie standard relue à la place de l' qx{}opérateur:

open my $OUT,'>',"$file_".qx{date +%Y-%m-%d--%I:%M:%S%P}

L' qxopérateur n'est pas limité aux accolades, utilisez votre caractère préféré comme délimiteur, assurez-vous simplement qu'il n'est pas dans la commande que vous devez exécuter:

qx<...>
qx(...)    
qx!...!    
qx@...@

etc...

Dans certains codes Perl, vous pouvez voir des backticks ( ` `) utilisés à la place pour cette fonction, de la même manière que le shell. qxConsidérez simplement l' opérateur comme la généralisation des backticks à n'importe quel délimiteur.

Soit dit en passant, cela donnera un horodatage légèrement différent à chaque fichier (si la différence de leurs temps de création se trouve être un nombre fini de secondes). Si vous ne le souhaitez pas, vous pouvez le faire en deux étapes:

my $tstamp = qx{...};
open my $OUT,'>',"$file_$tstamp" or die...;