ETUDE D'UN ÉDITEUR DE TEXTE ASCII 850-LATIN-I & WINDOWS-1252

1 2 3 4 5 6 7 8 9 10 11 12 13 14

Programmation Pascal

Banjo 5 string

Sitar music inde

Musique & Gammes

Peace and Love

ÉDITEUR EDNUM & EDIT13 1 2 3 4 5 6 7 8 9 10 11 12

ETUDE D'UN ÉDITEUR DE TEXTE ASCII 850-LATIN-I & WINDOWS-1252

Les règlements sont faits pour les médiocres et les indécis; rien de grand ne se fait sans l'imagination,
les hommes sont comme les chiffres, ils n'acquièrent de valeur que par leur position.
Napoléon Bonaparte

Il y a des gens qui vous laissent tomber un pot de fleurs sur la tête d'un cinquième étage et qui vous disent,
je vous offre des roses.
Victor Hugo

Le programme le plus simple qu'on puisse imaginer pour tous les Terriens

Avec turbo pascal for Windows ou Turbo C++ Windows, on peut progammamer un éditeur de teste avec quelques fonctions avec les bibliothèques qu'il son programmes pour faire des éditeurs texte.

Par contre avec Turbo Pascal 7 pour MS-DOS, pour programmer un éditeur de texte, il vous faut programmer toutes les fonctions nécessaires. Le mouvement du curseur de droite à gauche, de haut vers le bas, remonter/descendre une ligne, insérer un caractère, effacer un caractère à Gauche/droite, créer un nouveau fichier, ouvrir un fichier, sauvegarder le fichier, marquer un bloc, coller/copier un bloc, etc.

hello world

On vous explique comme on peut faire un programme simple pour qu'il afficher sur l'écran : « hello world » [1]
Mais on ne vous dit pas comme faire un programme en langage assembleur qui va afficher sur l'écran : « hello world ». Expliquer comme écrire un programme en codage de « bas niveau l'assembleur » [2] ce ne pas très commercial pour vendre des ordinateurs derniers cris, il ne faut pas faire peur au consommateur avec tous ce codes binaire (0 où 1) où hexadecimal (123456789ABCDEF).

Exemple le fameux « hello world » en lagage Pascal, il s'agit de montrer comment afficher sur l'écran les mots « hello world » (ou d'autres phrases). C'est le programme le plus simple qu'ont puisse imaginer.

{1 HELLO WORLD} 
{Programme exemple simple en Turbo Pascal}

Program HelloWorld;
Uses WinCrt;
Begin
   writeln('Hello, world!');
End.

{*2 Le mini-programme simple Assembleur de pascal*}
{*On peut s'écrire en Assembleur de la façon suivante*}

TITLE Program HelloWorld simple de Assembleur 
CODE     SEGMENT
ORG	100H
ASSUME  CS: CODE, DS: CODE

  MOV	DX, OFFSET MESSAGE
  MOV	AH, 9   ;; Chaine d'affichage du DOS
  INT	21H      ;; afficher chaine
  INT	20H      ;; return au DOS

MSSAGE DB  'Hello World', 10, 13,'$'
CODE   ENDS
           END

Au début de l'informatique, dans les années 50, programmer revenait ainsi à écrire de telles suites d'instructions lémentaires. Les langages de programmation les plus proches de ce codage de « bas niveau » sont appelés « langages d'assemblage » ou « Assembleurs ». Programmer dans un tel langage nécessite de connaître l'architecture matérielle de l'ordinateur sur lequel il s'exécutera.

Sur internet vous pouvez trouver beaucoup des « éditeurs de texte » mais c'est difficile de trouverez leur code source détaille des toutes les fonctions comme à été programme.
Le programme source et le programme exécutable sont deux versions numériques (stockées sous forme de bits dans la mémoire) du même algorithme. Le programme source est écrit en langage évolué, alors que le programme exécutable est le résultat de sa compilation.
En général, quand on achète un logiciel dans le commerce, ou ont le publie sur internet, c'est uniquement le programme exécutable (illisible, même pour informaticien) qui est fourni.
Quand le code source est aussi fourni, on parle de « logiciel libre » puisque tout informaticien peut alors lire le programme (à condition qu'il connaisse le langage dans lequel il est écrit) et le modifier s'il le souhaite.

En Turbo Pascal de la version 5,6 où 7 pour le DOS. On peut imaginer : première possibilité, personne à enselle de programmer un « éditeur de teste » complet.
La deuxième possibilité, ceux qu'ils l'on programme un « éditeur de texte » ne veulent pas fournir le code source.

Programmer, ce n'est pas toujours simple il faut penser logiquement, par étapes, envisager toutes les possibilités des actions, demande une grande attention, une grande rigueur. Mais à ces complications s'ajoute encore l'apprentissage d'une syntaxe extrêmement ardue, qui ne supporte pas la moindre faute, à la virgule près.

Pour programmer un « éditeur de texte » cet un travail long et pas facile, mais avant tout, pour étudier l'algorithme d'un éditeur il faut l'avoir dans la tête, et savoir ce que vous allez faire, et ce que l'éditeur va-t-il faire comme commandes, un « éditeur de texte » simple c'est pour écrire du texte brut, mais peut faire de taches supplémentaires, comme un commande pour insérer la date, ou afficher une table d'un verbe où traduire un mot etc.

A l'époque qu'on programme avec le système MS-DOS Turbo Pascal étai le langage idéal pour programmer, de nous jours la programmation MS-DOS et du passe. Maintenant ont programme à « 32 bit ou 64 bit » avec Windows et langage C++ où Delphin etc. mais cet une programmation beaucoup plus extrait et difficile à comprendre et la programmer.

Mais comme les langages de programmation ils vont continuer à évaluer à une grande vitesse bientôt on vous proposera de passer à le 128 bit où 256 bit. Les seul(es) qui serons capables de comprendre et programmer avec ce langages seront « Les Souris Martiennes » seulement elles seront capables de programmer sur des « 128 bit et peut-être 256 bit ou peut-être 512 bit » vous-voyez, l'avenir de petites souris ne se présente pas tout « ROSE » comme certains politiques le disent, mais ont peut l'imaginer plutôt très virtuel à « 3D-bicolore sur 128 bits où à 256 bits ».

Binaire : 1011

1x (2³)	+	0x (2²)	+	1x (2¹)	+	1x (2⁰)
1 x 8	+	0 x 4	+	1 x 2	+	1 x 1	décimal 11
8	+	0	+	2	+	1


Exemple system binaire : 111 = 7  

 
Deux à la puissance : 2⁹    2⁸   2⁷    2⁶   2⁵    2⁴    2³    2²   2¹   2⁰
Resultat décimal    : 512  256  128   64   32    16    8     4    2    1

Pour programmer il faut aussi avoir certaines qualités et le programmeur doit se concentrer sur le problème à résoudre. Avoir beaucoup de patience, pas qu'un programme ne marche pas toujours du premier coup. Il faut avoir de la logique et comprendre ce qui et logique, savoir réfléchir calmement, etc.

Une Histoire vrai : Dans le année 2011, il à un couple de personnes qu'ils vont acheter un ordinateur dans les grandes-surfaces, et lendemain ils le retournent au magassin en se plainant que l'ordinateur ne fonction pas. Alors le vendeur lui demande: es que vous-avez appuyez sur le bouton marche ?
Le client répond : à pas qu'il faut appuyer aussi sur un bouton, alors ce ne pas un ordinateur dernier cri comme disait la PUB !

Programmation structurée

La démarche de conception d'un programme

Concevoir un programme pour résoudre un problème donné, c'est donc suivre la démarche de la figure [1.1].

Figure 1.1: démarche de conception d'un programme

Dans ce schéma, les phases d'Analyse et de Traduction sont des opérations intellectuelles humaines, alors que les phases de compilation et d'exécution sont réalisées automatiquement par la machine. Le programme source et le programme exécutable sont deux versions numériques (stockées sous forme de bits dans la mémoire) du même algorithme.

Le programme source est écrit en langage évolué, alors que le programme exécutable est le résultat de sa compilation. En général, quand on achète un logiciel dans le commerce, c'est uniquement le programme exécutable (illisible, même pour informaticien) qui est fourni. Quand le code source est aussi fourni, on parle de « logiciel libre », puisque tout informaticien peut alors lire le programme (à condition qu'il connaisse le langage dans lequel il est écrit) et le modifier s'il le souhaite.

Une erreur syntaxique est une faute d'écriture (l'équivalent d'une faute d'orthographe ou de grammaire en français); elle est signalée par le compilateur quand celui-ci ne sait pas comment interpréter certaines instructions du programme source afin de les traduire dans le langage cible (Assembleur). Ces erreurs, quasiment inévitables même par les programmeurs expérimentés, proviennent d'un non respect des préconisations (draconiennes !) du langage de haut niveau utilisé pour le programme source.

Par exemple, oublier de commencer un programme par BEGIN, oublier de le terminer par END ou ne pas séparer deux instructions élémentaires en Pascal par le symbole « ; » constituent des fautes de syntaxe.

Une erreur sémantique, beaucoup plus grave, provient d'une mauvaise conception de la méthode suivie pour résoudre le problème. C'est alors l'algorithme lui-même qui doit être modifié, ce qui oblige à remettre en cause les partis pris de la phase d'Analyse.

Langages d'assemblage et langages évolués

Ecrire un programme, c'est donc écrire une suite d'instructions élémentaires s'enchaînant les unes après les autres pour réaliser un traitement sur des données. Dans le disque dur et la mémoire centrale, ces programmes sont codés sous forme de bits à la façon du mini-programme dont l'exécution est détaillée en [1.2].

De tels programmes sont aussi appelés des « programmes exécutables », puisqu'ils sont directement prêts à être exécutés.

Au début de l'informatique, dans les années 50, programmer revenait ainsi à écrire de telles suites d'instructions élémentaires. Les langages de programmation les plus proches de ce codage de « bas niveau » sont appelés « langages d'assemblage » ou « assembleurs ». Programmer dans un tel langage nécessite de connaître l'architecture matérielle de l'ordinateur sur lequel il s'exécutera; il y a ainsi presque autant de langages d'assemblage différents que de microprocesseurs.

Par exemple, imaginons un ordinateur similaire à notre ordinateur rudimentaire, mais disposant en plus (pour simplifier la suite) d'une dizaine de registres numérotés de 1 à 10, ayant chacun la taille d'un mot mémoire. Le mini-programme exécuté en pourrait alors s'écrire en Assembleur de la façon suivante :

ADD 1 2 3
MUL 3 4 5

Dans lequel ADD et MUL signifient respectivement « addition » et « multiplication » et où les numéros 1 à 5 désignent des registres (il est plus facile d'utiliser les registres pour stocker des données intermédiaires que de désigner directement des adresses en mémoire). Chaque instruction élémentaire est constituée exactement de la même façon que les instructions binaires de notre mini-programme : la première donne ainsi l'ordre d'additionner le contenu du registre 1 avec celui du registre 2, et de stocker le résultat dans le registre 3.

Les programmes écrits en Assembleur se traduisent immédiatement en programmes exécutables. Mais programmer en Assembleur n'est ni très simple ni très agréable. Aussi, de nouveaux langages de programmation ont peu à peu été définis pour faciliter la tâche des programmeurs. En inventer un nouveau, cela signifie :

définir un langage permettant d'exprimer n'importe quel algorithme
définir une correspondance, une méthode de traduction (exprimable par un algorithme!) entre ce nouveau langage et un langage d'assemblage.

La difficulté vient plutôt de la seconde condition que de la première. En effet, toutes les langues sont en principe capables d'exprimer toute méthode de calcul, tout algorithme, de façon plus ou moins informelle. Mais les ordinateurs ne comprennent rien à notre façon de parler. De plus, les langues des hommes sont beaucoup trop imprécises et ambiguës pour être traduisibles directement en Assembleur. Le problème est donc de définir une langue qui sera traduisible en Assembleur, de telle sorte que cette traduction elle-même puisse s'exprimer par un algorithme.

Ce rôle de traduction est joué par ce qu'on appelle les compilateurs. Un compilateur est un logiciel capable de transformer un programme écrit dans un langage de programmation donné L1 en un programme réalisant le même traitement mais écrit dans un autre langage L2 (en général un Assembleur), comme le montre le schéma de la figure [1.2]

Fig 1.2: rôle d'un compilateur démarche de conception d'un programme

Les compilateurs étant des programmes, ils sont eux-mêmes écrits dans un certain langage de programmation (et s'ils ne sont pas écrits en Assembleur, ils doivent eux-mêmes être compilés...) L'utilisation de compilateurs a permis la définition de langages de programmation de haut niveau ou évolués. Dans de tels langages, on peut s'abstraire de la connaissance matérielle de l'ordinateur sur lequel s'exécutera le programme pour se concentrer sur sa seule logique. Pascal est un langage de ce type. En Pascal, notre mini-programme peut s'écrire (à quelques instructions près) :

Begin
   nombre3:= nombre1 + nombre2;
   nombre5:= nombre3 * nombre4;
End.

ou plus simplement :

Begin
   nombre5:= (nombre1 + nombre2) * nombre4;
End.

Dans ce programme, « := » et « ; » ainsi que les mots clés BEGIN et END sont des symboles propres au langage Pascal. Les mots « nombre1 » à « nombre5 », eux, ne désignent plus une adresse en mémoire ni un registre mais une variable, c'est-à-dire un espace mémoire quelconque, abstrait, auquel est attribué un nom, sans que le programmeur ait à préciser où il se trouve physiquement.

Tout programme écrit en Pascal commence par le mot BEGIN et se termine par le mot END.
La première instruction du premier programme (après le BEGIN) signifie donc que la variable nommée « nombre3 » recevra comme contenu le résultat de l'addition des contenus respectifs des variables nommées respectivement « nombre1 » et « nombre2 ». Ce sera au compilateur Pascal de transformer ce programme (appelé aussi « programme source » parce qu'il est écrit dans un langage évolué) en la suite d'instructions en assembleur donnée plus haut. En Python, on écrira cette même instruction :

nombre5 = (nombre1 + nombre2) * nombre4

Mais attention : le symbole « = » apparaissant dans cette formule n'est pas une égalité au sens mathématique du terme. C'est une instruction, un ordre signifiant que ce qui est écrit à droite est la nouvelle valeur qui doit être stockée dans la variable écrite à gauche. Ainsi, en informatique, une instruction comme :

n = n+1
Est tout à fait recevable, alors qu'elle n'aurait pas grand sens en mathématique.
Elle signifie : la nouvelle valeur de n est son ancienne valeur + 1.

Source : Introduction à l'informatique université de Lille3

Algorithme

Un algorithme est un ensemble fini d'actions identifiables et finies(en temps et en moyens de toutes sortes nécessaires pour les exécuter) dont l'exécution dans un ordre convenu à l'avance réalise un calcul donne.

Programme

Un programme est l'expression d'un algorithme par une machine donnée dans un langage de programmation donné, en utilisant le répertoire d'actions (opérations-instructions) et les règles de composition propres à cette machine et ce langage donné.

Machine

Une machine réalise les opérations/fonctions :
1°/ Entrer les données.
2°/ Exécuter le programme (suite des opérations).
3°/ Séquencer les opérations, donc mémoriser le programme.
4°/ Mémoriser les résultats intermédiaires.
5°/Sortir les résultats.

Son organisation peut être schématisée en :
Une mémoire qui contient les objets manipulés sous forme codifiée (donnes) et qui a une capacité finie. Une unité de traitement qui effectue les opérations, qui prend les données en mémoire et y range les résultats.

Schéma simplifie d'une machine.

Appoche de l'activité de programmation passage d'un problème a un programme
Le but de la programmation est de passer d'un problème à un programme qui décrive des calculs amenant au résultat, à la réponse au problème. Les composantes de l'activité de programmation trouvent donc leur raison dans les différences entre un problème et un programme. On peut découper la construction d'un programme en 3 étapes

          (a)                 (b)               (c)   
Problème ----> Énoncé ----> Algorithme ----> programme

(a) Explicitation : un problème n'est jamais tout à fait défini, il y a toujours des sous-entendus dus à la connaissance du monde que possède la personne qui pose le problème : cette connaissance implicite du concepteur doit être explicitement fournie à l'ordinateur. Un premier effort est de déterminer une explicitation du problème, en ce qu'on peut appeler un énoncé.

(b) Programmation : un problème et un énoncé sont souvent intemporels, statiques, alors qu'un programme décrit une suite d'actions, c'est-à-dire une activité dynamique (il existe aussi des problèmes qui font intervenir le temps "réel" extérieur à la machine; ce n'est pas le temps du calcul). Le passage du statique au dynamique est la conception d'un algorithme. Un algorithme est une description des actions résolvant un problème, il intègre la partie dynamique de la résolution.

(c) Codification : un programme est écrit dans un langage strict, imposé, prenant en compte les contraintes liées à la machine qui exécutera les actions selon un des ordres possibles et avec des variables spécifiques. La codification est le passage de l'algorithme au programme.

Ces trois étapes correspondent à des activités de nature différente, leur mélange complique la tâche et conduit à des erreurs. Par exemple, les notions liées à l'ordre d'exécution des actions, de même que les variables n'ont rien à faire lors de l'établissement de l'énoncé. Il suffit de les introduire au niveau de l'algorithme; mais celui-ci doit n'utiliser que des données abstraites.

D'où une considération méthodologique :
- Travailler successivement à chacune de ces phases en utilisant éventuellement des langages différents
- Énoncé du problème en français ou en langage mathématique.
- Description de l'algorithme en langage de "spécification"
- Description du programme en langage de programmation.

Etude de un éditeur de texte avec Turbo Pascal

L'étude d'un éditeur de texte
Lorsque la taille d'un logiciel s'accroit, la création du logiciel devient de plus en plus délicate. Programmer un éditeur texte on ne peut pas le résoudre en quelques lignes savantes après dix minutes de réflexion. La technique de programmer structure permet de améliore l'organisation et l'écriture du programme, en facilitant la compréhension et la modification, et augmenter la fiabilité du logiciel ou programme.

Un éditeur de texte

c'est un project qu'il peut prendre des mois de réflexion et de programmations. Un des moyens utilise pour mieux maîtriser la complexité du logiciel est de constituer un ensemble de routines, de parties de programme ayan pour fonction la réalisation d'une tâche précise, en général simple. Ces routines viennent en fait compléter l'instruction du langage de developement avec de nouvelles fonctions ou procédures. La mise au point est moins erratique et la fiabilité obtenu meilleure. Dite-vous qu'il faudra écrire de centaines de procédures et fonctions, et le passage d'une à l'autre ne doit pas planter le programme, la moindre variable ou appel à une procédure peut provoquer une confusion dans la pile si cela et mal interprète, et cela peut planter le programme.

Méthode

Il faut écrire procédure par procédure et les tester de plusieurs façons jusque que la fonction soit correcte, et par la suite pourra être inclus sur le programme principal de l'éditeur. Sur l'éditeur une procédure principale permettra donc d'entrer les données au clavier et visualiser les résultats dans l'encrant de l'éditeur. Certaines routines sont stokes dans des fichiers différentes, ce qui permet de les utiliser directement en plaçant dans l'unité correspondante avec les directives Inclure correspondante comme ceci : {$I file_ecrire.pas} Cette méthode permet une souplesse maximale pour créer les unîtes.
Le nom du fichier contenant à la routine(s) peut être le même que la procédure avec l'extension (.PAS ou BLC) comme block à inclure, ce fichier ils peuvent être places dans un répertoire particulier.

Tester un programme

C'est se mettre à la place de l'utilisateur et imaginer tout ce qui peut faire comme erreurs, et une erreur ne doit pas planter le programme, il doit afficher un message d'erreur, et un lui indiquant l'erreur, et dans certains cas, ce qu'il doit-il faire pour poursuivre. Tester un programme de fois peut pendre autant de temps que de le programmer, tout dépend de ce que le programme peut-il faire.

Les Erreurs de programmations

Quant le programme fait une erreur et vous ne n'arrivez pas résoudre d'où-t-il bien peu devenir cette erreur, mais l'erreur de fois et devant vous yeux et votre cerveau et fatigue et vous ne la voyiez pas, laissez-la pour demain et vous avec plus de chances de le trouver plus facilement l'erreur et de détecter de ou il bien.
Un ordinateur exécute les taches qu'on lui programme logiquement et si la structure de la taches ne et pas dans un ordre logique et structure, l'ordinateur se plante et se arrête de fonctionner. Par contre, le cerveau de l'homme bien souvent ne réfléchi pas toujours logiquement, mais réfléchi à sa convenance pour la raison qu'il possède une fonction appelée l'orgueil, et ne veux pas admettre qu'il se trompe ou que sont raisonnement et une erreur.

La méthode copier/collé

Si vous employez cette méthode en faisant une « copie/coller » des sources des unités, et vous arrivez à compiler le programme, il peut fonctionner si vous respectez l'ordre de la compilation/exécution. Mais dite-vous que avec la méthode « copier/coller » vous n'arriverez pas à progresser et surtout vous n'auriez rien appris aux fonctions nécessaires pour programmer un éditeur de texte.

Mais par contre, si vous testez procédure par procédure avec une petite démo, alors vous arriverez à comprendre sont fonctionnement, et cela vous donnera la possibilité de le modifier ou peut-être le améliorer, en ajoutant des nouvelles fonctions.

Programmer un éditeur de texte

Une telle application soulève beaucoup de réflexion et de la logique. Le corps de l'éditeur doit disposer un minimum de fonctions suivantes : Les variables globales, le Buffer, l'écran, caractères de contrôle divers.

Avec les fonctions principales de l'éditeur on doit pouvoir déplacer le curseur à l'intérieur de la fenêtre du texte à l'écran à l'aide des combinaisons de touches du clavier ou de la souris:
Aller début de ligne, aller à la fin de ligne, une page d'écran vers le haut Une page d'écran vers le bas, un caractère à droite, un caractère à gauche Une ligne vers le haut, une ligne vers le bas, écrire un caractère mode insertion active où pas active, effacer un caractère à droite et à gauche, insérer une ligne vierge, sélectionner un block pour copier et coller, insérer un fichier extérieur sur l'éditeur, sauvegarder un block sur fichier, aller au menu général de l'éditeur ou aller à un menu bien détermine. etc.

Le buffer de l'éditeur

C'est un tableau de chaîne de caractères, sa taille est définie par une constante, un élément du tableau, tout comme si cette une ligne de texte.
On associe à ce tableau plusieurs variables : Le nombre de caractères que peut contenir le buffer, et sa déclaration c'est un pointeur variable dynamique déclare comme ceci :

Définition d'un type

pour pouvoir citer un type comme on le fait pour un objet, on donne à chaque type un nom bien déterminé. Certains sont prédéfinis, d'autres sont définis explicitement par une déclaration de type:

{*Pour associer un type à un objet, 
   on utilise un énoncé appelé déclaration*}

Type T   = constructeur de type. 
T_buffer = ^T;  {*ici on tranforme le type T en pointeur*}

var x : T;  {*1*}
var  buffer : T_buffer ;  {*2*}

{*(1) x c'est un variable simple, qui indique que l'on utilise le nom x 
        pour désigner un objet dont les valeurs sont du type T *}

{*(1) var x, y, z : T;  est équivalente à  var x:T; y:T; z:T; *}
           
{*(2) Buffer devient un vaiable d'un objet utilisable et declare 
   comme pointeur de type T.     
   Mais comme tout pointeur, il faut lui réserver une place en mémoire
   avec GetMem (voir plus bas) *}

Affectation variable

En programmation, on est amené à faire varier, pendant l'exécution d'un programme, la correspondante entre un nom et un objet. On appelle variable un nom qui peut être associe successivement à plusieurs objet. On dit parfois, qu'une variable est un objet dont la valeur peut changer au cours de l'exécution d'un programme

{*constructeur de type tableau de caractères*}
Type Edit_Buffer = Array [1..Max_Buffer+512] of Char;

{*constructeur de type pointeur le tableau de caractères*} 
{*déclaration comme variable le Buffer de l'Editeur*}

Buf_Ptr     = ^Edit_Buffer;                       
Var  Buffer : Buf_Ptr;

Le buffer c'est comme une grande feuille qu'on va écrire du texte, en pascal un pointeur bloc-mémoire qu'on peut allouer dans le tas est de 65521 octets (64Ko).
Un 1Ko égalé à 1024 octets. L'écran de l'éditeur et une fenêtre qu'ont peut la déplace sur le Buffer (feuille de papier) pour lire/écrire à un endroit de la feuille bien défini, le déplacement peut aller ver le haut, le bas, à droite et à gauche. etc.

Déclarations des pointeurs sur Turbo Pascal

{*Declaration du buffer sur la Unité Type_Buf *}
{*Types publiques du Buffer pour l'éditeur     *}

Interface                                              

CONST
      Max_Buffer=51200;   {*constante 50ko actuellement*}

TYPE  
      Edit_Buffer = Array[1..Max_Buffer+512] of Char;  {*1*}
      Buf_Ptr = ^Edit_Buffer;  {*2*}                        

VAR  Buffer : Buf_Ptr; {*3*}                                 

{*(1) tableau du buffer de l'éditeur  *}
{*(2) conversion dans un pointeur   *}	  
{*(3) Pointeur du Buffer de l'Editeur *}

Implementation

Begin
       Buffer:=Nil;
End.

notes: NIL : Le mot resserve NIL est une valeur constante particulière permettant de neutraliser un pointeur; il ne pointe ainsi sur rien. NIL est compatible avec tous les pointeurs.

Procédure GetMem
Crée une nouvelle variable dynamique de la taille indiquée et place son adresse dans une variable pointeur.
Déclaration: procédure GetMem(var P: pointer; Taille: Word);

Description: P est une variable d'un type pointeur quelconque. Taille est une expression spécifiant la taille en octets de la variable dynamique allouer.
La variable ainsi créée peut être référencée par P^. Une erreur d'exécution est signalée si la place disponible dans le tas n'est pas suffisante pour allouer la nouvelle variable.
il est possible d'éviter ainsi une erreur d'exécution avec MaxAvail

Restrictions: La plus grande taille de bloc mémoire qu'il est possible d'allouer en toute sécurité dans le tas en une seule opération est 65528 octets
(64Ko de octets).

Crée le buffer en memoire, type pointeur dynamique

{* remplisage le buffer d'espaces #32 *}
{* ^Z = #26 signifie la fin du buffer *}

if MaxAvail < (Max_Buffer+512) then
 begin
    GetMem(Buffer,Max_Buffer+512);
    Fillchar(Buffer^,Max_Buffer+512,' '); 
    Buffer^[1]:=#26;                          
 end;

Programme Assembleur

Procedures en Langage Assembleur

L'assembleur

le langage d'assembleur donne une connaissance du fonctionnement interne d'un ordinateur. et oblige au programmeur à décider des moindres actions de l'ordinateur. Les programmes en langage d'assembleur sont très précis, et permet au programmeur d'agir directement sur le matériel, ces programmes peuvent faire des choses qu'aucun autre ne peut faire pour commander le dispositif de E/S et l'interruption. Le langage assembleur est très puissant, c'est l'unique langage qui vous permette d'accéder à toute la puissance d'un processeur.

En principe on peut écrire n'importe quel programme en assembleur, mais quand ils sont assez longs on peut obtenir une meilleure gestion avec un langage plus évolue comme le « Pascal » ou le « C ». On peut mieux se concentre sur le problème car on n'aura pas à s'occuper directement de tous les détails se rapportant au matériel et au processeur. Un langage évolué permet de prendre du recul et on peut employer cette analogie, de voir la forêt plutôt que les arbres qui la composent.

Il faut dans ce cas, mélanger les programmes en langage d'assembleur aux programmes en langage évolue, en les relier le programme en langage évolue et le programme assembleur avec des sous-programmes en langage d'assembleur avec des fichiers objet, prés à être lies. Quand on compile un programme le compilateur il converti en langage machine les instructions, et le résultat par le compilateur est un programme (.OBJ) en langage machine.

LA PILE
Une PILE est une structure de données qui sert au stockage provisoire des informations. Un programme peut commander ce stockage par l'instruction PUSH (empiler). Il peut aussi provoquer la récupération des informations par l'instruction POP (dépiler).
La structure de données de la pile met en ordre d'une façon spéciale les données qui y ont été stockées. Un élément retire d'une pile (dépile) est toujours le dernier qui a été mis (empile). Le sigle de cette structure est LIFO (Las In, First Out ; dernier entré, premier à sortir).

Si on empile deux éléments, « A » d'abord, « B » ensuite, la première fois qu'on dépile on récupère « B » et à l'opération suivante, on récupère « A ».
Les informations son retirées de la pile dans un ordre à celui utilisé pour les y mettre. Un ordinateur réalise une pile au moyen d'une zone de stockage réserve à cet effet et d'un pointeur appelé pointeur appelé pointeur de pile. Le programme utilise celui celui-ci pour garder trace de la dernière adresse de la pile utilise pour introduire une information.

La pile en turbo pascal

La taille de la pile par défaut est de 16Ko est plus que suffisante pour la plupart des applications. Mais on peut spécifier la taille qu'on désire pour vu que celle-ci soit comprise entre « 1Ko » pour les petit programmes et « 64Ko » pour un programme faisant un usage intensif de la récursivité. Les tailles de la pile et du tas peuvent être ajustées par la directive de compilation « $M ». La directive « $M » n'a aucun effet sur les unités.
Stack size indique le segment de la pile (16Ko = 16 x 1024 = 16384)
Heap size la taille de tas (en octets).
{$M Stack size, heapmin, heapmax} ou {$M 16384, 0, 655360}
La directive {$N+} permet l'utilisation des quatre types de réels du coprocesseur arithmétique.

Le tas

Á chaque appel à « New et GetMem », le stockage est effectué dynamiquement sur le tas. En commençant à partir du bas. L'espace est libère par les routines « Dispose, Release et FreeMem ».

Dans le programme de l'éditeur EDIT13.PAS On initialise la quantité de la pile au début du programme {$M 16384,0,655360} C'est la pile qu'on a besoin pour garder les adresses des foncions appelés.

Exemple

Une fonction « A » en exécutant une tâche, peut appeler une autre fonction « B » pour réaliser une tâche définie, et ainsi de suite...
Faire appel à la fonction « A » qu'elle appelé « B » qu'elle appelé « C » qu'elle appelé « D » et le retour sera (dépiler sur la Pile) « D » retour « C » retour « B » retour « A » (La fonction « A » termine la tâche qu'elle devait faire).

Turbo Pascal et les liens avec les fichiers objet.

Le {$L ...} est utilise afin de faire le lien avec du code écrit en assembleur, pour les sous-programmes déclarés comme externes. le fichier doit être un fichier objet (.OBJ). La directive {$L nomfichier} demande au compilateur de lier le fichier nommé avec le programme ou l'unité en cours de compilation.

Procedures de l'éditeur le code écrit en assembleur.

{$L Win_Asm.OBJ}
{$L Miniscul.OBJ}
{$L Uppers.Obj}
{$L SCREEN.OBJ}

{*Effectue une sauvegarde par octets de la region delimite*}
Procedure ReadBuf(X1,Y1,X2,Y2:Byte;Var Buf);
External {Win_Box};

{*Dessine une image par octets sauvegardee par GetImage*}
Procedure WriteBuf(X1,Y1,X2,Y2:Byte;Var Buf);
External {Win_Box};

{*dessine un Rectangle sur les cordonees, cadre peut etre simple ou Double*}
Procedure Rectangle(x1,y1,x2,y2:Byte;Var Cadre:CadreChars);
External {Win_Box};

{*inverse la region de le ecran  delimite par les cordonees*}
Procedure HighBox(x1,y1,X2,Y2,Colori:Byte);
External {Win_Box};

{*Rempli un rectangle avec un caractere determine code ASCII*}
Procedure BoxFill(x1,y1,X2,Y2:Byte;Ch:Char);
External {Win_Box};

Les routines external en langage assembleur doivent respecter certaines règles pour pouvoir fonctionner correctement au sein d'un partiel. Voir le chapitre 14 les routines externes et partiels, du manuel de référence Turbo Pascal.

Procedures le code écrit en assembleur.

;;...........................................................
;; Exemple résultat sur fonction type String
;;...........................................................

    CODE SEGMENT BYTE PUBLIC
        ASSUME  CS:CODE
  Uppers  PROC NEAR  ;;Fonction Uppers(S:String):String;

           StrResul  EQU  DWORD  PTR [BP+8]
           PUBLIC Uppers
           PUSH BP
           MOV  BP,SP
	   
           PUSH DS
           LDS  SI,[BP+4]       ;;charge l'adresse de la chaine
           LES  DI,StrResul     ;;Charge l'adresse du résultat
           CLD                  ;;indicateur de direction à 0
           LODSB                ;;charge la longueur de la chaine
           STOSB                ;;copie dans résultat
           MOV  CL,AL           ;;longueur de la chaine dans CX
           XOR  CH,CH           ;;met CH à zéro
           JCXZ @@1             ;;Saut si CX = 0
  @@2:     LODSB                ;;charge caractère dans AL, incrémente SI
           CMP  AL,'a'          ;;saut si caractère différant de
           JB   @@3
           CMP  AL,'z'          ;;l'intervalle 'a' à 'z'
           JA   @@3
           SUB  AL,'a'-'A'      ;;converti en majuscule
  @@3:     STOSB                ;;copie dans résultat
           LOOP @@2             ;;boucle tant que cx différant de zéro
  @@1:     POP  DS              ;;dépile DS

           POP  BP              ;;dépile BP
           Ret  4               ;;Retour de pile 6 octets
  Uppers   ENDP                 ;;fin de procédure
  CODE     ENDS
  END

Turbo Assembleur et Turbo Pascal

La directive EXTRN : accès aux données de Turbo Pascal depuis Turbo Assembler.

Un module Turbo Assembler peut accéder à toutes les procédures, fonctions, variables et constantes types déclarées au niveau le plus extérieur du programme ou de l'unité avec lequel il est relié.

Notez que cela comprend les variables déclarées après la directive de compilation {$L+} et les déclarations de type EXTERNAL associées à ce module. Les labels Turbo Pascal et les constantes ordinaires ne son pas accessibles au langage assembleur.

Supposons que les variables globales suivantes soient déclarées par votre programme écrit en Turbo Pascal :

Procedures de l'éditeur le code écrit en assembleur.


VAR  a :Byte;   b :Word;   c :Shortint; d :Integer; e :Real; 
     f :Single; g :Double; h :Extended; i :Comp;    j :Pointer;
	 
Grâce aux déclarations EXTRN suivantes, ces variables sont accessibles
depuis votre programme écrit en langage assembleur :

 VAR 
   EXTRN  A : BYTE      ;;1 octet 
   EXTRN  B : WORD    ;; 2 octets.
   EXTRN  C : BYTE      ;; l'assembleur traite de la même façon
                                ;; les signés et les non-signés. 
   EXTRN  D : WORD    ;; ditto. 
   EXTRN  E : FWORD   ;; réel logiciel sur 6 octets. 
   EXTRN  F : DWORD   ;; flottant IEEE sur 4 octets. 
   EXTRN  G : QWORD  ;; flottant IEEE double précision sur 8 octets. 
   EXTRN  H : TBYTE    ;; flottant IEEE temporaire sur 10 octets.
   EXTRN  I : QWORD   ;; entier signé 80x87 sur 8 octets. 
   EXTRN  J : DWORD   ;; pointeur Turbo Pascal.


De la même manière vous pouvez accéder aux procédure et fonctions de
Turbo Pascal y compris les routines de la bibliothèque standard.
Utilisons l'unité Turbo Pascal suivante :

{*Unité exemple, qui défini plusieurs procédures Pascal*}
{*appelées depuis une procédure en langage assembleur*}

Unit Exemple;
Interface
   Procedure TestExemple;
   Procedure ProcPublic;
Implementation

Var A : word;

Procedure ProcAsm; EXTERNAL;
{$L PROCASM.OBJ}

Procedure ProcPublic;
 begin
      Writeln('Dans ProcPublic.');
 end;
 
Procedure ProcCourt;
 begin
      Wrirteln('Dans ProcCourt');
 end;
 
{$F+}
Procedure ProcLong;
 begin
      Writeln('Dans ProcLong.') ;
 end;
{$F-}

Procedure TextExemple ;
 begin
      Writeln('Dans TestExemple.') ;
      A:=10 ;
      writeln('Valeur de A avant ProAsm = ', A);
      ProcAsm;
      Writeln('Valeur de A après ProcAsm = ',A);
 End ; {*fin de testExemple*}
End.



Grace aux directives EXTRN, la procédures ProcAsm peut appeler
les procédure ProcPublic, ProcCourt ou ProcLong.


DATE SEGMENT WORD PUBLIC
     ASSUME  DS:DATE
     EXTERN A:WORD        ;; variable de l'unité
DATE ENDS

CODE   SEGMENT BYTE PUBLIC
ASSUME CS :CODE
EXTRN  ProcPublic : FAR    ;;Procedsuré longe (exportée par l'unité)
EXTRN  ProcCourt  : NEAR  ;;Proceduré courte (locale à l'unité)
EXTRN  ProcLong   : FAR    ;;Proceduré longue (locale mais forcée en longue)

ProcAsm  PROC   NEAR
         PUBLIC ProcAsm
         CALL FAR PTR ProcPublic
         CALL ProcCourt
         CALL FAR PTR ProcLong
         MOV  CX,DS:A             ;;récupere la variable A de l'unité
         SUB  CX,2                   ;;la modifie
         MOV  DS:A,CX             ;;la réintègre 
         RET
ProcAsm  ENDP                 
CODE     ENDS
         END


Le programme principal suivan teste cette unité Pascal 
ainsi que le code en langage assembleur

 PROGRAM ExempleT;
 USES Exemple;
 Begin
      TestExemple;
 End.

Pour construire le programme d'exemple avec le compilateur sur ligne de commande et l'assembleur, vous utiliserez ce fichier de commandes :

TASM PROCASM
TPC /B EXEMPLET
EXEMPLET

Puisqu'un sous-programme externe doit être déclaré au niveau le plus extérieur de votre programme, vous ne pouvez pas utliser les déclarations EXTRN pour accéder aux objets locaux d'une procédure ou d'une fonction. Cependant quand vos sous-programmes en assembleur sont appelés depuis Turbo Pascal, ils peuvent recevoir des objets en tant que valeurs ou paramètres VAR.

Extrait du Manuel de Turbo Assembleur Borland

Raccourcis de l'éditeur Ednum

Les raccourcis de éditeur
Les raccourcis de éditeur dits aussi accélérateurs sont des combinaisons de deux ou de trois touches qui sont ‚quivalentes a une commande du menu/editeur sans nécessiter l'accès au menus.

Mouvements du curseur
Caractère à droite Ctrl-D ou Flèche droite Mot à gauche Ctrl-A ou Ctrl-Flèche G. Mot à droite Ctrl-F ou Ctrl-Flèche D. Ligne précédente Ctrl-E ou Flèche Haut Ligne suivante Ctrl-X ou Flèche Bas Défilement arrière Ctrl-W Défilement avant Ctrl-Z Page précédente Ctrl-R ou PgUp Page suivante Ctrl-C ou PgDn Début fichier Ctrl-Q R ou Ctrl-PgUp Fin fichier Ctrl-Q C ou Ctrl-PgDn
Insertion et Suppression
Insertion Oui/Non Ctrl-V ou Inser Suppression 1 ligne Ctrl-Y Suppr.Carac. à gauche Ctrl-H ou Backspace Suppr.carac. à curseur Ctrl-G ou Suppr Suppr. Bloc Ctrl-K Y
Commandes de blocs de texte
Marque début de bloc Ctrl-K B Marque fin de bloc Ctrl-K K Option Début Bloc Shift + @ ou Définir le Bloc Shift + curseur Copie du bloc Ctrl-K C Suppression de bloc Ctrl-K Y Lecture Bloc disque Ctrl-K R Ecriture Bloc disque Crtl-K W Montre/Cache Bloc Ctrl-K H
Raccourci pour Menus
Alt-F Menu FILE Alt-E Menu EDIT Alt-O Menu OPTIONS Alt-L Menu LANG Alt-M Menu MATHES F10 Menu général sur l’éditeur. Alt-X Sortie de l'éditeur (Fin) Ctrl-F9 Insère la date courante. F1 Help F1O Calculatrice. ESC Fin où termine.

Raccourci Action
F1 Active le système &aide F1 sur aide index d'aide F2 Sauvegarde le fichier en cours F3 Charger un nouveau fichier F7 Suggestion Traduction Ang/Fran F8 Suggestion Traduction Fra/Ang Ctrl-F1 Place disponible dans l'éditeur Alt-F2 Change couleur du texte sur Edit Alt-F3 Chargement d'un des 8 derniers fichiers (liste Pick) ALT-F6 Alterne entre les deux derniers Fichiers Alt-F7 ouverture du calculateur Alt-F8 ouvre une boite du codes ASCII.. Alt-F9 ouvre une boite des codes ASCII.. Alt-F1O Calculatrice. Ctrl-F1O ouvre la boite de calcul de formule. Ctrl F1 Nombre de décimales.
Calculateur fonctions mathématiques
PI(0) égale à 3.141592654 ABS(nombre) Valeur absolue TAN(nombre) Tangente ATAN(nombre) COS(nombre) EXP(nombre) L'exponentielle de nombre LN(nombre) Logarithme de nombre ROUND(nombre) Arrondi le réel le plus proche SIN(nombre) SQRT(nombre) Racine carre de nombre. SQR(nombre) Carre de nombre. TRUNC(nombre) Enlevé la partie décimale RADIA(nombre) Transforme en radians ARSIN(nombre) ARCOS(nombre) INT(nombre) retourne la partie entière. FRAC(nombre) retourne la partie fractionnaire. F2 Save evaluate 1 F3 Save evaluate 2 F4 Save evaluate 3 F5 Evaluate 1 F6 Evaluate 2 F7 Evaluate 3 Ctrl-F8 copie de formule Evaluate

EMPLOI DE LA SOURIS SUR L'ÉDITEUR
Depuis l'éditeur, cliquez sur le bouton droit de la souris pour sélectionner le menu choisi. Sélection dans le menu avec la souris, pour Sélectionner une commande avec le clic de gauche. Une fois sélectionne pour ouvrir la sélection, positionnez-y la flèche de la souris, puis cliquez sur le bouton droit. La sélection ne pourra s'ouvrir que si la souris se trouve sur la ligne en surbrillance. Pour fermer la sélection en cours avec la souris, appuyez sur le bouton gauche + plus le bouton droit, cela est équivalent que appuyer sur [Echap ou ESC] équivalent à [Ascii=#27]. Dans certaines parties des menus ou sous-menus la souris ne fonctionne pas, Servez-vous des touches du clavier. Dans non porte quelle partie de l'éditeur la touche [Echap ou ESC] annule toujours l'opération en cours. La touche [Entrée] valide toujours une opération. Les touches du curseur pour se déplacer vers le haut, vers le bas, à gauche et à droite etc. La touche F10 ouvre toujours le Menu général de l'éditeur. Dans l'éditeur: Vous ne trouverez pas de barre de défilement haut/bas et droite/gauche. Cette fonction est assumée par les bordures de l'éditeur elles-mêmes. Positionnez la souris sur la ligne et : la ligne Haut remonte le curseur, la ligne droite déplace le curseur à droite, la ligne bas descend le curseur, la ligne gauche déplace le curseur a gauche.

Principales Procédures de l'éditeur

Procedure de l'éditeur
Procedure Change_Inser_Mode;
Procedure Initialiser;
Procedure Affiche_Menu;
Procedure Load_Fichier_Disque(Reper,Neime:String);
Procedure Load_Fichier_Disque_win(Reper,Neime:String);
Procedure Save_Fichier_Win(D_isque,NeimeFic:String);
Procedure Save_Fichier_Disque(D_isque,NeimeFic:String);
Procedure Efface_Block;
Procedure Defini_Bloc;
Procedure Init_Page;
Procedure Positione_Curseur(X1:byte);
Procedure Fin__Ligne_X;
Procedure Debut__Ligne_X;
Procedure Avance_Page_X_de_1;
Procedure Recule_Page_X_de_1;
Procedure Curseur__FinLigne;
Procedure Premiere_page_Debut(Pose:Word);
Procedure Change_Une_Page_Bas(Pose:Word;FindLines:Word);
Procedure Change_Une_Page_Haut(Code:Char);
Procedure Lecture_Une_Ligne_Bas(Pose:Word;code:Char);
Procedure Lecture_Une_Ligne_Haut(Pose:Word);
Procedure Curseur_Droite;
Procedure Curseur_Gauche;
Procedure Debut_ligne_Gauche;
Procedure Curseur___bas;
Procedure Curseur_Haut;
Procedure Avance_Une_Page;
Procedure Recule_Une_Page;
Procedure Fin_du_Fichier;
Procedure Debut_Du_Fichier;
Procedure Save_Ligne_Curseur(Poss:Word);
Procedure Load_Ligne_Curseur(Poss:Word);
Procedure Del_Gauche;
Procedure Del_Droite;

Procedure de l'éditeur
Procedure Del_FinLigne;
Procedure Del_Line;
Procedure Tab_Deplace;
Procedure Inserer_Ligne;
Procedure Inser_Char(Car:Char);
Procedure Avance_Page;
Procedure Recule_Page;
Procedure mot_suivan(pos:Word);
Procedure mot_Avan(pos:Word);
Procedure Donne_Position_XY(Var x,y:Word;Pose:Word;mode:Char);
Procedure Control_Longueur_DE_Lignes(Poss,Pose2:Word);
Function Erreur_file_Toolarge(Nom:String;Sizee:Longint;Code:Char ):Boolean;
Function Erreur_limite_Buf(code:char):Boolean;
Function FileExists(F,N : String) : Boolean;
Function _Fichiers_Dir(Var Directori:String; Texte_Load:String):String;
Procedure Change_Directori(RR:String);
Procedure Write_Block_Fic;
Procedure Block_Load_Fic;
Procedure CtrL_K;
Function Verify_Reper(Var Reper,S:String):Boolean;
Function Verify_Rep_Fic(Var Reper,Neime:String):Boolean;
Procedure CopyBlock__B(Debut_Pos,decale:Word);
Procedure CopyCopyBlock(decale:Word);
Procedure Coup_block;
Procedure LireTexte(Reper,Neime:String);
Function Selecte_Attr(Attribut:Word):Word;
Procedure Change_Attribut;
Procedure Cherche_Marque(pos:Word);
Procedure Change_Block(Signe:Char;Poss:Word;Deplace:integer);
Procedure Shift_Bloc(xxw:Word);
Procedure Cherche_position_de_XY(PosePose:Word);
Procedure Dir_Nom_Help;
Procedure Change_Repertoire_Langage(Fond__Box:byte);
*

Schéma pricipal de l'Éditeur

Architecture du programme l'Éditeur de texte en pascal

{$N+}
{$M 16384,0,655360} {*reservation taille de la pile interne*}
PROGRAM EDIT13;
Uses Déclaration des unîtes contenant des procédures & fonctions
Label ErreurFin; {*Les labels sont utilisés comme cibles pour de instruction GOTO*}

{*Déclaration des constantes publiques*}

Const  
  DelayMouse:integer=2000;
  Disk_Dur_C:string[70]=' ';
  ...... etc.
  
{*Déclaration des variables publiques*} 
Var Stop   : boolean;
  StrDate : string;
  ...... etc.

{*declaration de procedure & fonctions*}	
Procédures diverses 


Procédures P_Edit {*procedure principale*}	
Label Key_Fin;    {*label interne à la procedure*}
var x1,y1    : byte;
    KeyChoix : word;
    …… etc.
Début
  ……
  ……
Fin_début;{*end P_edit*}
	
Début_Programme  {**Début du Programme EDIT13**}
 Stop:=false;
 Si InitMouse Alors Affiche('Mouse active..');
 Sinon
 Goto ErreurFin; {*erreur fin du programme*}
  
{*Initialisation des variables de l'éditeur EDIT13**}
  Extension    :='.txt';
  Fin_Programme:=False;
  ……etc.
     
{*Initialisation variable répertoire actif*}
  GetDir(0,Disq);
  Disque_2:=Disq[1]+Disq[2];
  Si Disq[length(Disq)]<>'\' Alors Repertoire:=Disq+'\'
  Sinon Repertoire:=Disq;

{*Initialise des derniers fichiers employes*}
  Init_PicK;
  
{*Activation des pointeurs en mémoire virtuel*}
  size_plus:=512;
  size_Plus:=size_plus+Size_Buf_Texte; {*taille*}
  GetMem(BufTexte,size_plus);      {*activation*}   
  ……
  …… etc.
	
{*Initialise le fichier/variable dernière utilisation*}
  Init_Color(Repertoire+'FILES\EDIT13.INI');
  Init_Pick_Mode(1);

{*Initialise variables début programme*}
  Initialiser; 
  Affiche_Menu;  {*affiche l'éditeur*} 
  info_debut_program(10,8);
  Execute_File;  {*ouvre le dernier fichier utilise*}
  StyleMouse(2,14);  {position du pointeur de la souris*}

  P_Edit;  {*Procédures principale de l'éditeur*}

{*sauvegarde sur fichier init variable dernière utilisation*}
  Init_Pick_Mode(0);
  ErreurFin:

{*Supprime les pointeurs de la mémoire virtuel*}
  Si BufTexte<> NIL Alors FreeMem(BufTexte,size_plus);
  ……
  ……
  etc. 
  TextAttr:=7;
  Clrscr;
  Halt(1);
Fin_programme_edit13.  {*fin du programme de l'editeur*}

Codes ASCII DOS & Windows

Le MS-DOS emploi la page de code 850 Multilingue Latin I

La page de code 850 est une page de code définie par IBM et qui est utilisée en Europe occidentale avec le système DOS et d’autres systèmes de la même époque. C’est une extension de l’ASCII sur 8 bits, partiellement compatible avec la page de code 437 dont elle est dérivée et qu’elle modifie. Elle est encore utilisée dans les fenêtres de type console ou invite de commandes sur les systèmes Microsoft Windows en Europe occidentale.
Table de codage standard Jeu de caractères codés ISO/CEI 646 (variante de la norme ANSI X3.4:1986 des États-Unis, alias US-ASCII)

La page de code Windows-1252 ou CP1252 est un jeu de caractères, utilisé historiquement par défaut sur le système d'exploitation Microsoft Windows en anglais et dans les principales langues d’Europe de l’Ouest (dont le français).
Le tableau suivant montre Windows-1252. Les numéros 81, 8D, 8F, 90, et 9D ne sont pas utilisés et sont signalés par la couleur vert pâle. Les changements par rapport à ISO-8859-1 sont signalés par la couleur jaune.

La page de code Windows-1252 ou CP1252 est un jeu de caractères, utilisé historiquement par défaut sur le système d'exploitation Microsoft Windows en anglais et dans les principales langues d'Europe de l'Ouest (dont le français).
Le MS-DOS emploi la page de code 850 Multilingue Latin I La page de code 850 est une page de code définie par IBM et qui est utilisée en Europe occidentale avec le système DOS et d'autres systèmes de la même époque. Elle est encore utilisée sur Turbo Pascal, dans les fenêtres de type console ou invite de commandes sur les systèmes Microsoft Windows en Europe occidentale.

Pour remédier ce problème sur EDIT13, il suffit d'écrire deux fonction pour convertisseur les codes ASCII. Cela permet par exemple de lire le fichier crées par le Bloc-notes avec Turbo Pascal 7 pour le Dos. Dans la table ascii son les codes (80h) ou (128) jusque (FFh) ou (255) comme les caractères spéciaux où accentues...

La fonction Code_ASCII_ANSI (_ss:char): char;
Elle converti le code Windows-1252 ISO-8859-1 en code 850 Multilingue Latin I
Retourne les caractères de 128 à 255, fonction employé pour sauvegarde les fichiers.

La procédure employé pour sauvegarder les fichiers, converti le code ASCII en code ANSI Windows
Procédure Save_Fichier_win (D_isque, NeimeFic:String);

Function Code_ASCII_DOS (_ss:char):char;
Elle converti le code MS-DOS 850 Multilingue Latin I en code Windows-1252 ISO-8859-1
Retourne les caractères de 128 à 255, fonction employé par sauvegarde les fichiers.
Cette fonction employée par sauvegarde les fichiers Dos en fichier compatible avec le code ANSI Windows ISO-8859-1. Les fichiers peuvent être lus par Bloc-notes de Windows

La Procédure employé pour ouvrir les fichiers, code ANSI Windows les converti en code Ascii 850 Multilingue Latin
Function Code_ASCII_DOS (_ss:char):char;

La fonction employé pour lire (load) les fichiers sur le Edit13.
Procedure Load_Fichier_Disque_win (Reper,Neime:String);

Turbo Pascal for Windows (TPW) peut lire les fichiers créé parle bloc-notes de Windows Mais il ne converti pas les codes ASCII (128 à 255) MS-DOS 850 Multilingue Latin I des fichiers Turbo Pascal 7

La gestion de fichiers

Deux possibilités pour ouvrir un fichier : Par défaut l'éditeur employé le code Windows-1252. Le menu FILE, pour ouvrir un fichier la sélection LOAD ou F3 et pour sauvegarder le fichier SAVE ou F2.
Si vous voulez ouvrir un fichier format DOS avec code 850 multilingue latin I sur le menu EDIT il à deux sélections, Ouvrir un fichier : « load file DOS » et sauvegarder un fichier : « Save file DOS ». Le éditeur à été crée avec Turbo Pascal 7, alors le texte du buffer se le code DOS 850 multilingue latin I.
C'est l'unité ASCII qui transforme la ouverture et sauvegarde des fichiers quelle que soit le format.

Exemple 1

Vous pouvez ouvrir un fichier format Windows et le sauvegarder sur le format DOS, où vous pouvez ouvrir un fichier DOS et le sauvegarder format Windows.
Mais l'éditeur et programme par défaut avec le format code ASCII Windows. Si vous ouvert un fichier (avec LOAD du menu FILE) format DOS le code de caractères spéciaux (àéèêîù etc.) ne sont pas convertis au format Windows et si vous le sauvegardez avec (F2 ou Save menu FILE) ne les convertis pas au format Windows.

Exemple 2

Pour pas modifier le code du fichier : si cet un fichier DOS, il faut le ouvrir avec la fonction (Menu EDIT « load file dos » et le sauvegarder avec « Save file DOS » ) Si cet un fichier code Windows ouvrez-le avec (Menu FILE Load ou F3, et sauvegardez-le avec SAVE ou F2).

conversion des tables ASCII MS-DOS et Windows de l'éditeur.

unit Ascii;
interface
{---------------------------------------------------------------------} 
{ converti le code Windows ISO-8859-1 en code 850 Multilingue Latin I }
{ retourne les caractères de 128 a 255                                }
{ cette fonction employé par sauvegarde les fichiers                  }
{---------------------------------------------------------------------} 

fonction Code_ASCII_ANSI(_ss:char):char;

{---------------------------------------------------------------------} 
{ procédure employé pour sauvegarder les fichiers, converti le code   }
{ Ascii en code ANSI Windows                                          }
{---------------------------------------------------------------------} 

Procédure Save_Fichier_win(D_isque,NeimeFic:String);

{--------------------------------------------------------------------------} 
{ converti le code code 850 Multilingue Latin I en code Windows ISO-8859-1 }
{ Retourne les caractère de 128 a 255                                      }      
{ Cette fonction employé par sauvegarde les fichiers Dos en fichier        } 
{ compatible ANSI Windows ISO-8859-1, les fichiers peuvent être lue par    }
{ bloc-notes de Windows                                                    }
{--------------------------------------------------------------------------} 

function Code_ASCII_DOS(_ss:char):char;
  
{--------------------------------------------------------------------------} 
{ Procédure employé pour ouvrir les fichiers, code ANSI Windows les       } 
{ convertile code Ascii 850 Multilingue Latin I                            } 
{--------------------------------------------------------------------------} 

Procedure Load_Fichier_Disque_win(Reper,Neime:String);

implementation
begin
   code ……
end.

Notes

Sur Windows : Démarrer | Exécuter - ouvrir :
charmap   (ouverture de la table des caractères)
osk   (ouverture d'un clavier virtuel) 
cmd   (ouverture de la fenêtre MS-DOS)

Sur MS-DOS :
Help   (affiche les commandes pour DOS)
Help | more   (affiche les commandes par pages ou par commandes)

Unités de l'éditeur

Unites du programme éditeur de texte EDIT13

Unit Init13.pas
Répertoire ed..
Compiler Ed...
Unit Buffes
Unit Keys
Inser caractere
Variables
Edit13.pas
Menu edit
Nummouse.pas
Mousebox.asm
U_pick.pas
C_read.pas
H_aide.pas
H_help.pas
H_calcul.pas
Gaff2011.pas
Types_11.pas
h_maths.pas
SaveMath.pas
Ascii.pas
Blocload.pas
Blocsave.pas
b_ctrl_k_pas
b_lang2.pas
b_lang3.pas
b_notes.pas
b_traduc.pas
2012
2012
2012
2012
2012
2012
2012
2012
2012
2012
2012
2012
2012
2012
2012
Units_edit13

Compilation d'Edit13.pas en Edit13.exe

Compilation d'editeur Edit13.pas avec le systeme MS-DOS

Créer un répertoire nome « Edit13 » sur le disque dur C:\

Ouvrir invite de commandes MS-DOS : %SystemRoot%\system32\cmd.exe

Commandes ms-dos
CLS	Efface l'écran.
DIR	Affiche la liste des fichiers et des sous-répertoires d'un répertoire.
Chdir, CD	Affiche le nom du répertoire en cours ou change le répertoire en cours.
MD	Crée un répertoire.
MKDIR	Crée un répertoire.
RD	Supprime un répertoire.
RMDIR	Supprime un répertoire.
MD	Crée un répertoire.
MKDIR	Crée un répertoire.

Creation
Commande MS-DOS: MD où MKDIR Crée un répertoire C:\>MD [nom du répertoire] [entrée] C:\> C:\>MD Edit13 [entrée] C:\>CD Edit13 [entrée] Sud-répertoires C:\Edit13>MD Donnes [entrée] C:\Edit13>MD Files [entrée]

Unites du programme
le répertoire C:\Edit13\ Mettre sur le répertoire C:\Edit13\ tous les fichiers allant l'extension PAS, BLC, TPU Le contenu des répertoire(s) C:\Edit13 \| C:\Edit13\Donnes \| C:\Edit13\Files Plus haut sur " Unîtes du programme éditeur de texte EDIT13 " sur le menu à gauche cliquez sur: Unité d'Initialisation des overlays (1) Unit Init13.pas Répertoire EDIT13 : fichiers et unités de l'éditeur (2) Répertoire de l'éditeur Compilations des unités de l'éditeur (3) Compiler Edit13.exe Patientez vous êtes dans une autre Galaxie. En construction, toutes les sources complètes du Répertoire et programme Edit13.exe sur : REPERTOIRE_EDIT13.zip (686 Ko (702 521 octets))

Systeme binaire

Arithmetique Binaire

Ce le mathématicien George BOOLE (1815-1864), mathématicien et logicien anglais. Il voulait prouver l'existence de tout et de rien à partir de deux états, dans la recherche sur les lois de la pensée, George Boole décrit un système algébrique qui sera plus tard connu sous le nom d'algèbre booléenne.

Dans ce système, les propositions logiques sont indiquées par des symboles et peuvent être exécutées par des opérateurs mathématiques abstraits qui correspondent aux lois de la logique.

L'algèbre booléenne occupe une place primordiale dans l'étude des mathématiques pures et dans la conception des ordinateurs.

L'ordinateur stocke ces informations au moyen du système de numération binaire, sous forme de niveaux de tensions électriques de deux états, vrai ou faux chaque élément stocké peut avoir deux configurations : « ON » ou « OFF », ce que l'on peut traduire par « présent » ou « absent », en « service » ou « hors-service », « vrai » ou « faux », « 1 » ou « 0 ». A partir de « 0 » et « 1 » on peut faire des opérations arithmétiques très complexes.

systèmes	définitions commentaires
Système Binaire	Dans le système binaire, deux chiffres (0 et 1) suffisent pour représenter un nombre.
Système Décimal	le système de numération décimale, adopté par la plupart des pays, se compose de dix chiffres: 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9. Il s'agit donc d'un système de base10.
Système Hexadécimal	Le système hexadécimal, il utilise 16symboles: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A (dix), B (onze), C (douze), D (treize), E (quatorze) et F (quinze).

On emploie normalement l'arithmétique à base10 ou décimale où il y a 10 chiffres différents « 0 à 9 ».
La limitation à 10 chiffres de l'arithmétique à base10 n'empêche pas de représenter des grands nombres.
On utilise des nombres contenant plusieurs chiffres dont la position indique une puissance de 10.

Le chiffre le plus à droite de n'importe quel nombre indique les unités, le chiffre à gauche les dizaines, le suivant les centaines, et ainsi de suite. La progression de droite à gauche, est 10⁰, 10¹, 10², etc.

Le nombre 2368 est en fait 2 milliers, 3 centaines, 6 dizaines et 8 unités. La décomposition du nombre 2368, au point de vue mathématique:

2368 = 2 x 10³ + 3 x 10² + 6 x 10¹ + 8 x 10⁰

XXXX = 2000 + 300 + 60 + 8   {* décimale où binaire : (10⁰ = 1) où (2⁰ = 1) *}

Passage de binaire à décimal

A priorité, rien ne distingue le nombre 101 (cent et un) exprimé dans le système décimal traditionnel du nombre 101 (un zéro un) exprimé dans le système binaire (ou de base 2). Pour cette raison, on le notera : 101b

Chaque nombre exprimé dans le système binaire a son équivalent dans le système décimal (et vice-versa). Chaque chiffre du nombre binaire est affecté d'un poids. Ainsi, pour le nombre 1011b

Un nombre binaire est égal à la somme de ses poids.

binaire 2

Si l'on effectuait ces opérations sur des nombres binaires à quatre chiffres, on trouverait que leurs équivalents dans le système décimal sont :

Les additions de nombres binaires

L'addition binaire suit des règles calquées à l'arithmétique traditionnelle en base10.

0 + 0	=	0
1 + 0	=	1
0 + 1	=	1
1 + 1	=	0 avec report

Durant cette opération, nous avons eu trois reports (d'abord de la colonne de poids 0 vers celle de poids 1, puis de celle de poids 1 vers celle de poids 2 et enfin de celle de poids 2 vers celle de poids 3).

On peut vérifier que : 5 + 3 = 8 = ( 1 x 2³ + 0 x 2² + 0 x 2¹ + 0 x 2⁰ )

Autre exemple

L'addition (4 + 12) a donné lieu à deux reports : 
 d'abord de la colonne de poids 2 vers celle de poids 3 
 et puis de celle de poids 3 vers le vide  

   0100   
  +1100   puisque nous calculons sur 4 bits.
  -------
   0000   Un report est donc « perdu » et le résultat est erroné.

Les changements de base & Conversion binaire où décimal

Pour la notation binaire, on applique la règle de la décomposition en une somme de puissances de 2.

Exemple convertir 10000b en décimal :

donc, 10000b = décimal 16
décimal 16 = hexadécimal 10
La base hexadécimal on à les chifres : « 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F »
« A = 10, B = 11, C = 12, D = 13, E = 14, F = 15 »

Conversion du décimal où binaire

On effectue la division par 2 du nombre décimal, puis la division du quotient par 2 et ainsi de suite jusqu'à ce que le quotient soit égal à 0 ou 1
Donc, décimal 16 = 10000b

Les restes des divisions successives, prises dans l'ordre inverse, constituent le nombre représenté en binaire.

La multiplication en Binaire

En binaire dans une multiplication par 2, il faut ajouter un zéro à la fin du nombre.
C’est à dire décaler tous les chiffres vers la gauche.
Pour multiplier par 4 (c’est à dire 2²) il faut ajouter deux zéros, faire deux décalages successifs à gauche.

Principe d’une multiplication : Chaque décalage d’une case à gauche correspond à une multiplication par 2.

(2 * 2)	=	( 0010b * 2 )	=	0100 b	=	4 décimal
(6 * 2)	=	( 0110b * 2 )	=	1100 b	=	12 décimal
(2 * 4)	=	( 00010b * 4 )	=	1000 b	=	8 décimal
(6 * 4)	=	( 00110b * 4 )	=	11000 b	=	24 décimal

Les 3 exemples

Compilation du programme

Compilation d'editeur Edit13.pas avec le systeme MS-DOS

Créer un répertoire nome « Edit13 » ou « EDnum » sur le disque dur C:\

Ouvrir invite de commandes MS-DOS : %SystemRoot%\system32\cmd.exe

Commandes Ms-Dos
CLS	Efface l'écran.
DIR	Affiche la liste des fichiers et des sous-répertoires d'un répertoire.
Chdir, CD	Affiche le nom du répertoire en cours ou change le répertoire en cours.
MD	Crée un répertoire.
MKDIR	Crée un répertoire.
RD	Supprime un répertoire.
RMDIR	Supprime un répertoire.
MD	Crée un répertoire.
MKDIR	Crée un répertoire.

Creation
Commande MS-DOS : MD où MKDIR Créer un répertoire C:\>MD [nom du répertoire] [entrée] C:\> C:\>MD Edit13 [entrée] C:\>CD Edit13 [entrée] Créer les sud-répertoires C:\Edit13>MD Donnes [entrée] C:\Edit13>MD Files [entrée]

Unites du programme Edit13
Le répertoire C:\Edit13\ Mettre sur le répertoire C:\Edit13\ tous les fichiers allant l'extension PAS, BLC, TPU Le contenu des répertoire(s) C:\Edit13 \| C:\Edit13\Donnes \| C:\Edit13\Files Plus haut sur « Unîtes du programme éditeur de texte EDIT13 » sur le menu à gauche cliquez sur: Unité d'Initialisation des overlays (1) Unit Init13.pas Répertoire EDIT13 : fichiers et unités de l'éditeur (2) Répertoire de l'éditeur Compilations des unités de l'éditeur (3) Compiler Edit13.exe Notes: Patientez ! vous êtes dans une autre Galaxie. En construction, toutes les sources complètes du Répertoire et programme Edit13.exe & EDnum sur : REPERTOIRE_EDIT13.zip (686 Ko 702 521 octets))

ÉDITEUR EDNUM & EDIT13 1 2 3 4 5 6 7 8 9 10 11 12

ETUDE D'UN ÉDITEUR DE TEXTE ASCII 850-LATIN-I & WINDOWS-1252

Le programme le plus simple qu'on puisse imaginer pour tous les Terriens

hello world

Programmation structurée

La démarche de conception d'un programme

Langages d'assemblage et langages évolués

Algorithme

Programme

Machine

Schéma simplifie d'une machine.

Etude de un éditeur de texte avec Turbo Pascal

Un éditeur de texte

Méthode

Tester un programme

Les Erreurs de programmations

La méthode copier/collé

Programmer un éditeur de texte

Le buffer de l'éditeur

Définition d'un type

Affectation variable

Déclarations des pointeurs sur Turbo Pascal

Crée le buffer en memoire, type pointeur dynamique

Programme Assembleur

Procedures en Langage Assembleur

L'assembleur

La pile en turbo pascal

Le tas

Exemple

Turbo Pascal et les liens avec les fichiers objet.

Turbo Assembleur et Turbo Pascal

Raccourcis de l'éditeur Ednum

Principales Procédures de l'éditeur

Schéma pricipal de l'Éditeur

Codes ASCII DOS & Windows

Le MS-DOS emploi la page de code 850 Multilingue Latin I

La gestion de fichiers

Exemple 1

Exemple 2

Unités de l'éditeur

Compilation d'Edit13.pas en Edit13.exe

Créer un répertoire nome « Edit13 » sur le disque dur C:\

Commande MS-DOS: MD où MKDIR Crée un répertoire

Sud-répertoires

le répertoire C:\Edit13\

Systeme binaire

Arithmetique Binaire

Passage de binaire à décimal

Les additions de nombres binaires

Autre exemple

Les changements de base & Conversion binaire où décimal

Conversion du décimal où binaire

La multiplication en Binaire

Compilation du programme

Créer un répertoire nome « Edit13 » ou « EDnum » sur le disque dur C:\

Commande MS-DOS : MD où MKDIR Créer un répertoire

Créer les sud-répertoires

Le répertoire C:\Edit13\