source: pmb4.2/trunk/fuentes/pmb/classes/iso2709.class.php @ 892

Last change on this file since 892 was 892, checked in by jrpelegrina, 4 years ago

Fix some files

  • Property svn:executable set to *
File size: 37.5 KB
RevLine 
[815]1<?php
2// ---------------------------------------------------
3//  iso2709_record : classe PHP pour la manipulation
4//  d'enregistrements au format ISO2709
5//      (c) François Lemarchand 2002
6//      public release 0.0.6
7//  Cette bibliothèque est distribuée sous la Licence 2 GNU GPL       
8//
9//  Cette bibliothèque est distribuée car potentiellement utile mais 
10//  SANS AUCUNE GARANTIE, ni explicite, ni implicite, y compris les   
11//  garanties de commercialisation ou d'adaptation dans un but       
12//  spécifique. Reportez vous à la Licence Publique Générale GNU pour
13//  plus de détails.                                                 
14//
15//  Tous les fichiers sont sous ce copyright sans exception.
16//  Voir le fichier GPL.txt
17//
18// ---------------------------------------------------
19
20// +-------------------------------------------------+
21// ATTENTION, cette classe a été sérieusement débogguée par rapport à l'original. Les corrections ont été réalisées par PMB Services.
22// © PMB Services / www.sigb.net pmb@sigb.net et contributeurs (voir www.sigb.net)
23// +-------------------------------------------------+
24// $Id: iso2709.class.php,v 1.43 2013-11-18 15:58:06 mbertin Exp $
25
26if (stristr($_SERVER['REQUEST_URI'], ".class.php")) die("no access");
27
28// on s'assure que la classe n'est pas définie afin
29// d'éviter les inclusions multiples
30
31if ( ! defined( 'ISO2709' ) ) {
32  define( 'ISO2709', 1 );
33
34define('AUTO_UPDATE', 1);
35define('USER_UPDATE', 0);
36
37define("IS3",chr(0x1d));                        //Caractère de fin d'enregistrement
38define("IS2",chr(0x1e));                        //Caractère de fin de champ
39define("IS1",chr(0x1f));                        //Caractère de début de sous champ
40define("NSBB",chr(0x88));                       //Caractère de début "non sorting bloc"
41define("NSBE",chr(0x89));                       //Caractère de fin "non sorting bloc"
42
43class iso2709_record {
44// ---------------------------------------------------
45//              déclaration des propriétés
46// ---------------------------------------------------
47        // enregistrement UNIMARC complet
48        var $full_record;
49
50        // parties de l'enregistrement UNIMARC
51        var $guide = '';
52        var $directory = '';
53        var $data = '';
54
55        // propriétés 'publiques'
56        var $errors;
57        var $warnings;
58        var $auto_update; // mode de mise à jour;
59
60        // variables 'internes' de la classe
61        var $inner_guide;
62        var $inner_directory;
63        var $inner_data;
64
65        // caractères spéciaux
66        var $record_end;
67        var $rgx_record_end;
68        var $field_end;
69        var $rgx_field_end;
70        var $subfield_begin;
71        var $rgx_subfield_begin;
72        var $NSB_begin;
73        var $rgx_NSB_begin;
74        var $NSB_end;
75        var $rgx_NSB_end;
76        var $type_marc; //Utilisé pour reconnaitre l'USMARC de UNIMARC (= unimarc ou usmarc)
77        var $is_utf8 = FALSE; //definit si notice encodee en utf-8
78       
79// ---------------------------------------------------
80//              déclaration des méthodes
81// ---------------------------------------------------
82
83
84// ---------------------------------------------------
85// constructeur : récupération de l'enregistrement
86// ---------------------------------------------------
87function iso2709_record($string='', $update=AUTO_UPDATE,$type_marc="unimarc") {
88        // initialisation des caractères spéciaux
89        $this->record_end = chr(0x1d);          // fin de notice (IS3 de l'ISO 6630)
90        $this->rgx_record_end = "\x1D";
91        $this->field_end = chr(0x1e);   // fin de champ (IS2 de l'ISO 6630)
92        $this->rgx_field_end ="\x1E";
93        $this->subfield_begin = chr(0x1f);      // début de sous-champ (IS1 de l'ISO 6630)
94        $this->rgx_subfield_begin = "\x1F";
95        $this->NSB_begin = chr(0x88);           // début de NSB
96        $this->rgx_NSB_begin = "\x88";
97        $this->NSB_end = chr(0x89);                     // fin de NSB (NSE)
98        $this->rgx_NSB_end = "\x89";
99
100        // initialisation du mode d'update
101        $this->auto_update = $update;
102       
103        // initialisation du type marc de la notice (unimarc ou usmarc)
104        $this->type_marc = $type_marc;
105        # TRUE : l'update est géré par la classe
106        # FALSE : c'est au script appelant de gérer l'update;
107
108        // initialisation du tableau des erreurs
109        $this->errors = array();
110       
111        // initialisation du tableau des warnings
112        $this->warnings = array();
113       
114        // initialisation de la classe
115        // récupération de l'enregistrement intégral
116        $this->full_record = $string;
117
118        // mise à jour des variables internes
119        // guide de l'enregistrement
120        $this->guide = substr($this->full_record, 0, 24);
121
122        // guide interne : valeurs par défaut si création
123
124
125        $rl = intval(substr($this->guide, 0 , 5));      # record length : pos.1-4
126        $rs = substr($this->guide, 5, 1);               # record status : pos.5
127        $dt = substr($this->guide, 6, 1);               # document type : pos.6
128        $bl = substr($this->guide, 7, 1);               # bibliographic level : pos.7
129        $hl = intval(substr($this->guide, 8, 1));       # hierarchical level : pos.8
130        $pos9 = substr($this->guide, 9, 1);             # pos.9 undefined, contains a blank (except for usmarc UTF8, contains 'a')
131        $il = intval(substr($this->guide, 10, 1));      # indicator length : pos.10 (2)
132        $sl = intval(substr($this->guide, 11, 1));      # subfield identifier length : pos.11 (2)       
133        $ba = intval(substr($this->guide, 12, 5));      # base adress : pos.12-16       
134        $el = substr($this->guide, 17, 1);              # encoding level : pos.17
135        $ru = substr($this->guide, 18, 1);              # record update : pos.18
136        $pos19 = substr($this->guide, 19, 1);           # pos.19 : undefined, contains a blank
137        $dm1 = intval(substr($this->guide, 20, 1));     # Length of 'Length of field' (pos.20, 4 in UNIMARC)
138        $dm2 = intval(substr($this->guide, 21, 1));     # Length of 'Starting character position' (pos.21, 5 in UNIMARC)
139        $dm3 = intval(substr($this->guide, 22, 1));     # Length of implementationdefined portion (pos.22, 0 in UNIMARC)
140        $pos23 = substr($this->guide, 23, 1);           # POS.23 : undefined, contains a blank
141
142        //martizva - some server z3950 send UPCASE $bl !!!
143        $bl = strtolower($bl); 
144
145        $this->inner_guide = array(
146                'rl' =>  $rl ? $rl : 0,
147                'rs' =>  $rs ? $rs : 'n',
148                'dt' => $dt ? $dt : 'a',
149                'bl' => $bl ? $bl : 'm',
150                'hl' => $hl ? $hl : 0,
151                'pos9' => $pos9 ? $pos9 : ' ',
152                'il' => $il ? $il : 2,
153                'sl' => $sl ? $sl : 2,
154                'ba' => $ba ? $ba : 24, 
155                'el' => $el ? $el : '1',
156                'ru' => $ru ? $ru : 'i',
157                'pos19' => $pos19 ? $pos19 : ' ',
158                'dm1' => $dm1 ? $dm1 : 4,
159                'dm2' => $dm2 ? $dm2 : 5,
160                'dm3' =>  $dm3 ? $dm3 : 0,
161                'pos23' => $pos23 ? $pos23 : ' '
162                );
163
164        // récupération du répertoire
165        $m = 3 + $this->inner_guide["dm1"] + $this->inner_guide["dm2"];
166
167        $this->directory = substr($this->full_record, 24, $this->inner_guide["ba"] - 25);
168
169        $tmp_dir = explode('|', chunk_split($this->directory, $m, '|'));
170        for($i = 0; $i < count($tmp_dir); $i++) {
171                if($tmp_dir[$i]) {
172                        $this->inner_directory[$i] = array(
173                        'label' => substr($tmp_dir[$i], 0, 3),
174                        'length' => intval(substr($tmp_dir[$i], 3, $this->inner_guide[dm1])),
175                        'adress' => intval(substr($tmp_dir[$i], 3 + $this->inner_guide["dm1"],  $this->inner_guide[dm2]))
176                        );
177                }
178        }
179
180        if(($this->type_marc != "usmarc") && !(preg_match("/^[x-z]$/",$this->inner_guide['pos6']))) {
181                $this->inner_guide['pos9'] =' ';
182        }
183       
184        // récupération des champs
185        $m = substr($this->full_record, $this->inner_guide["ba"], strlen($this->full_record) - $this->inner_guide["ba"]);
186        if($m) {
187                while(list($cle, $valeur)=each($this->inner_directory)) {
188                        $this->inner_data[$cle] = array(
189                                                        'label' => $this->inner_directory[$cle]["label"],
190                                                        'content' => substr($this->full_record, $this->inner_guide["ba"] + $valeur["adress"], $valeur["length"])
191                                                        );
192                        if ($this->inner_data[$cle]['label']=='100') $f100 = $this->inner_data[$cle]['content'];
193                }
194
195                //Prise en compte de l'encodage des notices en UTF-8
196                $encodage_fic_source=$_SESSION["encodage_fic_source"];
197                if($encodage_fic_source){//On choisi de forcer l'encodage des notices lues
198                        if($encodage_fic_source == "utf8"){
199                                $this->is_utf8=TRUE;
200                        }
201                }else{
202                        if($this->type_marc == "usmarc"){
203                                if ($this->inner_guide['pos9']=='a') $this->is_utf8=TRUE; //USMARC
204                        }else{
205                                if (substr($f100,30,2)=='50') $this->is_utf8=TRUE; //UNIMARC
206                        }
207                }
208        } else {
209                $this->inner_data = array();
210                $this->inner_directory = array();
211        }
212                       
213               
214                       
215        }
216
217// ---------------------------------------------------
218//              récupération d'un ou plusieurs sous-champ(s)
219// ---------------------------------------------------
220
221// ## cette fonction retourne un array ##
222function get_subfield() {
223
224        $result = array();
225
226        // vérification des paramètres
227        if(!func_num_args()) {
228                return $result;
229                }
230
231        for($i = 0; $i < sizeof($this->inner_data); $i++) {
232                if(preg_match('/'.func_get_arg(0).'/', $this->inner_data[$i]["label"])) {
233                        switch(func_num_args()) {
234                                case 1: // pas d'indication de sous-champ : on retourne le contenu entier
235                                        $result[] = $this->ISO_decode(preg_replace("/$this->rgx_field_end/", '', $this->inner_data[$i]["content"]));
236                                        break;
237                                case 2: // un seul sous-champ demandé
238                                        // récupération de la valeur du champ
239                                        $field = $this->inner_data[$i]["content"];
240                                        // le masque de recherche : subfield_begin cars. subfield_begin ou field_end
241                                        $mask = $this->rgx_subfield_begin.func_get_arg(1);
242                                        // MODIF ER
243                                        //$mask .= '(.*)['.$this->rgx_subfield_begin.'|'.$this->rgx_field_end.']';
244                                        $mask .= '(.*)['.$this->rgx_subfield_begin.''.$this->rgx_field_end.']';
245                                        while (preg_match("/$mask/sU", $field)) {
246                                                preg_match("/$mask/sU", $field, $regs);
247                                                $result[] = $this->ISO_decode($regs[1]);
248                                                $field = preg_replace("/$mask/sU", '', $field);
249                                                }
250                                        break;
251                                default: // un ou plusieurs sous-champs
252                                        // récupération de la valeur du champ
253                                        $field = $this->inner_data[$i]["content"];                             
254                                        for($j = 1; $j < func_num_args(); $j++) {
255                                                $subfield = func_get_arg($j);
256                                                $mask = $this->rgx_subfield_begin.$subfield;
257                                                // MODIF ER
258                                                //$mask .= '(.*)'.$this->rgx_subfield_begin.'|'.$this->rgx_field_end;
259                                                $mask .= '(.*)['.$this->rgx_subfield_begin.''.$this->rgx_field_end.']';
260                                                preg_match("/$mask/sU", $field, $regs);
261                                                $tmp[$subfield] = $this->ISO_decode($regs[1]); 
262                                                }
263                                        $result[] = $tmp;
264                                        break;
265                                }
266                        }
267                }
268        return $result;
269        }
270
271//Retourne le tableau des sous champs du champ $field
272//Si $subfield est vide (le code d'un sous champ), la fonction retourne un tableau de tableaux :
273//array(array("label"=>code du sous champ,"content"=>valeur du sous champ))
274//Sinon, si le sous champ est précisé, la fonction retourne un tableau simple correspondant
275//à toutes les valeurs trouvées pour le sous champ $subfield
276function get_subfield_array($field,$subfield="") {
277        $result=array();
278        $res_inter=array();
279        for($i = 0; $i < sizeof($this->inner_data); $i++) {
280                if ($this->inner_data[$i]["label"]==$field) {
281                        $content = substr($this -> inner_data[$i]["content"], 0, strlen($this -> inner_data[$i]["content"]) - 1);
282                        $sub_fields = explode(chr(31), $content);
283                        for ($j = 1; $j < count($sub_fields); $j ++) {
284                                        $res=array();
285                                        $res["label"]=substr($sub_fields[$j], 0, 1);
286                                        $res["content"]=$this -> ISO_decode(substr($sub_fields[$j], 1));
287                                        $res_inter[]=$res;
288                        }
289                }
290        }
291        if ($subfield!="") {
292                for ($i=0; $i<sizeof($res_inter); $i++) {
293                        if ($res_inter[$i]["label"]==$subfield) {
294                                $result[]=$res_inter[$i]["content"];
295                        }
296                }
297        }       else $result=$res_inter;
298        return $result;
299}
300
301//Retourne le tableau des sous champs du champ $field
302//Si $subfield est vide (le code d'un sous champ), la fonction retourne un tableau de tableaux :
303//array(array("label"=>code du sous champ,"content"=>valeur du sous champ))
304//Sinon, si le sous champ est précisé, la fonction retourne un tableau simple correspondant
305//à toutes les valeurs trouvées pour le sous champ $subfield
306function get_subfield_array_array($field,$subfield="") {
307        $result_field=array();
308        for($i = 0; $i < sizeof($this->inner_data); $i++) {
309                if ($this->inner_data[$i]["label"]==$field) {
310                        $result=array();
311                        $res_inter=array();
312                        $content = substr($this -> inner_data[$i]["content"], 0, strlen($this -> inner_data[$i]["content"]) - 1);
313                        $sub_fields = explode(chr(31), $content);
314                        for ($j = 1; $j < count($sub_fields); $j ++) {
315                                        $res=array();
316                                        $res["label"]=substr($sub_fields[$j], 0, 1);
317                                        $res["content"]=$this -> ISO_decode(substr($sub_fields[$j], 1));
318                                        $res_inter[]=$res;
319                        }
320                        if ($subfield!="") {
321                                for ($j=0; $j<sizeof($res_inter); $j++) {
322                                        if ($res_inter[$j]["label"]==$subfield) {
323                                                $result[]=$res_inter[$j]["content"];
324                                        }
325                                }
326                        } else $result=$res_inter;
327                        $result_field[]=$result;
328                }
329        }
330        return $result_field;
331}
332
333function get_all_fields($field) {
334        $result_fields=array();
335        for($i = 0; $i < sizeof($this->inner_data); $i++) {
336                if(preg_match('/'.$field.'/', $this->inner_data[$i]["label"])) {
337                        $content = substr($this -> inner_data[$i]["content"], 0, strlen($this -> inner_data[$i]["content"]) - 1);
338                        $sub_fields = explode(chr(0x1F), $content);
339                        $res=array();
340                        for ($j = 1; $j < count($sub_fields); $j ++) {
341                                        $res[substr($sub_fields[$j], 0, 1)][]=$this -> ISO_decode(substr($sub_fields[$j], 1));
342                                       
343                        }
344                        $result_fields[$this->inner_data[$i]["label"]][]=$res;
345                }
346        }
347        return $result_fields;
348}
349
350// ---------------------------------------------------
351//              ajout d'un champ
352// ---------------------------------------------------
353function add_field($label='000', $ind='') {
354
355        // vérification des paramètres : au moins 2
356        if(func_num_args() < 3) {
357                $this->errors[] = '[add_field] impossible d\'ajouter un champ vide';
358                return FALSE;
359                }
360
361        if($label < 1) {
362                $this->errors[] = '[add_field] le label \''.$label. '\' n\'est pas valide';
363                return FALSE;
364                }
365
366        // test des indicateurs
367        if(strlen($ind) != 0 && strlen($ind) != $this->inner_guide[il]) {
368                $this->errors[] = '[add_field] l\'indicateur \''.$ind. '\' n\'est pas valide';
369                return FALSE;
370                }
371
372        // mise en form du label
373        if(strlen($label) < 3 && $label < 100) $label = sprintf('%03d', $label);
374
375        // notre champ doit commencer par un label
376        if (!preg_match('/^[0-9]{3}$/', $label)) {
377                $this->last_error = '[add_field] le label \''.$label. '\' n\'est pas valide';
378                return FALSE;
379                }
380
381        $nb_args = func_num_args();
382
383        // suivant le cas, ajout des infos
384        switch($nb_args) {
385                case 3: // il n'y a qu'un seul param en plus du label et des indicateurs
386                        if(!is_array(func_get_arg(2))) $content = func_get_arg(2);
387                                else {
388                                        // le param est un tableau
389                                        $field = func_get_arg(2);
390                                        for($i=0;$i < sizeof($field); $i++) {
391                                                if(preg_match('/^[a-zA-Z0-9]$/', $field[$i][0]) && $field[$i][1]) $content .= $this->subfield_begin.$field[$i][0].$field[$i][1];
392                                                }
393                                        }
394                        break;
395                default: // plus d'un champ
396                        // on s'assure que le nombre de param est pair
397                        if(floor($nb_args/2) < $nb_args/2) $nb_args = $nb_args - 1;
398                        // récupérer les paires champ/valeur
399                        $i = 2;
400                        while( $i < $nb_args - 1) {
401                                $field = func_get_arg($i);
402                                $fieldbis = func_get_arg($i + 1);
403                                if(preg_match('/^[a-zA-Z0-9]$/', $field)) $content .= $this->subfield_begin.$field.$fieldbis;
404                                        else $this->errors[] = '[add_field] étiquette de sous-champ non valide';
405                                $i = $i + 2;
406                                }
407                        break;
408                }
409
410        if(sizeof($content)) {
411                $content = $this->ISO_encode($content).$this->field_end; 
412
413                // ajout des éventuels indicateurs
414                if(strlen($ind) == $this->inner_guide["il"]) $content = $ind.$content;
415
416                // mise à jour des inner_data
417                $index = sizeof($this->inner_data);
418                $this->inner_data[$index]["label"] = $label;
419                $this->inner_data[$index]["content"] = $content;               
420
421                }
422
423        if($this->auto_update) $this->update();
424                return TRUE;
425        }
426
427// ---------------------------------------------------
428//              suppression d'un champ
429// ---------------------------------------------------
430function delete_field($label, $index=-1) {
431
432        if(!func_num_args()) {
433                $this->errors[] = '[delete_field] pas de label pour le champ';
434                return FALSE;
435                }
436
437        if(!$label) {
438                $this->errors[] = '[delete_field] le label \''.$label. '\' n\'est pas valide';
439                return FALSE;
440                }
441
442        // mise en form du label
443        if(strlen($label) < 3 && $label < 100) $label = sprintf('%03d', $label);
444
445        // vérification du format du label
446        if (!preg_match('/^[0-9\.]{3}$/', $label)) {
447                $this->last_error = '[delete_field] le label \''.$label. '\' n\'est pas valide';
448                return FALSE;
449                }
450
451        for($i=0; $i < sizeof($this->inner_data); $i++) {
452                if(preg_match('/'.$label.'/', $this->inner_data[$i]["label"])) {
453                        $this->inner_data[$i]["label"] ='';             
454                        $this->inner_data[$i]["content"] ='';
455                        }       
456                }               
457
458        if($this->auto_update) $this->update();         
459        return TRUE;
460        }
461
462// ---------------------------------------------------
463//              update de l'enregistrement
464// ---------------------------------------------------
465function update() {
466
467        // supprime les lignes vides d'inner_data et gestion de l'encodage
468        $ch_100_trouve=false;
469        for($i=0; $i < sizeof($this->inner_data); $i++){
470                if(empty($this->inner_data[$i]["label"]) || empty($this->inner_data[$i]["content"])) {
471                        array_splice($this->inner_data, $i, 1);
472                        $i--; 
473                }
474               
475                //Gestion de l'encodage de la notice
476                if($this->inner_data[$i]["label"] == "100"){
477                        if(preg_match("#^(.*?)(".$this->subfield_begin.".*?)".$this->field_end."#",$this->inner_data[$i]["content"],$matches)){
478                                if(strlen($matches[1]) != 2){
479                                        $this->inner_data[$i]["content"]="  ".$matches[2];
480                                }
481                        }
482                        if(strlen($this->inner_data[$i]["content"]) > 35){
483                                $this->inner_data[$i]["content"]=substr($this->inner_data[$i]["content"],0,35);
484                        }elseif(strlen($this->inner_data[$i]["content"]) < 31){
485                                $this->inner_data[$i]["content"]=substr($this->inner_data[$i]["content"],0,-1);//j'enlève le caractère de fin de champ
486                        }
487                        if($this->is_utf8){
488                                $this->inner_data[$i]["content"][30]="5";
489                                $this->inner_data[$i]["content"][31]="0";
490                                $this->inner_data[$i]["content"][32]=" ";
491                                $this->inner_data[$i]["content"][33]=" ";
492                                $this->inner_data[$i]["content"][34]=$this->field_end;
493                        }else{
494                                $this->inner_data[$i]["content"][30]="0";
495                                $this->inner_data[$i]["content"][31]="1";
496                                $this->inner_data[$i]["content"][32]="0";
497                                $this->inner_data[$i]["content"][33]="3";
498                                $this->inner_data[$i]["content"][34]=$this->field_end;
499                        }
500                        $ch_100_trouve=true;
501                }
502        }
503       
504        //Gestion de l'encodage de la notice
505        if(!$ch_100_trouve){
506                $tmp=array();
507                $tmp["label"]="100";
508                if($this->is_utf8){
509                        $tmp["content"]="  ".$this->subfield_begin."a                          50".$this->field_end;
510                }else{
511                        $tmp["content"]="  ".$this->subfield_begin."a                          0103".$this->field_end;
512                }
513                $this->inner_data[]=$tmp;
514        }
515
516        // reconstitution inner_directory
517        $this->inner_directory = array();
518        for($i = 0; $i < sizeof($this->inner_data); $i++){
519               
520                if(strlen($this->inner_data[$i]["content"]) > 9999){
521                        //Si le champs est trop long on le découpe et on créer un warning
522                        $tempo=$this->inner_data[$i]["content"];
523                        $this->inner_data[$i]["content"]=substr($tempo,0,9998).substr($tempo,-1);
524                        $num_notice=$this->get_subfield("001");
525                        $txt=$num_notice[0]? $num_notice[0]." ":"";
526                        $this->warnings[] = '[warning : longueur] notice '.$txt.'exportée mais champ \''.$this->inner_data[$i]["label"]. '\' tronqué';
527                }
528                $this->inner_directory[$i] = array(
529                                'label' => $this->inner_data[$i]["label"],
530                                'length' => strlen($this->inner_data[$i]["content"]),
531                                'adress' => 0
532                                );
533                } 
534
535        // mise à jour des offset et du répertoire 'réel'
536        for($i = 1; $i < sizeof($this->inner_data); $i++){
537                $this->inner_directory[$i]["adress"] = $this->inner_directory[$i - 1]["length"] + $this->inner_directory[$i - 1]["adress"];
538                }
539
540        // mise à jour du répertoire
541        $this->directory = ''; 
542        for($i=0; $i < sizeof($this->inner_directory) ; $i++) {
543                $this->directory .= sprintf('%03d', $this->inner_directory[$i]["label"]);
544                $this->directory .= sprintf('%0'.$this->inner_guide["dm1"].'d', $this->inner_directory[$i]["length"]);
545                $this->directory .= sprintf('%0'.$this->inner_guide["dm2"].'d', $this->inner_directory[$i]["adress"]);
546                } 
547
548        // mise à jour du contenu
549        $this->data = $this->field_end;
550        for($i=0; $i < sizeof($this->inner_data) ; $i++) {
551                $this->data .= $this->inner_data[$i]["content"];
552                }
553        $this->data .= $this->record_end;
554
555        // mise à jour du guide
556        ## adresse de base.
557        $this->inner_guide["ba"] = 24 + strlen($this->directory) + 1;
558        ## longueur de l'enregistrement iso2709
559        $this->inner_guide["rl"] = 24 + strlen($this->directory) + strlen($this->data);
560
561        $this->guide = sprintf('%05d', $this->inner_guide["rl"]);
562        $this->guide .= $this->inner_guide["rs"];
563        $this->guide .= $this->inner_guide["dt"];
564        $this->guide .= $this->inner_guide["bl"];
565        $this->guide .= $this->inner_guide["hl"];
566        $this->guide .= $this->inner_guide["pos9"];
567        $this->guide .= $this->inner_guide["il"];
568        $this->guide .= $this->inner_guide["sl"];
569        $this->guide .= sprintf('%05d', $this->inner_guide["ba"]);
570        $this->guide .= $this->inner_guide["el"];
571        $this->guide .= $this->inner_guide["ru"];
572        $this->guide .= $this->inner_guide["pos19"];
573        $this->guide .= $this->inner_guide["dm1"];
574        $this->guide .= $this->inner_guide["dm2"];
575        $this->guide .= $this->inner_guide["dm3"];
576        $this->guide .= $this->inner_guide["pos23"];
577
578        // constitution du nouvel enregistrement
579        $this->full_record = $this->guide.$this->directory.$this->data;
580
581        }
582
583// ---------------------------------------------------
584//              affichage d'un rapport des erreurs
585// ---------------------------------------------------
586function show_errors() {
587        if(sizeof($this->errors)) {
588                print '<table border=\'1\'>';
589                print '<tr><th colspan=\'2\'>iso2709_record : erreurs</th></tr>';
590                for($i=0; $i < sizeof($this->errors); $i++) {
591                        print '<tr><td>';
592                        print $i+1;
593                        print '</td><td>'.$this->errors[$i].'</td></tr>';
594                        }
595                print '</table>';
596        } else {
597                print 'aucune erreur<br />';
598        }
599}
600
601// ---------------------------------------------------
602//              fonction de validation d'un enregistrement
603// ---------------------------------------------------
604function valid($mode="convert") {
605
606        // $this->errors = array(); // init du tableau des erreurs
607        $num_notice=$this->get_subfield("001");
608        $txt=$num_notice[0]? $num_notice[0]." ":"";
609        // test de la longueur de l'enregistrement
610                if (strlen($this->full_record) != $this->inner_guide['rl'] || substr($this->full_record, -1, 1) != $this->record_end) 
611                        $this->errors[] = '[error : format] notice '.$txt.'perdue : La longueur de l\'enregistrement ne correspond pas au guide';
612
613        // test des fin de champs
614        // on retourne false si un champ ne finit pas par l'IS3
615        while(list($cle, $valeur) = each($this->inner_data)) {
616                if(!preg_match("/".$this->rgx_field_end."$/", $valeur["content"]))
617                        $this->errors[] = '[error : format] notice '.$txt.'perdue : Le champ '.$cle.' ne finit pas par le caractère de fin de champ';
618                }
619
620        // les tableaux internes sont vides
621        if(!sizeof($this->inner_data) || !sizeof($this->inner_data))
622                $this->errors[] = '[error : internal] notice '.$txt.'perdue : Cet enregistrement est vide';
623
624        // les inner_data et le inner_directory ne sont pas synchronisés
625        if(sizeof($this->inner_data) != sizeof($this->inner_directory))
626                $this->errors[] = '[error : internal] notice '.$txt.'perdue : Les tableaux internes ne sont pas synchronisés';
627
628        if(($mode == "import_notice") && (trim($this->inner_guide['pos9'])) && (preg_match("/^[a-l]$/",$this->inner_guide['pos9']))){
629                $this->errors[] = '[error : format] notice '.$txt.'perdue : Il ne s\'agit pas d\'une notice bibliographique (voir norme UNIMARC B) ('.$this->inner_guide['pos9'].')';
630        }       
631               
632        if(sizeof($this->errors)) return FALSE;
633       
634        return TRUE;
635        }
636
637// ---------------------------------------------------
638//              fonctions de mise à jour du guide
639// ---------------------------------------------------
640function set_rs($status) {
641        if ($status) {
642                $this->inner_guide["rs"] = $status[0];
643                if($this->auto_update) $this->update();
644                }                       
645        }
646
647function set_dt($dtype) {
648        if ($dtype) {
649                $this->inner_guide["dt"] = $dtype[0];
650                if($this->auto_update) $this->update();
651                }                       
652        }
653
654function set_bl($bltype) {
655        if ($bltype) {
656                $this->inner_guide["bl"] = $bltype[0];
657                if($this->auto_update) $this->update();
658                }                       
659        }
660
661function set_hl($hltype) {
662        if ($hltype) {
663                $this->inner_guide["hl"] = $hltype[0];
664                if($this->auto_update) $this->update();
665                }                       
666        }
667
668function set_el($eltype) {
669        if ($eltype) {
670                $this->inner_guide["el"] = $eltype[0];
671                if($this->auto_update) $this->update();
672                }                       
673        }
674
675function set_ru($rutype) {
676        if ($rutype) {
677                $this->inner_guide["ru"] = $rutype[0];
678                if($this->auto_update) $this->update();
679                }                       
680        }
681
682        /*
683                Tables de conversion ISO 646 & 5426 / ISO 8859-15
684        */
685        function iso_tables() {
686                global $ISO5426,$ISO5426_dia,$ISO8859_15,$ISO8859_15_dia;
687                //Tableaux de correspondance de ISO646/5426 vers ISO8859-15
688                        $ISO5426_dia=array(
689                                chr(0xc1).chr(0x41)=>chr(0xc0),chr(0xc1).chr(0x45)=>chr(0xc8),chr(0xc1).chr(0x49)=>chr(0xcc),
690                                chr(0xc1).chr(0x4f)=>chr(0xd2),chr(0xc1).chr(0x55)=>chr(0xd9),chr(0xc1).chr(0x61)=>chr(0xe0),
691                                chr(0xc1).chr(0x65)=>chr(0xe8),chr(0xc1).chr(0x69)=>chr(0xec),chr(0xc1).chr(0x6f)=>chr(0xf2),
692                                chr(0xc1).chr(0x75)=>chr(0xf9),chr(0xc2).chr(0x41)=>chr(0xc1),chr(0xc2).chr(0x45)=>chr(0xc9),
693                                chr(0xc2).chr(0x49)=>chr(0xcd),chr(0xc2).chr(0x4f)=>chr(0xd3),chr(0xc2).chr(0x55)=>chr(0xda),
694                                chr(0xc2).chr(0x59)=>chr(0xdd),chr(0xc2).chr(0x61)=>chr(0xe1),chr(0xc2).chr(0x65)=>chr(0xe9),
695                                chr(0xc2).chr(0x69)=>chr(0xed),chr(0xc2).chr(0x6f)=>chr(0xf3),chr(0xc2).chr(0x75)=>chr(0xfa),
696                                chr(0xc2).chr(0x79)=>chr(0xfd),chr(0xc3).chr(0x41)=>chr(0xc2),chr(0xc3).chr(0x45)=>chr(0xca),
697                                chr(0xc3).chr(0x49)=>chr(0xce),chr(0xc3).chr(0x4f)=>chr(0xd4),chr(0xc3).chr(0x55)=>chr(0xdb),
698                                chr(0xc3).chr(0x61)=>chr(0xe2),chr(0xc3).chr(0x65)=>chr(0xea),chr(0xc3).chr(0x69)=>chr(0xee),
699                                chr(0xc3).chr(0x6f)=>chr(0xf4),chr(0xc3).chr(0x75)=>chr(0xfb),chr(0xc4).chr(0x41)=>chr(0xc3),
700                                chr(0xc4).chr(0x4e)=>chr(0xd1),chr(0xc4).chr(0x4f)=>chr(0xd5),chr(0xc4).chr(0x61)=>chr(0xe3),
701                                chr(0xc4).chr(0x6e)=>chr(0xf1),chr(0xc4).chr(0x6f)=>chr(0xf5),chr(0xc8).chr(0x41)=>chr(0xc4),
702                                chr(0xc8).chr(0x45)=>chr(0xcb),chr(0xc8).chr(0x49)=>chr(0xcf),chr(0xc8).chr(0x4f)=>chr(0xd6),
703                                chr(0xc8).chr(0x55)=>chr(0xdc),chr(0xc8).chr(0x59)=>chr(0xbe),chr(0xc8).chr(0x61)=>chr(0xe4),
704                                chr(0xc8).chr(0x65)=>chr(0xeb),chr(0xc8).chr(0x69)=>chr(0xef),chr(0xc8).chr(0x6f)=>chr(0xf6),
705                                chr(0xc8).chr(0x75)=>chr(0xfc),chr(0xc8).chr(0x79)=>chr(0xff),chr(0xc9).chr(0x41)=>chr(0xc4),
706                                chr(0xc9).chr(0x45)=>chr(0xcb),chr(0xc9).chr(0x49)=>chr(0xcf),chr(0xc9).chr(0x4f)=>chr(0xd6),
707                                chr(0xc9).chr(0x55)=>chr(0xdc),chr(0xc8).chr(0x59)=>chr(0xbe),chr(0xc9).chr(0x61)=>chr(0xe4),
708                                chr(0xc9).chr(0x65)=>chr(0xeb),chr(0xc9).chr(0x69)=>chr(0xef),chr(0xc9).chr(0x6f)=>chr(0xf6),
709                                chr(0xc9).chr(0x75)=>chr(0xfc),chr(0xc9).chr(0x79)=>chr(0xff),chr(0xca).chr(0x41)=>chr(0xc5),
710                                chr(0xca).chr(0x61)=>chr(0xe5),chr(0xd0).chr(0x43)=>chr(0xc7),chr(0xd0).chr(0x63)=>chr(0xe7),
711                                chr(0xcf).chr(0x53)=>chr(0xa6),chr(0xcf).chr(0x73)=>chr(0xa8),chr(0xcf).chr(0x5a)=>chr(0xb4),
712                                chr(0xc5).chr(0x20)=>chr(0xaf),chr(0xca).chr(0x20)=>chr(0xb0),chr(0xc7).chr(0x20)=>chr(0xba)
713                        );
714                       
[892]715        //-------LLIUREX  16/03/2016-----------------------------------
716        // --- soluciona problema de codificación de los registros de z3950
[815]717                        $ISO5426=array(
[892]718                                chr(0xa0)=>chr(0xa0),
719                                chr(0xa1)=>chr(0xc5).chr(0x81),
720                                chr(0xa2)=>chr(0xc3).chr(0x98),
721                                chr(0xa3)=>chr(0xc4).chr(0x90),
722                                chr(0xa4)=>chr(0xc3).chr(0x9e),
723                                chr(0xa5)=>chr(0xc3).chr(0x86),
724                                chr(0xa6)=>chr(0xc5).chr(0x92),
725                                chr(0xa7)=>chr(0xca).chr(0xb9),
726                                chr(0xa8)=>chr(0xc2).chr(0xb7),
727                                chr(0xa9)=>chr(0xe2).chr(0x99).chr(0xad),
728                                chr(0xaa)=>chr(0xc2).chr(0xae),
729                                chr(0xab)=>chr(0xc2).chr(0xb1),
730                                chr(0xac)=>chr(0xc6).chr(0xa0),
731                                chr(0xad)=>chr(0xc6).chr(0xaf),
732                                chr(0xae)=>chr(0xca).chr(0xbc),
733                                chr(0xaf)=>chr(0xae),
734                                chr(0xb0)=>chr(0xca).chr(0xbb),
735                                chr(0xb1)=>chr(0xc5).chr(0x82),
736                                chr(0xb2)=>chr(0xc3).chr(0xb8),
737                                chr(0xb3)=>chr(0xc4).chr(0x91),
738                                chr(0xb4)=>chr(0xc3).chr(0xbe),
739                                chr(0xb5)=>chr(0xc3).chr(0xa6),
740                                chr(0xb6)=>chr(0xc5).chr(0x93),
741                                chr(0xb7)=>chr(0xca).chr(0xba),
742                                chr(0xb8)=>chr(0xc4).chr(0xb1),
743                                chr(0xb9)=>chr(0xc2).chr(0xa3),
744                                chr(0xba)=>chr(0xc3).chr(0xb0),
745                                chr(0xbb)=>chr(0xbb),
746                                chr(0xbc)=>chr(0xc6).chr(0xa1),
747                                chr(0xbd)=>chr(0xc6).chr(0xb0),
748                                chr(0xbe)=>chr(0x22),
749                                chr(0xbf)=>chr(0xbf),
750                                chr(0xc0)=>chr(0xc2).chr(0xb0),
751                                chr(0xc1)=>chr(0xe2).chr(0x84).chr(0x93),
752                                chr(0xc2)=>chr(0xe2).chr(0x84).chr(0x97),
753                                chr(0xc3)=>chr(0xc2).chr(0xa9),
754                                chr(0xc4)=>chr(0xe2).chr(0x99).chr(0xaf),
755                                chr(0xc5)=>chr(0xc2).chr(0xbf),
756                                chr(0xc6)=>chr(0xc2).chr(0xa1),
757                                chr(0xc7)=>chr(0xc3).chr(0x9f),
758                                chr(0xc8)=>chr(0xe2).chr(0x82).chr(0xac),
759                                chr(0xe0)=>chr(0xcc).chr(0x89),
760                                chr(0xe1)=>chr(0xcc).chr(0x80),
761                                chr(0xe1).chr(0x61)=>chr(0xe0),
762                                chr(0xe1).chr(0x65)=>chr(0xe8),
763                                chr(0xe1).chr(0x69)=>chr(0xec),
764                                chr(0xe1).chr(0x6f)=>chr(0xf2),
765                                chr(0xe1).chr(0x75)=>chr(0xf9),
766                                chr(0xe1).chr(0x41)=>chr(0xc0),
767                                chr(0xe1).chr(0x45)=>chr(0xc8),
768                                chr(0xe1).chr(0x49)=>chr(0xcc),
769                                chr(0xe1).chr(0x4f)=>chr(0xd2),
770                                chr(0xe1).chr(0x55)=>chr(0xd9),
771                                chr(0xe2)=>chr(0xcc).chr(0x81),
772                                chr(0xe2).chr(0x61)=>chr(0xe1),
773                                chr(0xe2).chr(0x65)=>chr(0xe9),
774                                chr(0xe2).chr(0x69)=>chr(0xed),
775                                chr(0xe2).chr(0x6f)=>chr(0xf3),
776                                chr(0xe2).chr(0x75)=>chr(0xfa),
777                                chr(0xe2).chr(0x41)=>chr(0xc1),
778                                chr(0xe2).chr(0x45)=>chr(0xc9),
779                                chr(0xe2).chr(0x49)=>chr(0xcd),
780                                chr(0xe2).chr(0x4f)=>chr(0xd3),
781                                chr(0xe2).chr(0x55)=>chr(0xda),
782                                chr(0xe2).chr(0x79)=>chr(0xfd),
783                                chr(0xe2).chr(0x59)=>chr(0xdd),
784                                chr(0xe3)=>chr(0xcc).chr(0x82),
785                                chr(0xe3).chr(0x61)=>chr(0xe2),
786                                chr(0xe3).chr(0x65)=>chr(0xea),
787                                chr(0xe3).chr(0x69)=>chr(0xee),
788                                chr(0xe3).chr(0x6f)=>chr(0xf4),
789                                chr(0xe3).chr(0x75)=>chr(0xfb),
790                                chr(0xe3).chr(0x41)=>chr(0xc2),
791                                chr(0xe3).chr(0x45)=>chr(0xca),
792                                chr(0xe3).chr(0x49)=>chr(0xce),
793                                chr(0xe3).chr(0x4f)=>chr(0xd4),
794                                chr(0xe3).chr(0x55)=>chr(0xdb),
795                                chr(0xe4)=>chr(0xcc).chr(0x83),
796                                chr(0xe4).chr(0x61)=>chr(0xe3),
797                                chr(0xe4).chr(0x41)=>chr(0xc3),
798                                chr(0xe4).chr(0x6f)=>chr(0xf5),
799                                chr(0xe4).chr(0x4f)=>chr(0xd5),
800                                chr(0xe4).chr(0x6e)=>chr(0xf1),
801                                chr(0xe4).chr(0x4e)=>chr(0xd1),
802                                chr(0xe5)=>chr(0xcc).chr(0x84),
803                                chr(0xe6)=>chr(0xcc).chr(0x86),
804                                chr(0xe7)=>chr(0xcc).chr(0x87),
805                                chr(0xe8)=>chr(0xcc).chr(0x88),
806                                chr(0xe8).chr(0x61)=>chr(0xe4),
807                                chr(0xe8).chr(0x65)=>chr(0xeb),
808                                chr(0xe8).chr(0x69)=>chr(0xef),
809                                chr(0xe8).chr(0x6f)=>chr(0xf6),
810                                chr(0xe8).chr(0x75)=>chr(0xfc),
811                                chr(0xe8).chr(0x41)=>chr(0xc4),
812                                chr(0xe8).chr(0x45)=>chr(0xcb),
813                                chr(0xe8).chr(0x49)=>chr(0xcf),
814                                chr(0xe8).chr(0x4f)=>chr(0xd6),
815                                chr(0xe8).chr(0x55)=>chr(0xdc),
816                                chr(0xe8).chr(0x79)=>chr(0xff),
817                                chr(0xe9)=>chr(0xcc).chr(0x8c),
818                                chr(0xea)=>chr(0xcc).chr(0x8a),
819                                chr(0xea).chr(0x61)=>chr(0xe5),
820                                chr(0xea).chr(0x41)=>chr(0xc5),
821                                chr(0xeb)=>chr(0xcd).chr(0xa1),
822                                chr(0xec)=>chr(0xef).chr(0xb8).chr(0xa1),
823                                chr(0xed)=>chr(0xcc).chr(0x95),
824                                chr(0xee)=>chr(0xcc).chr(0x8b),
825                                chr(0xef)=>chr(0xcc).chr(0x90),
826                                chr(0xf0)=>chr(0xcc).chr(0xa7),
827                                chr(0xf0).chr(0x63)=>chr(0xe7),
828                                chr(0xf0).chr(0x43)=>chr(0xc7),
829                                chr(0xf1)=>chr(0xcc).chr(0xa8),
830                                chr(0xf2)=>chr(0xcc).chr(0xa3),
831                                chr(0xf3)=>chr(0xcc).chr(0xa4),
832                                chr(0xf4)=>chr(0xcc).chr(0xa5),
833                                chr(0xf5)=>chr(0xcc).chr(0xb3),
834                                chr(0xf6)=>chr(0xcc).chr(0xb2),
835                                chr(0xf7)=>chr(0xcc).chr(0xa6),
836                                chr(0xf8)=>chr(0xcc).chr(0x9c),
837                                chr(0xf9)=>chr(0xcc).chr(0xae),
838                                chr(0xfa)=>chr(0xcd).chr(0xa0),
839                                chr(0xfb)=>chr(0xef).chr(0xb8).chr(0xa3),
840                                chr(0xfc)=>chr(0xfe),
841                                chr(0xfd)=>chr(0x3f),
842                                chr(0xfe)=>chr(0xcc).chr(0x93),
843                                chr(0xff)=>chr(0x3f)
[815]844                        );
[892]845//-------FIN  LLIUREX  16/03/2016-----------------------------------------
[815]846                       
847                        //Tableaux de correspondance de ISO8859-15 vers ISO646/5426
848                        //Pour les diacritiques, il y a correspondance biunivoque, on fait donc une inversion du tableau
849                        $ISO8859_15_dia=array_flip($ISO5426_dia);
850                       
851                        //Pour les caractères spéciaux, la transformation n'est pas biunivoque
852                        $ISO8859_15=array(
853                                chr(0xa0)=>chr(0xa0),chr(0xa1)=>chr(0xa1),chr(0xa2)=>chr(0x3f),chr(0xa3)=>chr(0xa3),
854                                chr(0xa4)=>chr(0x80),chr(0xa5)=>chr(0xa5),chr(0xa6)=>chr(0xcf).chr(0x53),chr(0xa7)=>chr(0xa7),
855                                chr(0xa8)=>chr(0xcf).chr(0x73),chr(0xa9)=>chr(0xad),chr(0xaa)=>chr(0x41),chr(0xab)=>chr(0xab),
856                                chr(0xac)=>chr(0x3f),chr(0xad)=>chr(0xa0),chr(0xae)=>chr(0xaf),chr(0xb1)=>chr(0xd8).chr(0x2b),
857                                chr(0xb2)=>chr(0x32),chr(0xb3)=>chr(0x33),chr(0xb4)=>chr(0xcf).chr(0x5a),chr(0xb5)=>chr(0x75),
858                                chr(0xb6)=>chr(0x20),chr(0xb7)=>chr(0xb7),chr(0xb8)=>chr(0xcf).chr(0x7a),chr(0xb9)=>chr(0x31),
859                                chr(0xbb)=>chr(0xbb),chr(0xbc)=>chr(0x4f).chr(0x45),chr(0xbd)=>chr(0x6f).chr(0x65),chr(0xbf)=>chr(0xbf),
860                                chr(0xc6)=>chr(0xe1),chr(0xd0)=>chr(0xe2),chr(0xd7)=>chr(0x2a),chr(0xd8)=>chr(0xe9),
861                                chr(0xde)=>chr(0xec),chr(0xdf)=>chr(0xfb),chr(0xe6)=>chr(0xf1),chr(0xf0)=>chr(0xf3),
862                                chr(0xf7)=>chr(0x2f),chr(0xf8)=>chr(0xf9),chr(0xfe)=>chr(0xfc)
863                        );
864        }
865       
866        /*
867                Conversion d'une chaine ISO 8859-15 en ISO 646/5426
868        */
869        function ISO_646_5426_encode($string) {
870                global $ISO5426,$ISO5426_dia,$ISO8859_15,$ISO8859_15_dia;
871                if (!$ISO5426) {
872                        if(is_object($this))$this->iso_tables();
873                        else iso2709_record::iso_tables();
874                }
875               
876                $string_r="";
877                for ($i=0; $i<strlen($string); $i++) {
878                        if ($string[$i]<chr(0xa0)) 
879                                $string_r.=$string[$i];
880                        else if ($ISO8859_15_dia[$string[$i]])
881                                $string_r.=$ISO8859_15_dia[$string[$i]];
882                        else if ($ISO8859_15[$string[$i]])
883                                $string_r.=$ISO8859_15[$string[$i]];
884                        else
885                                $string_r.="?";
886                }
887                return $string_r;
888        }
889       
890        //      Conversion d'une chaine ISO 646 / 5426 an ISO 8859-15
891
892        function ISO_646_5426_decode($string) {
893                global $ISO5426,$ISO5426_dia,$ISO8859_15,$ISO8859_15_dia;
894                if (!$ISO5426) {
895                        if(is_object($this))$this->iso_tables();
896                        else iso2709_record::iso_tables();
897                }
898                //Remplacement des symboles et caractères spéciaux
899                $string_r="";
900                for ($i=0; $i<strlen($string); $i++) {
901                        //Si c'est un caractère avant 0xA0 alors rien a changer
902                        if ($string[$i]<chr(0xA0)) 
903                                $string_r.=$string[$i];
904                        else if (($string[$i]>=chr(0xC0))&&($string[$i]<=chr(0xDF))) {
905                                //Si c'est un diacritique on regarde le caractère suivant et on cherche dans la table de correspondance
906                                $car=$string[$i].$string[$i+1];
[892]907//Si le caractère est connu
908//------- LLIUREX  16/03/2016--------------------------------------
[815]909                                if ($ISO5426_dia[$car]) {
910                                        $string_r.=$ISO5426_dia[$car];
[892]911                                        $i++;
912                                } else if ($ISO5426[$string[$i]]) {
913                                        $string_r.=$ISO5426[$string[$i]];
[815]914                                } else {
915                                        //Sinon on ne tient juste pas compte du diacritique
916                                        $string_r.=$string[$i+1];
[892]917                                        $i++;
[815]918                                }
919                                //On avance d'un caractère
[892]920                        } 
921                        else if ( (($string[$i]>=chr(0xE1))&&($string[$i]<=chr(0xE4))) || ($string[$i]==chr(0xE8)) || ($string[$i]==chr(0xEA)) || ($string[$i]==chr(0xF0)) ) {
922                                        $car=$string[$i].$string[$i+1];
923                                        if ($ISO5426[$car]) {
924                                                $string_r.=$ISO5426[$car];
925                                                $i++;
926                                        } else {
927                                                $car=$string[$i];
928                                                $string_r.=$ISO5426[$car];
929                                        }
930                        }
931//------- FIN LLIUREX  16/03/2016----------------------------------
932
933                        else {
[815]934                                //Sinon c'est un catactère spécial ou un symbole
935                                $car=$string[$i];
936                                $string_r.=$ISO5426[$car];
937                        }
938                }
939                $string_r=str_replace(NSBB,"",$string_r);
940                if(preg_match("/[a-zA-Z0-9]".NSBE."[a-zA-Z0-9]/",$string_r)){
941            $string_r=str_replace(NSBE," ",$string_r);
942        }else{
943            $string_r=str_replace(NSBE,"",$string_r);
944        }
945        //$string_r=str_replace(NSBE,"",$string_r);
946                return $string_r;
947        }
948
949        function ISO_decode($chaine) {
950                global $ISO_decode_do_not_decode ;
951                global $charset;
952                $encodage_fic_source=$_SESSION["encodage_fic_source"];
953                if ($ISO_decode_do_not_decode) return $chaine ;
954               
955                //On a forcé l'encodage au moment de l'import ou de la convertion
956                if($encodage_fic_source == "iso8859"){
957                        if($charset !=='utf-8'){//Le charset de PMB est en iso-8859
958                                return $chaine ;
959                        }else{
960                                if(function_exists("mb_convert_encoding") && ((strpos($chaine,chr(0x92)) !== false) || (strpos($chaine,chr(0x93)) !== false) || (strpos($chaine,chr(0x9c)) !== false) || (strpos($chaine,chr(0x8c)) !== false))){//Pour les caractères windows
961                                        $chaine = mb_convert_encoding($chaine,"UTF-8","Windows-1252");
962                                }else{
963                                        $chaine = utf8_encode($chaine);
964                                }
965                                return $chaine;
966                        }
967                }elseif($encodage_fic_source == "iso5426"){
968                        if(is_object($this)) {
969                                $chaine=$this->ISO_646_5426_decode($chaine);
970                        } else {
971                                $chaine=iso2709_record::ISO_646_5426_decode($chaine);
972                        }
973                        if($charset !=='utf-8'){//Le charset de PMB est en iso-8859
974                                return $chaine ;
975                        }else{
976                                if(function_exists("mb_convert_encoding") && ((strpos($chaine,chr(0x92)) !== false) || (strpos($chaine,chr(0x93)) !== false) || (strpos($chaine,chr(0x9c)) !== false) || (strpos($chaine,chr(0x8c)) !== false))){//Pour les caractères windows
977                                        $chaine = mb_convert_encoding($chaine,"UTF-8","Windows-1252");
978                                }else{
979                                        $chaine = utf8_encode($chaine);
980                                }
981                                return $chaine;
982                        }
983                       
984                }elseif($encodage_fic_source == "utf8"){
985                        if($charset !=='utf-8'){//Le charset de PMB est en iso-8859
986                                return utf8_decode($chaine) ;
987                        }else{
988                                return $chaine;
989                        }
990                }
991               
992                //Fonctionnement normal
993                if (is_object($this) && ($this->is_utf8===TRUE)) {      //Cas notices USMARC et UNIMARC encodees en UTF8
994                        if ($charset !=='utf-8') $chaine = utf8_decode($chaine);
995                        return $chaine;
996                }
997
998                if(is_object($this)) {
999                        $chaine=$this->ISO_646_5426_decode($chaine);
1000                } else {
1001                        $chaine=iso2709_record::ISO_646_5426_decode($chaine);
1002                }
1003                if ($charset == 'utf-8'){
1004                        if(function_exists("mb_convert_encoding") && ((strpos($chaine,chr(0x92)) !== false) || (strpos($chaine,chr(0x93)) !== false) || (strpos($chaine,chr(0x9c)) !== false) || (strpos($chaine,chr(0x8c)) !== false))){//Pour les caractères windows
1005                                $chaine = mb_convert_encoding($chaine,"UTF-8","Windows-1252");
1006                        }else{
1007                                $chaine = utf8_encode($chaine);
1008                        }
1009                }
1010                return $chaine;
1011        }
1012       
1013        function ISO_encode($chaine) {
1014                global $charset;
1015                if (!$chaine) return $chaine;
1016               
1017                if(is_object($this) && ($this->is_utf8===TRUE)){
1018                        return $chaine;
1019                }
1020               
1021                /*if ($charset == 'utf-8' && is_object($this) && ($this->is_utf8===false)){
1022                        $chaine = utf8_decode($chaine);
1023                }elseif($charset != 'utf-8' && is_object($this) && ($this->is_utf8===true)){
1024                        $chaine = utf8_encode($chaine);
1025                }*/
1026                       
1027                if(is_object($this)){
1028                        $chaine=$this->ISO_646_5426_encode($chaine);
1029                }else{
1030                        $chaine=iso2709_record::ISO_646_5426_encode($chaine);
1031                }
1032                return $chaine;
1033        }
1034}
1035
1036
1037} # fin déclaration
1038
1039?>
Note: See TracBrowser for help on using the repository browser.