Journal Taptempo en COBOL

Posté par . Licence CC by-sa.
Tags :
39
21
mar.
2018

Après tous les exemples réalisés dans une multitude de langages, en voila en COBOL.
J'ai utilisé GnuCOBOL, car j'ai pas de z/OS ou d'AS400 sous la main. Et j'ai pu utilisé la libc pour le gettimeofday. De plus GnuCOBOL ajoute quelque spécificités, en particulier sur le verbe ACCEPT.

             ******************************************************************
            * author/copyright goernil
            * date: 20/03/2018
            * this program is free software. it comes without any warranty, to
            * the extent permitted by applicable law. you can redistribute it
            * and/or modify it under the terms of the do what the fuck you
            * want to public license, version 2, as published by sam hocevar.
            * see http://www.wtfpl.net/ for more details.
            *
            * purpose: calculate tempo
            * tectonics: cobc
            ******************************************************************
            *
            identification division.
            program-id. taptempo.
            data division.
            file section.
            working-storage section.
                01 ws-timeval-64bit.
                    02 ws-seconds       pic x(8) comp-5.
                    02 ws-microseconds  pic x(8) comp-5.
                77 ws-tzp usage pointer value null.
                77 ws-ms-since-epoch    pic 9(18) display.

                01 ws-entree-clavier    pic x(80).

                01 ws-stockage-tap.
                    05 ws-tap pic 9(18) display occurs 100.
                01 ws-precision         pic 9(20) value 6.
                01 ws-precision-disp    pic z9.
                01 ws-i                 pic 9(3).
                01 ws-j                 pic 9(3).
                01 ws-tempo             pic z(8)9.
                01 ws-tap-moy-s         pic 9(9)v9(9).
                01 ws-nb-args           pic 9(9).
                01 ws-args.
                    03 ws-tab-arg occurs 2048.
                    05 ws-arg               pic x(20). 
                    05 ws-arg-num redefines ws-arg pic 9(20). 
                01 ws-max-nb-args       pic 9(9) values 2048.
                01 ws-arg-i             pic 9(9).

            procedure division.
            main-procedure.

                perform lecture-arguments.

                display 'Appuyer sur la touche entrée en cadence. '
                        'Le premier ne compte pas.'
                            '(q pour quitter)'
                accept ws-entree-clavier

                move 0  to ws-i

                perform until   ws-entree-clavier = 'q'
                    accept ws-entree-clavier
                    perform gettimeofday
                    if ws-i < ws-precision  
                    then
                        add 1 to ws-i
                        move ws-ms-since-epoch to ws-tap (ws-i)
                    else
                        perform pushtap
                    end-if

                    if ws-i = ws-precision  
                        compute ws-tap-moy-s =  ( ws-tap (ws-i) - ws-tap(1) )
                                        /  (ws-precision - 1)
                                        / 1000
                        compute ws-tempo = 1 / ws-tap-moy-s * 60
                        if ws-entree-clavier <> 'q'
                            display 'tempo : ' ws-tempo ':'
                        end-if
                        end-if
                end-perform

                perform endprogram           
                stop run.

            lecture-arguments.
                accept ws-nb-args from argument-number

                Perform until ws-arg-i = ws-nb-args
                    add 1 to ws-arg-i
                    accept ws-arg(ws-arg-i) FROM ARGUMENT-VALUE
                    evaluate  ws-arg(ws-arg-i)
                        when '-h'
                            perform display-help
                            perform endprogram
                        when '-s'
                            accept ws-precision  FROM ARGUMENT-VALUE
                            add 1 to ws-arg-i
                            move   ws-precision  to ws-arg(ws-arg-i)
                            if ws-precision <> 0
                                and ws-precision > 1
                                and ws-precision < 100
                            then 
                                move ws-precision to ws-precision-disp 
                                display 'la précision est ' 
                                        ws-precision-disp 
                                ' échantillons(s)'
                            else
                                display '-s usage : Doit être numerique '
                                    'et entre 2 et 99. Valeur par défault 6.'
                                perform endprogram    
                            end-if
                        when other
                            display 'Wrong args'
                            perform display-help
                            perform endprogram
                    end-evaluate
                end-perform
                continue.

            display-help.
                display 'Usage: taptempo '
                display '[-s samples]'
                continue.

            gettimeofday.
                call "gettimeofday" using
                    by reference ws-timeval-64bit
                    by value ws-tzp
                end-call
                compute ws-ms-since-epoch = ws-seconds * 1000
                        + ws-microseconds / 1000
                continue.

            pushtap.
                perform varying ws-j from 1 by 1 until ws-j = ws-i
                    move ws-tap (ws-j + 1) to ws-tap (ws-j)
                end-perform
                move ws-ms-since-epoch to ws-tap (ws-i)
                continue.

            endprogram.
                stop run
                continue.

            end program taptempo.
  • # Tiens !

    Posté par (page perso) . Évalué à 10.

    C'est la première fois que je lis du Cobol.
    En dehors des déclarations qui me paraissent un peu ésotériques, je trouve que c'est à la fois verbeux, anglocentré, et clair.
    Pas si mal que ça à vue de nez, même si ça fait bizarre de voire une convention explicite d'évaluation et d'appel de fonction…
    Merci d'avoir posté ça !

    Au fait, tu as utilisé Cobol professionnellement, ou tu l'as appris pour le portage¹ de TapTempo ? T'en penses quoi ?

    ¹: Enfin, t'as oublié la doc, les options, la localisation…

    • [^] # Re: Tiens !

      Posté par . Évalué à 3.

      Oui j'en fait de manière professionnel principalement sur z/OS et un peu As400. De mon point de vue, c'est très efficace pour faire de l'informatique de gestion (gérer des contrats, de la compta, des référentiels de personnes…) sur la partie traitement des bases de données aussi bien pour le transactionnel aque pour le traitement par lot. En tant que langage, son âge se fait sentir, surtout après avoir utilisé du langage objet. Mais c'est vrai que la lecture est assez simple.

      Si j'ai géré les options , on peut choisir le nombre d'échantillons. Pour la localisation c'est pas prévu dans le standard Cobol, sauf erreur de ma part. Ou alors il aurait fallu que je passe par gettext, mais la flemme.

    • [^] # Re: Tiens !

      Posté par (page perso) . Évalué à 5.

      J’avais déjà vu du COBOL, mais c’était toujours écrit en majuscules, et c’est la première fois que j’en vois en minuscules ! Il y a eu des évolutions dans le langage, ou c’était juste une convention ?

      • [^] # Re: Tiens !

        Posté par (page perso) . Évalué à 3.

        Il y a eu une évolution, mais il y a longtemps il me semble. Mais la convention est resté à beaucoup d'endroit.

        « Rappelez-vous toujours que si la Gestapo avait les moyens de vous faire parler, les politiciens ont, eux, les moyens de vous faire taire. » Coluche

  • # Assembleur

    Posté par (page perso) . Évalué à 3.

    C'est moi ou le COBOL ressemble fortement à une très fine surcouche au dessus de l'assembleur?

    • [^] # Re: Assembleur

      Posté par . Évalué à 6.

      Il y'a de ça, en particulier sur les instructions de base (Move, perform, if …) . Après le standard cobol 2002 introduit plein de truc géniaux comme l'orienté objet, un parseur XML, etc…

  • # Un peu plus velu

    Posté par . Évalué à 7. Dernière modification le 21/03/18 à 22:04.

    Si ça t'intéresse il y a le code source de la calculette des alloc qui est dispo … en cobol :
    https://www.nextinpact.com/news/106298-les-allocations-familales-nous-ouvrent-code-source-leur-calculateur-daides.htm

    Attention, suivant les entête des routines, Stéphanie de Monaco et un artichaut ont participés à l'écriture des programmes ^^'

    • [^] # Re: Un peu plus velu

      Posté par . Évalué à 1.

      52 fichiers dans 2 dossiers pour 534 Mo soit environ 6,9 millions de ligne de codes…

      Velu, c'est le mot.

      • [^] # Re: Un peu plus velu

        Posté par (page perso) . Évalué à 4.

        Des fichiers sources de plus de 100 000 lignes o_O

        Rassurez-moi, les gens ne travaillent pas directement dans ces fichiers ? Il y a un préprocesseur qui a concaténé plein de fichiers en un, non ?

        En plein milieu du code on semble voir des changelogs et des commentaires du style :

          *END_OF_COPY_FILE                                                 CGPACKWK
          *    COPY  CGRDRCWK.                                              
          *COPY"/distrib/appli/cristal/05200/ref/cobol/copy/CGRDRCWK.CPY"   CGRDRCWK
        
        • [^] # Re: Un peu plus velu

          Posté par (page perso) . Évalué à 2. Dernière modification le 25/03/18 à 12:50.

          Oui ça a été confirmé dans les commentaires par deux des développeurs

          ce qui fait que nextinpact a demandé par après à avoir une copie du vrais code source, pas du code généré

  • # Variables

    Posté par (page perso) . Évalué à 5.

    Une nouvelle version de TapTempo, super !

    Que représente le working-storage section avec sa syntaxe étonnante `01 ws-tap-moy-s pic 9(9)v9(9).̀  ?
    Est-ce la déclaration des variables du programme ?

    • [^] # Re: Variables

      Posté par . Évalué à 8.

      Un source cobol est divisé en plusieurs division divisé en section.

      La working est la zone où on déclare les variables.

      les explications
      01 c'est pour indiquer le niveau dans la structure de données. 01 c'est la base.
      Ws-tap-moy-s c'est son petit nom.
      pic est un diminutif de picture. Ca indique que la variable décrit une zone d'un certain format.

      9(9)V9(9) indique que la zone contient un nombre composé au maximun de 9 chiffres avant la virgule et 9 chiffre après.

      • [^] # Re: Variables

        Posté par (page perso) . Évalué à 1.

        Merci pour cette formation rapide :-)

      • [^] # Re: Variables

        Posté par . Évalué à 2.

        C'est pas mal du tout de pouvoir préciser le nombre de chiffres avant et après la virgule ! Je ne crois pas avoir vu ça dans d'autres langages à part peut-être Ada.

        Est-ce que ce nombre de chiffre est compté sur la version décimale du nombre ?
        Est-ce que les variables sont stockés sous forme de nombres flottants, ou ce sont des entiers avec virgule ?

        • [^] # Re: Variables

          Posté par (page perso) . Évalué à 2.

          Je ne crois pas avoir vu ça dans d'autres langages à part peut-être Ada.

          Exact, tu n'as pas rêvé. D'après le Wikibook, les types décimaux à point fixe ont justement été créés pour refléter ce qui se fait en Cobol.
          Par contre, il faut faire attention à l'arithmétique associée.

        • [^] # Re: Variables

          Posté par . Évalué à 3.

          Lorsqu'on déclare un nombre en 9(9)V9(3), le nombre est stocké en ascii. par ex 132.5 sera stocké 000000132.500. Pour déclarer un int comme en C, il faut ajouté le mot COMP (computational).

          L'énorme avantage de stocker les nombres de cette manière, c'est que les calculs sont exacts et les arrondis gérés, ce qui est vital en informatique de gestion.

          • [^] # Re: Variables

            Posté par . Évalué à 1.

            Merci pour l'explication !

            Ada a effectivement un support facilement utilisable.

            Python aussi, mais ça a l'air un peu plus complexe à utiliser, via le module decimal.

  • # Style du code

    Posté par (page perso) . Évalué à 7.

    ÇA MANQUE DE CAPS LOCK POUR DU COBOL.

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.