Par - Page 1

Par



Syntax        par [options] [archive à traiter] [liste de fichiers]



Options

-a,--add
        Ajoute les fichiers à l'archive. Crée l'archive si elle n'existe pas.
        Si l'archive existe en flash, elle est désarchivée et réarchivée à la fin.
        Défaut:
        - N'enregistre pas le chemin absolu des fichiers.
        - Si un fichier du même nom existe dans l'archive, renvoie une erreur.


-e,--extract
        Désarchive les fichiers spécifiés dans la liste.
        Défaut:
        - Utilise le chemin absolu des fichiers s'il existe dans l'archive, sinon extrait dans le répertoire courant.
        - Désarchive les fichiers spécifiés dans la liste, sinon désarchive tous les fichiers.
        - Si un fichier à désarchiver existe déjà, renvoie une erreur.


-r,--remove
        Détruit les fichiers dans une archive. Désarchive l'archive si elle est en flash et l'y remet à la fin.


-l,--list
        Affiche des informations sur une archive et sur les fichiers contenus.
        Défaut: affiche les informations de tous les fichiers (nom, taille, type), sauf si une liste est spécifiée.


-f,--flash
        Si on crée une archive, elle est mise en flash à la fin de l'opération.
        Si on extrait des fichiers, ils sont mis en flash au fur et à mesure.


-s,--save-path
        Enregistre le chemin absolu des fichiers ajoutés à une archive. Si aucun path n'est spécifié pour un fichier,
        le répertoire courant est enregistré.


-d,--dir <fld>
        Extrait les fichiers listés/tous les fichiers dans le répertoire fld, sans tenir compte de l'éventuel chemin
        enregistré. '.' signifie 'répertoire courant'.
        Défaut:
        - renvoie une erreur si le répertoire n'existe pas.


-F,--force
        Ecrase les fichiers dans une archive quand on veut y ajouter un fichier déjà présent.
        Ecrase les fichiers existants quand on désarchive des fichiers.
        Crée automatiquement le répertoire fld de l'option -d si le répertoire n'existe pas.


-c,--continue
        En cas d'erreur non fatale (fichier existant et pas d'option -f spécifiée, fichier inexistant,
        nom invalide etc...), ignore le fichier et passe au suivant.
        

-v,--verbose
        Mode verbeux sur stdout.
        Défaut:
        - Par ne renvoie que les erreurs sur stderr.


-h,--help
        Affiche une aide sur les différentes options.


Notes
        - Les archives sont créées en RAM.
        - Les fichiers sont extraits en RAM.
        - Les fichiers sont ajoutés dans une archive sans information de path.
        - Les fichiers sont extraits en utilisant l'information de path si elle existe, sinon dans le répertoire courant.
        - Si --add/--extract/--remove/--list sont spécifiés, le dernier switch passé est utilisé, les autres ignorés.
        - Si des options incohérentes sont spécifiées (par exemple, --force quand on liste une archive), elles sont ignorées silencieusement.

Folco (./1) :
ps -> Je voudrais que Par signifie "PedroM Archiver". J'avais déjà fait ça pour Pexec, avant de me poser une question : quid d'utiliser un nom de programme dont je ne possède pas le copyright dans le mien ? PpHd saura sûrement me répondre. C'est en fait pour ça que j'avais renommé Pexec en EExec, même si PpHd n'avait rien dit... bref je ne veux pas faire de pas de travers niveau droit/license/toussa.

Folco (./9) :
Merci beaucoup C'est juste que c'est normal que je demande. Et t'as pas forcément envie de voir le premier soft en script qui additionne deux entiers s'affubler de "PedroM Advanced Mathematics Ingeneering Tool Suite".

Folco (./9) :
Puis comme disait un célèbre auteur contemporain : topics/32855-romcall-mem/3#84

Folco (./9) :
A propos PpHd, des critiques ?

PpHd (./10) :
Oué, les options longues servent à rien (trop long pour ti)

PpHd (./10) :
et même pour les options courtes j’enlèverai le '-' pour que ca soit plus court à taper.

;==============================================================================
;       Registers usage:
;       a2      callback
;       a3      switchlist (current)
;       d3      #opt / misc
;
;       Offset of args in the stack :
FRAME_BASE      equ     4+4*4            ; 4 registers saved + return address
CMDLINE         equ     0+FRAME_BASE
DATA_PTR        equ     4+FRAME_BASE
SWITCHLIST      equ     8+FRAME_BASE
CALLBACK        equ     12+FRAME_BASE
SWITCHFUNC      equ     16+FRAME_BASE
;==============================================================================

pdtlib@0002:
    ;-----------------------------------------------
    ;    Check if an arg remains
    ;-----------------------------------------------
        movem.l d3-d4/a2-a3,-(sp)
        movea.l CALLBACK(sp),a2                         ; Callback : a2
\Loop:    movea.l CMDLINE(sp),a0                          ; CMDLINE*
        bsr.s   pdtlib@000A                             ; Get next arg
        move.l  a0,d0
        bne.s   \StillArgs
                moveq.l #PDTLIB_END_OF_PARSING,d0       ; No more arg, quit
\Quit:          movem.l (sp)+,d3-d4/a2-a3
                rts

    ;-----------------------------------------------
    ;    Check if it is a long or a short switch
    ;-----------------------------------------------
\StillArgs:
    movea.l    SWITCHLIST(sp),a3
    moveq.l    #-4,d3
    cmpi.b    #'-',(a0)
    bne.s    \NoMinus
        cmpi.b    #'-',1(a0)
        beq.s    \LongSwitch
        bra.s    \ShortSwitch
\NoMinus:
    cmpi.b    #'+',(a0)
    beq.s    \Plus
        ;-----------------------------------------------
        ;    Not a switch, inform the program
        ;-----------------------------------------------
        moveq.l #PDTLIB_NOT_A_SWITCH,d0
                movea.l DATA_PTR(sp),a0
                jsr     (a2)
                moveq.l #PDTLIB_NOT_A_SWITCH,d1
\TestCallbackReturn:
                subq.w  #PDTLIB_STOP,d0                 ; Continue or stop, depending on
                bne.s   \Loop                           ; callback result
                        move.w  d1,d0
                        bra.s   \Quit
\Plus:    cmpi.b    #'+',1(a0)
    beq.s    \LongSwitch

    ;-----------------------------------------------
    ;    Handle short switch
    ;-----------------------------------------------
\ShortSwitch:
    move.b    (a0)+,d0                ; d0.b: sign
\ShortSwitchLoop:
    addq.w    #4,d3
    move.b    (a3)+,d1
    beq.s    \NoShortSwitch
    cmp.b    (a0),d1
    beq.s    \SwitchFoundNoPop
\NoShortSwitch:
    tst.b    (a3)+                    ; CHECK THAT FOR #0 AT END OF TABLE !
    bne.s    \NoShortSwitch
    tst.b    (a3)
    bne.s    \ShortSwitchLoop
    tst.b    1(a3)
    bne.s    \ShortSwitchLoop

    ;-----------------------------------------------
    ;    Switch doesn't exist
    ;-----------------------------------------------
\InvalidSwitch:
        moveq.l #PDTLIB_INVALID_SWITCH,d0
        movea.l DATA_PTR(sp),a0
        jsr     (a2)
        moveq.l #PDTLIB_INVALID_SWITCH,d1
        bra.s   \TestCallbackReturn

    ;-----------------------------------------------
    ;    Handle long switch
    ;-----------------------------------------------
\LongSwitch:
    move.b    (a0),d4                    ; d4.b: sign
    pea    2(a0)
\LongSwitchLoop:
    addq.l    #1,a3                    ; Skip short switch
    addq.w    #4,d3
    move.l    (sp),-(sp)
    pea    (a3)
    ROMC    strcmp
    addq.l    #8,sp
    tst.w    d0
    beq.s    \SwitchFound
\SkipSwitch:
    tst.b    (a3)+
    bne.s    \SkipSwitch
    tst.b    (a3)
    bne.s    \LongSwitchLoop
    tst.b    1(a3)
    beq.s    \InvalidSwitch
    bra.s    \LongSwitchLoop

    ;-----------------------------------------------
    ;    Switch is found, execute its routine
    ;-----------------------------------------------
\SwitchFound:
        movea.l (sp)+,a0
    move.b    d4,d0
\SwitchFoundNoPop:
        movea.l SWITCHFUNC(sp,d3.w),a1
        move.l  DATA_PTR(sp),a0
        jsr     (a1)
        moveq.l #PDTLIB_SWITCH_OK,d0
        move.l  DATA_PTR(sp),a0
        jsr     (a2)
        moveq.l #PDTLIB_SWITCH_OK,d1
        bra.s   \TestCallbackReturn

Folco (./5) :
Ah ben tu poses une très bonne question au contraire, je voulais en parler mais j'ai oublié. Là j'ai du taf à faire dans la maison, mais j'ai un début d'API pour que le programme puisse être utilisé comme backend d'un GUI, c'est prévu.

Sasume (./12) :
cf blogs/blog.php?id=109&i=127 , une architecture comme la propose GC est plus légère, j’espère que ce sera possible avec ton prog

Sasume (./12) :
./11> De l’ASM et le C alors ?

PDTLIB_MSG pdtlib__ManageCmdline (CMDLINE* CmdLine, void* Data, const char* SwitchList, PDTLIB_MSG (*Callback)(void* Data asm("%a0"), PDTLIB_MSG Message asm("%d0")),
                                  void (*SwitchFunc)(void* Data asm ("%a0"), char Sign asm ("%d0")), ...) __attribute__((stkparm));

Folco (./13) :
Comme dit PpHd, on est quand même sur TI, ça ferait chier de proposer une lib et un programme, alors qu'un programme kernel peut-être considéré comme une lib. Le tout est de bien choisir les points d'entrée, et de minimiser les wrappers nécessaires autour des exports pour que le programme soit appelé en tant que librairie commodément, en alourdissant au minimum le programme.
Qu'en penses-tu ?

Tu parles pour quoi, pour les tabs ou pour le programme ?

Sasume (./12) :
./11> De l’ASM et le C alors ?

Folco (./11) :
Et tu fais comment pour différencier un fichier d'une option ?
Ou alors -xlkjsdfjherterqmsdflkjg façon tar ? C'est juste imbitable, mais bon

	pea	SwitchFolder(pc)
	pea	SwitchSavePath(pc)
	pea	SwitchFlash(pc)
	pea	SwitchRemove(pc)
	pea	SwitchList(pc)
	pea	SwitchUnarc(pc)
	pea	SwitchArc(pc)
	pea	SwitchCallback(pc)
	pea	StrSwitches(pc)
	clr.l	-(sp)						; a6 is used as global frame pointer, I don't need &Data
	pea	CMDLINE(a6)
	jsr	MANAGE_CMDLINE(a6)

SwitchRemove:
    move.w    #REMOVE,TASK(a6)
    moveq.l    #PDTLIB_CONTINUE,d0
    rts

SwitchFlash:
    bset.b    #FLAG_FLASH,FLAGS(a6)
    moveq.l    #PDTLIB_CONTINUE,d0
    rts

SwitchSavePath:
    bset.b    #FLAG_SAVE_PATH,FLAGS(a6)
    moveq.l    #PDTLIB_CONTINUE,d0
    rts

...

SwitchCallback:
    cmpi.w    #PDTLIB_INVALID_SWITCH,d0
    bne.s    \NotInvalidSwitch

    ;---------------------------------------------------------------
    ;    Switch doesn't exist
    ;---------------------------------------------------------------
        move.w    #ERROR_INVALID_SWITCH,ERROR(a6)
        lea    CMDLINE(a6),a0
        jsr    GET_CURRENT_ARG_PTR(a6)
        pea    (a0)
        pea    StrErrorInvalidSwitch(pc)
\QuitError:    bsr    Print2Stderr
        addq.l    #8,sp
        moveq.l    #PDTLIB_STOP,d0
        rts
\NotInvalidSwitch:
    cmpi.w    #PDTLIB_NOT_A_SWITCH,d0
    bne.s    \NotNotASwitch

...

	;---------------------------------------------------------------
	;	Else it is PDTLIB_SWITCH_OK, all is fine
	;---------------------------------------------------------------
\NotNotASwitch:
	moveq.l	#PDTLIB_CONTINUE,d0
	rts

PpHd (./16) :
Il faut différencier les actions / opérations principales des autres options.

Folco (./20) :

Tu pux préciser stp ? Un truc du genre :
:> par fcv -a

Pour créer une archive (-a) de deux fichiers, la mettre en flash (f) en ignorant les erreurs (c) en mode verbeux (v)

Folco (./21) :
L'emmerdement dans ce que je te propose PpHd, c'est que c'est dur d'en faire quelque chose de standard sous PedroM : en effet, les softs ne sont pas obligés d'accéder à la ligne de commande de cette manière : il peut très bien ne pas y avoir d'arguments compactés, ni de commande (pas une simple option quoi).

Avec ma lib, je voulais proposer un standard sous PedroM. Si ça ne te va pas, j'aimerais bien que tu en définisses un, je me ferai un plaisir de l'implémenter et de l'utiliser.

PpHd (./22) :
Oué. Sur TI, le clavier n'est pas super pratique. Surtout pour 89.

PpHd (./22) :
Ben le mieux serait que tu fasses des Pack Archive avec ce soft.

PpHd (./22) :
Et perso, je ferrai plutôt une interface autre que vis system("par ...") pour les softs mais directement en exportant dans par les fonctions nécessaires pour l'utiliser directement.

PpHd (./22) :
Dans ce cas, les programmes (pour extraire) peuvent utiliser les fonctions du kernel existantes, et il ira utiliser par.

Folco (./23) :
Ca nécessite donc d'utiliser zpack et zunpack. Ces programmes embarquent printf de tigcclib, c'est dommage sous PedroM où tu t'es amusé à faire une libc, d'autant plus qu'on perd stderr. Et on perd également l'exécution en archive, bref, on perd tous les avantages sur lesquels j'appuie pour les programmes dédiés à PedroM, je trouve ça dommage. Qui plus est, si on veut garder une compatibilité AMS (vu que les PA, zpack et zunpack le sont), il faut parser la ligne de commande avec les fontions de l'estack, donc on perd encore le main(int argc, const char** argv) spécifique à PedroM, et si commode. Je trouve que ça fait beaucoup de sacrifices, à moins de réimplémenter des fonctions zpack et zunpack dédiées à PedroM (entre autres en utilisant la lib système).

Folco (./23) :
Je reste dans la situation où c'est une lib qui gère la ligne de commande : Est-ce que le programme va processer le fichier fcv, ou y a-t-il une commande derrière, auquel cas fcv sont des flags ? Et l'utilisateur peut de toutes façon avoir besoin de préfixer plusieurs options avec -, dans le cas où ses options demande des arguments (-i/--include, -f/--folder etc...).

Folco (./23) :
Je suis un peu perplexe. En plus, à moins de rajouter un fichier d'information spécifique à Par dans le pack archive, on perd l'outil d'enregistrement/restauration de path prévu pour Par. J'ai fait ça avec dans l'idée qu'après un crash ou une fausse manip, on peut remettre sa cals d'aplomb avec un simple appel à Par, en mode --force pour écraser ce qui peut avoir été corrompu (un fichier de configuration dans /system mal modifié par l'utilisateur, et qui fait merde un soft par exemple). En clair, je ne vois pas à quoi sert Par s'il suffit tout simplement d'utiliser zpack et zunpack qui existent déjà.

PpHd (./25) :
Là j'avoue que je ne comprends pas pourquoi tu me parles de zpack/zunpack.

PpHd (./25) :
A toi de voir quel est le mieux. N'oublie pas la cible finale.

API

unsigned short par__ArchiveFile (const char* Archive, unsigned short Flags, const char* Folder, const char* File1, ...);
unsigned short par__ExtractFile (const char* Archive, unsigned short Flags, const char* Folder, const char* File1, ...);
unsigned short par__Remove      (const char* Archive, const char* File1, ...);
unsigned short par__List        (const char* Archive, const char* File1, ...);

PpHd (./28) :
Par exemple pour extraire une archive sans savoir quels sont les fichiers dedans on fait comment ?

PpHd (./28) :
C'est quoi les valeurs retours retournées ?

; header
ds.b 2 -> code d'erreur
ds.b (strlen(str)) -> chaine d'erreur (word null si pas d'erreur)

; Pour list, on rajoute :
ds.b 2 -> nombre de fichiers

; Puis une partie dynamique :
ds.b 18 -> Nom du fichier (c-string)
ds.b 2 -> taille du fichier
ds.b 1 -> type
ds.b 1 -> <padding>
etc...
dc.w 0 -> fin de la liste.

HANDLE par__ArchiveFiles (const char* Archive, unsigned short Flags, void (*Callback) (const char* Str), const char* Folder, const char* File1, ...);
HANDLE par__ExtractFiles (const char* Archive, unsigned short Flags, void (*Callback) (const char* Str), const char* Folder, const char* File1, ...);
HANDLE par__Remove (const char* Archive, void (*Callback) (const char* Str), const char* File1, ...);
HANDLE par__List (const char* Archive, void (*Callback) (const char* Str), const char* File1, ...);

unsigned short par__ArchiveFile(const char *Archive, unsigned short Flags, const char *Folder, const char *File);
unsigned short par__ExtractFile(const char *Archive, unsigned short Flags, const char *Folder, const char *File);
unsigned short par__Remove(const char *Archive, const char *File);