SCCS : source code control system

8.5 SCCS : source code control system

Gestionnaire de versions de fichiers
Regroupe divers utilitaires
Fonctions :
- Historique des versions
  
  Enregistre les différentes versions
  
  Quels changements, pourquoi, par qui, quand
  
  Informations gardées dans un ``s-file''
- Vérouillage des fichiers édités
  
  Þ développement par plusieurs persones
Outils standard Unix : SCCS

Il existe aussi
- RCS : produit GNU, fonctionnalite identique à SCCS
- CVS : Concurrent Versions System

Opérations de base

Get: -- Récupérer un fichier pour compilation (pas d'édition)

Récupère une version d'un fichier depuis un s-file

Par défaut, la dernière version

Pas de changement du fichier possible (droit r--)
Edit: -- Récupérer une version pour édition

But : éditer le fichier puis enregistrer les modifications dans le s-file

Récupère une version d'un fichier depuis un s-file

Par défaut, la dernière version

Une seule personne peut éditer un fichier à un instant donné
(garanti par SCCS)
Put: -- Enregitrer les modifications dans le s-file

Un nouveau numéro de version est généré

Un commentaire doit être ajouté pour expliquer la modification

Terminologie

S-file

C'est un fichier unique qui conserve :

Toutes les versions d'un des fichiers utilisateur

(seules les différences sont stockées Þ gain de place)
Les informations complémentaires

Commentaires, date...

Il est stocké dans un sous-répertoire (par défault SCCS)

Son nom est s.filename

Delta

C'est l'ensemble des changements d'une version à l'autre

Le s-file contient l'ensemble des deltas

SID

SCCS Id

Nombre qui représente un delta

Généralement 2 niveaux : release.level

Mots clés

Identification d'un fichier

Lors d'un get (Þ compilation/installation)

Mots clés sont expansés par SCCS

Exemple : numéro de versions...

Mots clés de la forme %x%, par exemple :

`%I%`	SID du dernier delta appliqué
`%Z%`	Marque `@(#)`, utilisée par la commande `what`
`%W%`	Nom du module + SID + date
`%G%`	Date du dernier delta appliqué

Création de fichiers SCCS

Csh shell script :

% mkdir SCCS save
% foreach file (*.[ch])
    sccs admin -i$file $file
    mv $file save/$file
  end

Crée les s-file associés aux fichiers précisés
Détruit les fichiers (sauvegarde dans save, au cas où...)
Si l'on veut des mots clés dans les fichiers, mieux vaut le faire avant de créer les s-file

Récupérer les fichiers pour la compilation

Pour obtenir une copie de la dernière version :

sccs get prog.c

SCCS répond

1.1
87 lines

La version 1.1 a été récupérée, elle contient 87 lignes
Le fichier prog.c a été créé dans le répertoire courant
Droits = lecture seulement

Modifier les fichiers

Demander une copie pour l'édition :

sccs edit prog.c

sccs get -e prog.c

Réponse idem à get, en plus :
```
New delta 1.2
        
```
Édition du fichier
```
emacs prog.c
        
```

Enregistrer les changements dans le s-file

Une fois les changements réalisés dans le fichier
Enregistrer les changements dans SCCS
```
sccs delta prog.c
        
```
Cette commande demande interactivement le commentaire à insérer avec le delta dans le s-file

Et affiche

1.2 
5 inserted
3 deleted
84 unchanged

Le fichier prog.c peut maintenant être détruit

Il sera reconstruit par un sccs get si nécessaire

Quand réaliser un delta ?

Pas avant qu'une compilation et un test aient été effectués
Exemple d'utilisation :
- Get tous les sources
- Edit les sources nécessaires
- Réalisation de changements, tests, compilation
  
  Jusqu'à obtention du résultat voulu
- Delta de tout ce qui a été édité
- Re-get tous ce qui a été édité
- Recompilation totale

Information

Trouver tous ce qui est en cours d'édition :
```
sccc info 
        
```
Affiche nom du fichier, version, nom utilisateur, date...
La commande
```
sccs check
        
```
retourne une valeur non-nulle si une édition a lieu

Þ utilisation dans un script

Par exemple abandonner une installation si tout n'a pas été correctement passé par delta
Si tout ce qui a été édité doit être passé à delta :
```
sccs delta `sccs tell`
        
```

Option -u [user-name]

sccs -u marquet  info 
sccs -u check 
sccs -u $USER tell

Les mots-clés SCCS

Les mots-clés insérés dans les fichiers sont expansés par get

Exemple

static char SccsId[] = "%W%, %G%" ;

sera remplacé par

static char SccsId[] = "@(#)prog.c 1.2, 01/20/94" ;

La commande what

sccs what prog.c ../usr/bin/prog

retrouve le @(#) et imprime

prog.c:
        prog.c  1.2       01/20/94
../usr/bin/prog
        prog.c  1.1       01/12/94

L'exécutable est donc antérieure à la dernière version

Pour ce faire, le @(#) doit apparaître dans l'exécutable

Donc dans une chaîne de caractères déclarée statique
Pour les fichiers d'entête (.h) ® dans un commentaire

Projets multifichiers

Mettre à jour simultanément tous les fichiers d'une application
Éditer tous les fichiers
```
sccs edit SCCS
        
```
Une fois les modifications effectuées
Faire un delta sur tous ces fichiers
```
sccs delta SCCS
        
```
Un commentaire unique pour tous les fichiers

Une nouvelle release

Option -r
```
sccs edit -r2 prog.c 
        
```
La nouvelle version sera numérotée 2.1
Pour tous les fichiers
```
sccs edit -r2 SCCS
        
```

Les anciennes versions

Option -r
```
sccs get -r1.2 prog.c 
        
```
Option -c
```
sccs get -c940119120000 prog.c 
        
```
La version courante au 94/01/19 à 12:00:00

SCCS et `make`

Entrées du Makefile
- all Tout reconstruire
- sources Contruire tous les sources à partir des fichiers SCCS
- clean Détruire tout ce qui peut être reconstruit
```
sccs clean
            
```
  Détruit tous les fichiers pour lesquels un s-file existe
- etc.

Maintenir un simple programme

LDFLAGS= -s -i 

prog: prog.o 
        $(CC) $(LDFLAGS) -o prog prog.o 
prog.o: prog.c prog.h 

exmpl: exmpl.o 
        $(CC) $(LDFLAGS) -o exmpl exmpl.o 
exmpl.o: exmpl.c 

.DEFAULT:
        sccs get $<

Si un fichier n'existe pas, la dernière règle est appliquée

On tente de le construire à partir d'un fichier SCCS

Autre possibilité

SRCS= prog.c prog.h exmpl.c
LDFLAGS= -s -i 

prog: prog.o 
        $(CC) $(LDFLAGS) -o prog prog.o 
prog.o: prog.h 

exmpl: exmpl.o 
        $(CC) $(LDFLAGS) -o exmpl exmpl.o 

sources: $(SRCS)
$(SRCS):
        sccs get $@

Avantages :

Pas de dépendances explicites entre le .o et le .c
Il existe une entrée sources
Le Makefile ne tentera pas de faire des get sur des fichiers inexistants

Le suffixe ~

Les fichiers SCCS n'ont pas de suffixe particulier

Mais un préfixe (SCCS/s.)

Convention dans make : le suffixe ~ désigne le s-file

Règles par défaut
```
.c~.o:
        $(GET) $(GFLAGS) $<
        $(CC) $(CFLAGS) -c $*.c
        -$(RM) -f $*.c
        
```