OpenLLM-France/wikimedia huggingface dataset:
# Programmation Assembleur

* Programmation Assembleur
* Introduction
* Les différents processeurs :
* x86
* PowerPC
* Itanium
* Sparc
* Mips
* ARM
* Alpha
* HP-PA
* SuperH
* 68000
* PIC16F84
* Z80
* Modifier ce modèle
* Retour au livre Programmation
Consultez également ces pages dans d’autres projets Wikimedia :
* Ressources multimédia sur Commons.
* Article encyclopédique sur Wikipédia.
* Définition sur Wiktionnaire.
* Ressources éducatives sur Wikiversité.
Le langage Assembleur ou langage d'assemblage, dit assembleur tout court, est le langage de programmation le plus proche - tout en restant lisible par un être humain - du langage machine utilisé par le (micro)processeur de la machine. Le langage machine exprime les instructions des programmes par des combinaisons de bits, comme
En langage d'assemblage, ces instructions sont représentées par des symboles mnémoniques bien plus lisibles, comme
(qui signifie de mettre la valeur hexadécimale 61 (97 en décimal) dans le registre 'AL'.)
Contrairement à un langage de haut-niveau, il y a une correspondance 1-1 entre le code assembleur et le langage machine, ainsi les ordinateurs peuvent traduire le code dans les 2 sens sans perdre d'information. La transformation du code assembleur dans le langage machine est accomplie par un programme nommé Assembleur, dans l'autre sens par un programme Désassembleur. L'opération s'appelle respectivement, assemblage et désassemblage. Dans un programme réel en Assembleur, c'est un peu plus complexe que cela (on peut donner des noms aux routines, aux variables), et on n'a plus cette correspondance.
Chaque architecture d'ordinateurs a son propre langage machine, et donc son propre langage d'assemblage (l'exemple ci-dessus est pour l'architecture x86 des PC). Ces différents langages diffèrent par le nombre et le type d'opérations qu'ils ont à supporter. Ils peuvent avoir des tailles et des nombres de registres différents, et différentes représentations de type de données en mémoire. Tandis que tous les ordinateurs sont capables de faire les mêmes choses, ils le font de manière différente.
Par ailleurs, il peut exister plusieurs syntaxes pour le même jeu d'instruction, selon les conventions choisies par le fournisseur du programme d'assemblage. L'exemple ci-dessus était donné en syntaxe AT&T, en syntaxe Intel il s'écrit :
La syntaxe la plus populaire est généralement celle utilisée dans la documentation du fabricant du processeur.
# Programmation Algol

Cette page fait partie du livre Programmation
# Programmation Android/Exemples/miniPainter
## Objectif

Le but est de réaliser un mini logiciel de dessin pour Android. Le code est celui de l'ancien fingerpaint pour android 1.1.

## Réalisation
### MainActivity.java

Pour dessiner on a besoin de 4 éléments :
* Bitmap qui regroupe les pixels définissant le trait
* Canvas qui doit contenir tous les traits
* Path : une Primitive (le trait lui même)
* Paint pour décrire la couleur et le style du dessin
Le path est une courbe de bézier qui trace le bitmap.
# Programmation Assembleur/x86

* Programmation Assembleur
* Introduction
* Les différents processeurs :
* x86
* PowerPC
* Itanium
* Sparc
* Mips
* ARM
* Alpha
* HP-PA
* SuperH
* 68000
* PIC16F84
* Z80
* Modifier ce modèle
* Retour au livre Programmation

## Préface

Ce livre a pour ambition de couvrir la programmation en assembleur Intel, celui en usage pour la famille de microprocesseurs x86. L'objectif principal est la connaissance des rouages des ordinateurs compatibles PC.
Le lecteur notera qu'avec l'évolution des microprocesseurs, les noms des instructions peuvent être différents suivant l'architecture qu'elle soit 16-bit, 32-bit ou 64-bits.

## Sommaire

* Introduction
* Registres
* Les flags
* Copie entre registres et mémoire
* Les branchements
* La pile
* Les interruptions
* Opérations arithmétiques et logiques
* Interactions avec les périphériques
* Index
* Conclusion
# Programmation Assembleur/x86/Index

* Programmation Assembleur/x86
* Introduction
* Registres
* Les flags
* Copie entre registres et mémoire
* Les branchements
* La pile
* Les interruptions
* Opérations arithmétiques et logiques
* Interactions avec les périphériques
* Index
* Conclusion
* Modifier ce modèle

## Index des instructions

Cet index des instructions permet de comprendre ce que fait une instruction particulière dans le code source en assembleur x86.

### A

* AAA Ajustement du résultat après addition en BCD
* AAD Ajustement du résultat après division en BCD
* AAM Ajustement du résultat après multiplication en BCD
* AAS Ajustement du résultat après soustraction en BCD
* ADC Addition d'entiers avec la retenue
* ADD Addition d'entiers
* AND Et logique bit à bit

### C

* CALL
* CLC
* CLD
* CLI Bloquer les interruptions
* CMC
* CMP Comparaison d'entiers
* CMPSB
* CMPSD
* CMPSW

### D

* DAA Ajustement du résultat après addition en BCD
* DAS Ajustement du résultat après soustraction en BCD
* DEC Décrémenter
* DIV Division d'entiers non signés

### E

* ESC

### H

* HALT Attendre l'arrivée d'une interruption

### I

* IDIV Division d'entiers signés
* IMUL Multiplication d'entiers signés
* IN
* INC Incrémenter
* INT Appel à une interruption
* INTO et INTO Appel à l'interruption de débordement si OF=1 (Overflow)
* IRET Fin de vecteur d'interruption

### J

* JA
* JAE
* JB
* JBE
* JC
* JCXZ et JCXZ Saut si CX=0
* JE
* JECXZ Saut si ECX=0
* JG
* JGE
* JL
* JLE
* JMP Saut inconditionnel
* JNA
* JNAE
* JNB
* JNBE
* JNC
* JNE
* JNG
* JNGE
* JNL
* JNLE
* JNO
* JNP
* JNS
* JNZ
* JO
* JP
* JPE
* JPO
* JRCXZ Saut si RCX=0
* JS
* JZ

### L

* LAHF et LAHF
* LODSB
* LODSD
* LODSW
* LOOP
* LOOPZ
* LOOPNZ

### M

* MOV
* MOVSB
* MOVSD
* MOVSW
* MUL Multiplication d'entiers non signés

### N

* NEG Changer le signe d'un entier signé
* NOT Inversion de bits

### O

* OR Ou logique bit à bit
* OUT

### P

* POP Dépiler dans un registre
* POPA Dépiler tous les registres
* POPF et POPF Dépiler les indicateurs (Flags)
* PUSH Empiler la veleur d'un registre
* PUSHA Empiler tous les registres
* PUSHF et PUSHF Empiler les indicateurs (Flags)

### R

* RCL Rotation de bits et la retenue vers la gauche
* RCR Rotation de bits et la retenue vers la droite
* REP
* REPZ
* REPNZ
* RET
* RETF
* ROL Rotation de bits vers la gauche
* ROR Rotation de bits vers la droite

### S

* SAHF et SAHF
* SAL Décalage de bits vers la gauche
* SAR Décalage arithmétique de bits vers la droite (préservation du bit de signe)
* SBB Soustraction d'entiers avec la retenue
* SCASB
* SCASD
* SCASW
* SETALC
* SHL Décalage de bits vers la gauche
* SHR Décalage de bits vers la droite
* STC
* STD
* STI Débloquer les interruptions
* STOSB
* STOSD
* STOSW
* SUB Soustraction d'entiers

### T

* TEST Test de bits

### W

* WAIT

### X

* XLAT
* XOR Ou exclusif bit à bit
# Programmation Android

Android est le système d'exploitation opensource de Google à destination des dispositifs mobiles (Smartphones, Tablettes)

## Le framework et les outils
### SDK

Le SDK est un framework pour coder en Java sur Android.
* L'api est ici : http://developer.android.com/reference/packages.html

### NDK

Le NDK est un framework pour coder en C/C++ sur Android.

### ADT

Le Android Developer Toolkit est un outil de développement gratuit basé sur Eclipse permettant de développer directement pour Android. Il comprend dans sa version "bundle" les machines virtuelles nécessaires pour le debug.
* Le plugin ADT pour eclipse est disponible ici : http://developer.android.com/tools/sdk/eclipse-adt.html.
* La bundle est disponible dans le SDK ici : http://developer.android.com/sdk/index.html.

## Coder pour Android

* Ce livre n'est pas un guide de programmation Java.
* Ce wikilivre est un recueil de didacticiels Android commentés.
Pour débuter, il y a un livre gratuit sur OpenClassrooms : Créer des applications pour Android. Ce livre est à jour pour coder sur l'ADT 21.0.1. -> Android JellyBean en Java 1.6 ou plus - voir Ressources
Suivre les didacticiels de ce livre est suffisant pour comprendre la structure d'une application android. La plupart les applications présentées ici fonctionnent en l'état en copiant le code à la racine du ./src conformément à l'arborescence du package et ne nécessitent que peu de modifications dans les "ressources" de l'application, ainsi que dans le code source présenté.

### Permissions

Android est un dispositif protégé qui requiert la validation de l'utilisateur pour leurs exécutions. Une liste des permissions à figurer dans le Manifest est ici : http://developer.android.com/reference/android/Manifest.permission.html

## Didacticiels

* Leçon N°1 : un mini localisateur
* Leçon N°2 : un mini painter

## Ressources

* Android Development Tutorial : http://www.vogella.com/articles/Android/article.html
* Site du zero : http://www.siteduzero.com/informatique/tutoriels/creez-des-applications-pour-android
# Programmation C sharp/Appel de plateforme

L'appel de plateforme permet au code géré (managed code) de faire appel à du code non géré (unmanaged code) contenu dans une bibliothèque externe, utilisant du code natif à la plateforme.

## Syntaxe

La méthode externe doit être déclarée comme statique (mot clé static) et externe (mot clé extern) ce qui signifie qu'il ne faut aucun bloc de code.
Cette méthode doit obligatoirement utiliser l'attribut DllImport de l'espace de nom System.Runtime.InteropServices afin de déclarer le nom de la DLL utilisée et d'autres paramètres optionnels permettant l'interopérabilité avec l'application .Net.
Il est conseillé de déclarer ces méthodes externes dans une classe séparée.

## En savoir plus

* Présentation détaillée de l'appel de plate-forme
# Programmation C sharp/Classe abstraite

Une classe abstraite possède au moins une méthode abstraite ou une propriété abstraite, c'est à dire ne comportant aucune implémentation (pas de code). Une telle classe ne peut être instanciée avec l'opérateur new. Il faut utiliser une sous-classe implémentant les méthodes abstraites de la classe de base.

## Syntaxe

Le mot clé abstract doit précéder la classe abstraite et toutes les méthodes abstraites.
Exemple :

## Implémenter les méthodes abstraites

La classe implémentant les méthodes abstraites de la classe de base doit utiliser le mot clé override, car les méthodes abstraites sont implicitement virtuelles également :
La classe peut ne pas implémenter toutes les méthodes abstraites de la classe de base. Dans ce cas elle est également abstraite, et laisse le soin à ses sous-classes d'implémenter les méthodes abstraites restantes.

## Propriétés abstraites

Il est également possible de déclarer des propriétés abstraites.
Exemple :

## Mode d'accès

Les méthodes et propriétés abstraites peuvent être publiques ou protégées. Puisque les méthodes et propriétés abstraites doivent être implémentées par les sous-classes, il n'est pas possible de les déclarer avec le mot clé private, ou d'utiliser le mot clé sealed avec la classe. De plus les méthodes et propriétés abstraites ne peuvent être statiques.
# Programmation C sharp/Code non vérifié

Le code produit par la compilation d'un programme C# est géré par l'environnement .Net qui effectue diverses vérifications, gère la mémoire en utilisant un ramasse-miette et peut lancer des exceptions en cas d'erreur : référence nulle, divisions par zéro, variable non initialisée, indexation d'un tableau au delà de ses limites.
Le recours à du code non vérifié peut être nécessaire pour utiliser le système d'exploitation, un périphérique accédé par adresse mémoire, ...
Le code non vérifié doit obligatoirement être marqué avec le mot-clé unsafe. Ce qui permet d'empêcher son exécution dans un contexte non sûr (code provenant d'une source non fiable).

## Déclaration

Le mot-clé unsafe peut être ajouté à la déclaration d'une méthode comme dans l'exemple suivant :
Il est également possible de l'ajouter pour un bloc d'instruction seul :

## Pointeurs

Un pointeur est un type qui stocke une adresse vers une donnée du type spécifié par le pointeur. La syntaxe d'utilisation est la même que dans les langages C et C++.

### Déclaration

La déclaration d'un pointeur utilise un type suivi du caractère étoile.
Exemple :

### Adresse d'une variable

Un pointeur peut recevoir l'adresse d'une variable, en faisant précéder la variable du caractère &.
Exemple :

### Déréférencer un pointeur

Un pointeur utilisé directement donnera l'adresse de la variable. Pour utiliser le contenu pointé par le pointeur il faut le déréférencer en le faisant précéder du caractère étoile *.
Exemple :

### Membre d'une classe pointée

Pour accéder à un membre d'un objet pointé il est possible d'utiliser la syntaxe suivante :
Ou d'utiliser l'opérateur flèche équivalent :

### Pointeur et tableau

L'adresse d'un tableau est donnée sans utiliser l'opérateur d'adresse &. Toutefois, il n'est pas possible de modifier l'adresse du tableau afin d'éviter de perdre l'adresse de début du tableau. Le pointeur doit utiliser le mot-clé fixed pour obtenir l'adresse d'un tableau.
Exemple :

## Gestion de la mémoire

Le mode non vérifié permet de modifier le comportement du ramasse-miettes.

### Éviter le déplacement par le ramasse-miettes

Le mot clé fixed sert à éviter qu'un tableau ou un objet ne soit déplacé en mémoire par le ramasse-miettes :
* pour empêcher le déplacement durant l'exécution d'une instruction ou un bloc d'instructions :
* pour déclarer un tableau de taille fixe (non déplacé en mémoire) :
Exemple :

### Taille d'une variable ou d'un type

L'opérateur sizeof s'utilise dans un contexte de code non vérifié, comme une fonction renvoyant le nombre d'octets occupés par la variable ou le type spécifié.
Exemple :

### Allocation sur la pile

Le mot-clé stackalloc permet d'allouer un objet ou un tableau sur la pile plutôt que sur le tas. Dans ce cas, cet objet ou tableau n'est pas géré par le ramasse-miettes. Il est donc possible d'utiliser un pointeur sans utiliser le mot-clé fixed.
Syntaxe : le mot-clé stackalloc s'utilise à la place du mot-clé new pour initialiser des pointeurs locaux.
Exemple :
# Programmation C sharp/Bibliographie et liens
## Liens internes

* Programmation .Net

## Liens externes

* (français) La documentation MSDN de Visual C#
* (français) Centre de Développement C# - Site MSDN
* (français) Guide de programmation C#
* (français) Un blog sur .Net
* (anglais) C# Language Specification 4th edition
* (anglais) Encyclopédie collaborative sur C# et .Net
* (anglais) Page du standard ISO
* (anglais) Page du standard ECMA
* (anglais) C# Help : aide aux développeurs
* (anglais) Vidéos d'apprentissage de C#, Visual Studio express, et .Net
* (anglais) Vidéos d'apprentissage de C#, Visual Studio, et .Net

## Livres

* (français) Benoît Prieur - Programmation en C# : préparation aux certifications MCSA - Examen 70-483 - Éditions ENI - 2018 - 448 pages - (ISBN 978-2409013829)
* (français) Pierre-Yves Saumont, Antoine Mirecourt - Introduction à C# - Éditions Eyrolles - 2001 - 292 pages - (ISBN 2-7464-0301-3)
* (français) Gérard Leblanc - C# et .NET - Éditions Eyrolles - 2002 - 710 pages - (ISBN 2-212-11066-9)
* (français) Gérard Leblanc - C# et .NET Version 2 - Éditions Eyrolles - 2006 - (ISBN 2-212-11778-7)
* (français) Donis Marshall, Christine Eberhardt, Philippe Beaudran, Dorothée Sittler - Visual C# 2005 - Collection Microsoft Press, Éditions Dunod - 2006 - (ISBN 2-10-049942-4)
* (français) Mickey Williams - Manuel de référence Microsoft Visual C# - Collection Langages et Programmation, Éditions Dunod - 2002 - 784 pages - (ISBN 2-10-006659-5)
* (français) Tom Archer - Formation à C# - Collection Formation à..., Éditions Dunod - 2001 - 400 pages - (ISBN 2-84082-864-2)
* (anglais) Adrian Kingsley-Hughes, Kathie Kingsley-Hughes - C# 2005 Programmer's Reference - Éditions Wrox - 2006 - (ISBN 0-470-04641-4)
* (anglais) Simon Robinson, Christian Nagel, Karli Watson, Jay Glynn, Morgan Skinner, Bill Evjen - Professional C# (3ème édition) - Éditions Wrox - 2004 - (ISBN 0-7645-5759-9)
* (anglais) Ben Albahari, Peter Drayton, Brad Merrill - C# Essentials (2ème édition) - Éditions O'Reilly Media - 2002 - (ISBN 0-5960-0315-3)
* (anglais) Andrew Krowczyk, Zach Greenvoss, Christian Nagel, Ashish Banerjee, Thiru Thangarathinam, Aravind Corera, Chris Peiris, Brad Maiani - Professional C# Web Services: Building .NET Web Services with ASP.NET and .NET Remoting - Éditions Wrox Press - 2001 - 550 pages - (ISBN 1-8610-0439-7)
* (anglais) Matthew MacDonald - Pro .NET 2.0 Windows Forms and Custom Controls in C# - Éditions Apress - 2005 - 1080 pages - (ISBN 1-59059-439-8)
# PyQt/QComboBox
## Description

Cette classe permet d'afficher une liste d'éléments sous forme de liste déroulante avec, lorsque la liste n'est pas déroulée, uniquement l'élément sélectionné affiché. Il est possible de construire un objet permettant l'édition des éléments ou non (l'utilisateur peut introduire ses propres éléments) en spécifiant un paramètre au constructeur. De plus, un tel objet peut contenir des éléments textuels ou des images (pixmap). Un objet QComboBox émet deux signaux : activated lorsqu'un élément a été sélectionné et highlighted lorsqu'un élément est mis en évidence dans la liste.

## Exemple

* PyQt3.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qcombobox.py
* # Programme exemple pour la classe QComboBox
* from qt import *
* import sys
* class Demo(QApplication) :
* def init (self,args) :
* QApplication. init (self, args)
* # widget principal, il s'agit d'une fenˆetre de dialogue
* self.dialog = QDialog(None, "Dialog")
* self.cbox1 = QComboBox(self.dialog, "cbox1")
* self.cbox1.insertItem("choix 1")
* self.cbox1.insertItem("choix 2")
* self.cbox1.insertItem("choix 3")
* # l'utilisateur peut entrer son propre texte
* self.cbox1.setEditable(True)
* # choix par défaut : le troisième ( ! offset by one !)
* self.cbox1.setCurrentItem(2)
* self.connect(self,SIGNAL("lastWindowClosed"),self,SLOT("quit"))
* self.dialog.show
* self.exec loop
* if name == "__main__" :
* x = Demo(sys.argv)
* PyQt4.*
* #!/usr/bin/python
* # -*- coding : utf-8 -*-
* # qCombobox.py
* # Programme exemple pour la classe QComboBox#
* from PyQt4.QtGui import *
* from PyQt4.QtCore import *
* import sys
* class Demo(QApplication) :
* def __init__(self, args) :
* QApplication.__init__(self,args)
* # widget principal, il s'agit d'une fenêtre de dialogue
* self.dialog = QDialog
* self.dialog.setWindowTitle("Dialog")
* self.Combo1=QComboBox
* self.Combo1.setObjectName("Liste 1")
* self.Combo2=QComboBox
* self.Combo1.addItem ("choix 1")
* self.Combo1.addItem ("choix 2")
* self.Combo1.addItem ("choix 3")
* self.Combo2.setObjectName("Liste 2")
* self.Combo3=QComboBox
* self.Combo3.setObjectName("Liste 3")
* # le bouton Combo3 n'est pas modifiable
* self.Combo3.setDisabled(True) ;
* # espace entre les boutons
* self.vbox = QVBoxLayout
* self.vbox.addWidget(self.Combo1)
* self.vbox.addWidget(self.Combo2)
* self.vbox.addWidget(self.Combo3)
* self.vbox.addStretch(1)
* self.dialog.setLayout(self.vbox)
* self.dialog.show
* self.connect(self,SIGNAL("lastWindowClosed"),self,SLOT("quit"))
* self.exec_
* if __name__ == "__main__" :
* app=Demo(sys.argv)
# PyQt/QLabel
## Description

Cette classe permet d'afficher au choix du texte ou une image, tout en spécifiant plusieurs paramètres concernant l'apparence visuelle de l'objet. Il est possible d'afficher du texte simple, du texte contenant des informations de mise en page, une image (pixmap), une vidéo, un nombre (converti en chaîne de caractères automatiquement) ou bien mettre un QLabel vide. Les changements concernant l'apparence de l'objet portent sur l'alignement dans son widget parent et l'indentation du texte. De plus, il est possible de définir des touches accélératrices permettant de transférer le focus du clavier.
Il est possible de mettre simplement en forme le texte. Qt utilise pour cela un sous-ensemble de balises HTML. Pour de plus amples informations consultez la page http://qt-project.org/doc/qt-4.8/q3stylesheet.html. html qui défini l'ensemble des balises disponibles et leurs effets sur le texte.

## Exemple

* PyQt3.*
* #!/usr/bin/python
* # -*- coding: utf-8 -*-
* # qlabel.py
* # Programme exemple pour la classe QLabel
* from qt import *
* import sys
* class Demo(QApplication) :
* def init (self,args) :
* QApplication. init (self, args)
* # widget principal, il s'agit d'une fenˆetre de dialogue
* self.dialog = QDialog(None, "Dialog")
* # premier élément textuel, nom de l'objet = ”text1”
* self.text1 = QLabel(self.dialog,"text1")
* # taille de l'objet et positionnement absolu
* self.text1.setGeometry(QRect(120,80,181,71))
* # le texte `a afficher
* self.text1.setText("Le texte \ntient sur \nplusieurs lignes !")
* # mise en page : très facile !
* self.text2 = QLabel(self.dialog,"text2")
* self.text2.setText("<h1><span style="color:red">Et la mise en page\n"+ " est possible</span></h1>")
* self.text2.setGeometry(QRect(120,220,191,101))
* self.connect(self,SIGNAL("lastWindowClosed"),self,SLOT("quit"))
* self.dialog.show
* self.exec loop
* if name == "__main__" :
* x = Demo(sys.argv)
* PyQt4.*
* #!/usr/bin/python
* # -*- coding: utf-8 -*-
* # qlabel.py
* # Programme exemple pour la classe QLabel
* from PyQt4.QtGui import *
* from PyQt4.QtCore import *
* import sys
* class Demo(QApplication) :
* def __init__(self,args) :
* QApplication.__init__(self, args)
* # widget principal, il s'agit d'une fenˆetre de dialogue
* self.dialog = QDialog
* self.dialog.setWindowTitle("Dialog")
* # premier élément textuel, nom de l'objet = ”text1”
* self.text1 = QLabel(self.dialog)
* # taille de l'objet et positionnement absolu
* self.text1.setGeometry(QRect(120,80,180,70))
* # le texte `a afficher
* self.text1.setText("Le texte \ntient sur \nplusieurs lignes !")
* # mise en page : très facile !
* self.text2 = QLabel(self.dialog)
* self.text2.setText("<h1><span style="color:red">Et la mise en page<br>"+ " est possible</span></h1>")
* self.text2.setGeometry(QRect(120,220,250,100))
* self.connect(self,SIGNAL("lastWindowClosed"),self,SLOT("quit"))
* self.dialog.show
* self.exec_
* if __name__ == "__main__" :
* x = Demo(sys.argv)