C : traitements pas lot, batch, boucle for du dos,... (avec contrôle des extensions)


Télécharger le projet
Commenter

Description

Pas compliqué mais permet d'accélérer les traitements par lot (assez lents..) du DOS/NT

Permet d'effectuer une ou plusieurs commandes sur un ou plusieurs fichiers
Permet aussi de n'accepter que certaines extensions

Utile dans les scripts BASH (Linux) ou les fichiers de traitements par lot (.BAT) sous DOS/NT

syntaxe :
---------

com [-f] COMMANDE [-f] SOURCE [ [-f] EXT ]

-f => indique un fichier et non une chaîne de caractères

Dans COMMANDE :
[N] => n° d'ordre dans le fichier source

[FE] => le fichier
[F] => le fichier - l'ext
[E] => l'ext

annuler par \ ( ex : \[FE] )

ex d'utilisation :
------------------

1)
#!/bin/bash

ls > /tmp/tempo1.src
echo echo working on [FE]...>/tmp/tempo1.com
echo wma2wav [FE]>>/tmp/tempo1.com
echo lame [F].wav>>/tmp/tempo1.com
echo rm [F].wav>>/tmp/tempo1.com
echo echo [FE] converted!>>/tmp/tempo1.com

/home/niki/com -f /tmp/tempo1.com -f /tmp/tempo1.src "wma"

rm /tmp/tempo1.*

2)
@echo off
dir /B>c:\tempo1.src
c:\docs\perso\com "c:\program files\lame\lame.exe [FE]" -f c:\tempo1.src "wav"

Source / Exemple : 


/*
   com [-f] COMMANDE [-f] SOURCE [ [-f] EXT ]
   -f   => indique un fichier et non une chaîne de caractères
   
   Dans COMMANDE :
   [N]  => n° d'ordre dans le fichier source
   
   [FE] => le fichier
   [F]  => le fichier - l'ext
   [E]  => l'ext
   
   annuler par \ ( => \[FE] )


  • /


#include "fct_string.h"
#include "fct_file.h"

#define FICHIER 0
#define COMMANDE 1

void error_mes();
int sys_call(char **commande, char **fichiers, char **extension);

void main (int argc, char *arg[])
{
 int i, next, paramc=0;
 char ***param=0;
 
 for (i=1, next=COMMANDE ; i<argc ; i++)
     {
           if (!(compare(arg[i], "-f")))
              next=FICHIER;
           else
           {
               param=(char ***)realloc(param,(paramc+1)*sizeof(char ***));
               if (next==COMMANDE)
               {
                                  param[paramc]=(char **)malloc(2*sizeof(char **));
                                  param[paramc][0]=copy(arg[i]);
                                  param[paramc][1]=0;
               }
               else
                   param[paramc]=file(arg[i]);
               
               paramc++;
               next=COMMANDE;
           }
     }
        
     param=(char ***)realloc(param,(paramc+1)*sizeof(char ***));
     param[paramc]=(char **)malloc(sizeof(char **));
     param[paramc][0]=0;
     
     if (!(paramc<2))
        sys_call(param[0], param[1], param[2]);
     else 
          error_mes();     
}

int sys_call(char **commande, char **fichiers, char **extension)
{
	char *ext_fich, *sansext_fich, *shell;
	int fich, com, num;
	
		for ( fich=0, num=1 ; fichiers[fich] ; fich++)
		{
            if (extension[0]==0 || test_ext(fichiers[fich], extension))
			{
				for (com=0 ; commande[com] ; com++)
				{
                    shell=copy(commande[com]);
    				
                    ext_fich=ext(fichiers[fich]);
    				sansext_fich=sansext(fichiers[fich]);
    				if (ESPACES && fichiers[fich][0]!='\"')
    				{
    					fichiers[fich]=concact("\"",fichiers[fich],"\"",0);
    					sansext_fich=concact("\"",sansext_fich,"\"",0);
    				}
    				
    				shell=replace(shell, "\\\[N]", "ùµ£");
    				shell=replace(shell, "\[N]", i2a(num));
    				shell=replace(shell, "ùµ£", "\[N]");
    				shell=replace(shell, "\\\[FE]", "ùµ£");
    				shell=replace(shell, "\[FE]", fichiers[fich]);
    				shell=replace(shell, "ùµ£", "\[FE]");
    				shell=replace(shell, "\\\[F]", "ùµ£");
    				shell=replace(shell, "\[F]", sansext_fich);
    				shell=replace(shell, "ùµ£", "\[F]");
    				shell=replace(shell, "\\\[E]", "ùµ£");
    				shell=replace(shell, "\[E]", ext_fich);
    				shell=replace(shell, "ùµ£", "\[E]");
    				
    				system(shell);
    				num++;
			}
		}
	}	
}

void error_mes()
{
   printf("\n\n\tcom [-f] COMMANDE [-f] SOURCE [ [-f] EXT ]");
   printf("\n-f   => indique un fichier et non une chaîne de caractères");
   printf("\n");
   printf("\nDans COMMANDE :");
   printf("\n[N]  => n° d'ordre dans le fichier source");
   printf("\n");
   printf("\n[FE] => le fichier");
   printf("\n[F]  => le fichier - l'ext");
   printf("\n[E]  => l'ext");
   printf("\n");
   printf("\nannuler par \\ ( => \\[FE] )");
    
}

Conclusion :


n'essayer pas d'utiliser "ùµ£" (les trois caractères de suite) dans la commande...
c'est légèrement baclé, à ce niveau là... (le programme les remplacerait par "[F]")

PS : c'est moi ou il y a un problème de coloration dans l'affichage du code source sur le site ?
Télécharger le projet

Codes Sources

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (drdd)