VBA.language.txt

                                  ┏━━━━━━━━━┓
                                  ┃   VBA   ┃
                                  ┗━━━━━━━━━┛

                                  ┌─────────────┐
                                  │   GENERAL   │
                                  └─────────────┘

FUTUR ==>               #Sera remplacé par VB.Net.
                        #Version actuelle VBA 7.0 (Office 2010-2013) vs VBA 6.0 (Office 2000-2007)
                        #Principalement 7.0 ajoute support 64 bits.

COMPILATION ==>         #Byte-code compiling, effectué automatiquement à chaque complétion d'une ligne de commande.
                        #Le byte-code (P-code) est enregistré en tant que stream au sein même du fichier Excel, Powerpoint,
                        #etc.
                        #L'accès à un object model pour une application donné passe par le procédé d'"OLE Automation"
                        #Top level est un PROJECT, en général toujours implicite, suivi des MODULE.
                        #Pour fonctions, top level est VBA., qu'on peut toujours omettre.

'COMMENT                #Commentaires
COMMANDE
COMMANDE:               #Séparateurs de fin
COMMANDE _
 SUITE                  #Trailing newlines.

STATEMENTS HORS         #  - Compiler directives
PROCEDURE ==>           #  - Déclaration

#If TEST Then
  ...
[#Else[If TEST Then]]
  ...                   #TEST ne peut utiliser que des variables déclarées via #Const VAR = VAL (qui ne sert qu'à ça).
#End If                 #Il s'agit de compiler directives. Peuvent être dans une procédure.

CASE ==>                #Case insensitive language

Weak typing             #Dont conversions implicite STR <-> NUM.
                        #Si STR -> NUM impossible, runtime error. STR -> NUM prend en compte locale courante.
                        #NULL -> STR runtime error.
                        #Conversion explicite via CTYPE : CBool, CByte, CCur, CDate, CDbl, CInt, CSng, CVar(VAL).
                        #Str(NUM) est comme CStr, sauf que même un leading space si chiffre positif, et utilise virgule "."
                        #toujours, et non virgule de la locale.
                        #Val(NUM) est comme CDbl, sauf qu'ignore les blanks et les caractères suivant le premier caractère
                        #non-NUM.
Static type checking    #Mais Dynamic possible via les VARIANTE

SCOPES ==>              #VAR :
                        #  - public :
                        #    - dans procédure (déf), lexical scoping (dispo dans même procédure)
                        #    - hors procédure, général VAR (dispo dans tout module, toute procédure) (si autre module, utiliser
                        #      MODULE.VAR)
                        #  - static : dans procédure only. Comme public sauf que conserve valeur après fin procédure.
                        #    Notamment utile lors récursions.
                        #  - private : hors procédure only (déf), C-static VAR (dispo dans toute procédure, ce module
                        #    uniquement)
                        #FONC :
                        #  - static : fait que toutes variables déclarées sont static
                        #  - private : FONC utilisable dans ce module uniquement
                        #  - public (déf) : FONC utilisable dans tout module
                        #Modules : procédures sont organisées en modules (équivalent d'un fichier source *.c).
                        #Si statement, Option Private Module, toutes FONC sont Private

MODULES ==>             #En général (par ex. pour Office) :
                        #  - Object modules :
                        #    - lié à un Object (Worksheet, Chart, Slide, etc.)
                        #    - pour Forms inséré de cet Object
                        #    - Public procédures dispo pour tout autre module, via OBJECT.FONC
                        #    - parfois également module spécial comme ThisWorkbook (Excel) :
                        #  - UserForm modules :
                        #    - lié à un UserForm
                        #    - pour Forms ce cet UserForm
                        #  - Modules normaux :
                        #    - à préférer
                        #    - définition des fonction Excel persos ici
                        #    - Public procédures dispo pour tout autre module.
                        #  - Class module ?

                                  ┌───────────┐
                                  │   TYPES   │
                                  └───────────┘

TYPES ==>               #   - Numeric NUM :
                        #     - Integer (SHORT)
                        #     - Long (INT)
                        #     - LongLong (LONG LONG) : seulement VBA 7.0 ?
                        #     - Single (FLOAT)
                        #     - Double (DOUBLE)
                        #     - &O et &H devant NUM pour des nombre octaux et hexa, avec un autre & à la fin
                        #   - Boolean : True ou False. Coertion NUM : False est 0, True <> 0 (-1 par déf)
                        #   - String (STR) :
                        #     - dont fixed-sized String, déclarée via As String * SIZE.
                        #     - initialisée avec des espaces.
                        #     - tronquée si affectée avec plus, padded avec espaces si affectée avec moins.
                        #   - Byte : comme R
                        #   - Currency : comme un LONG LONG
                        #   - Date : VAL s'écrit #MM/DD/YYYY# ou #1 Jan 1908#. Convertis en NUM, devient nombre de jours depuis
                        #     1/1/1900
                        #   - Object : parent de tout objet non-fondamental
                        #     - Object non initialisé a valeur Nothing
                        #   - Variant :
                        #     - Valeurs spéciales (test avec IsTYPE()) :
                        #       - NULL    : constante NULL (no valid data). Comme Ind. de logique tribooléenne si utilisé en
                        #                   comparaison.
                        #       - Empty   : lorsque VARIANTE n'a pas été initialisée. Constante Empty disponible aussi.
                        #       - Error   : créé par CVError(UINT), et en général renvoyé par fonction comme error code.
                        #         - Missing : lorsque VARIANTE est argument optionnel, sans valeur par défaut, non donné.
                        #   - STRUCT, ou UserDefinedType, de type personnalisé
                        #   - Collection, array de types divers
                        #Il semble que le type sous-jacent de base soit en fait Variante, avec des sous-types nommés vbTYPE
IsTYPE(VAL)             #TYPE possibles : Numeric, Boolean, Object, Missing, Null, Empty, Error, Array, Date
                        #IsNumeric fonctionne sur BOOL, et sur "32.34", mais pas "32.34 b"
TypeName(VAL)           #Renvoie type sous forme de STRING
VarType(VARIANTE)       #Renvoie type sous-jacent, parmi : vbTYPE, avec aussi vbDataObject (VARIANTE de VARIANTE_ARRAY) et
                        #vbArray

[SCOPE] Enum ENUM
  VAR = UINT...
End Enum                #ENUM ne sont que des const NUM. A additionné pour or'd (sont des puissances de 2)

OPERATIONS BASIQUES ==> #NUM :
                        #  + - * /
                        #  ^ mod \ (integer division)
                        #  < <= > >= = <>
                        #BOOL :
                        #  Not Or And Xor
                        #  Imp (Comme =, sauf que coerce en BOOL) Eqv (pareil, sauf que comparaison avec NULL donne toujours
                        #  NULL)
                        #  TEST n'utilise pas de (  ). Pour distinguer assignation de test d'égalité, utiliser CBool( )
                        #STR :
                        #  < <= > >= = <>
                        #  Like (comme =~ pour globbing)
                        #  Option Compare Binary (déf) : comparaison ASCII, vs. Option Compare Text qui lui est case-insensitif
                        #OBJECT :
                        #  Is (comparaison de référence)

[SCOPE] [WithEvents] VAR#Déclaration de variable (déf: VARIANTE).
[([[UINT1 To]UINT2]...)]#Optionnel, mais variable non-déclarée et affectée (par un objet ou type fondamental) sera considérée
[As [New] TYPE]...      #VARIANTE.
                        #Par conséquent, le type est implicitement deviné ce qui donne des surprises pour les types
                        #non-fondamentaux.
                        #Pour les types fondamentaux, choix entre possibilité d'une variable au type dynamique (alors pas de
                        #déclaration et donc VARIANTE) ou statique, donc safe (préférer alors déclaration via VAR[CHAR] = VAL)
                        #Si (), création d'array fixes uni ou multi-dimensionnelles :
                        #  - Index UITN1 commence par défaut à 0 (modifiable avec "Option Base 1", devant être dans un module,
                        #    avant toute procédure).
                        #  - Si pas d'UINT2, array dynamique :
                        #    - Pour ensuite donner/changer dimension faire ReDim : même syntaxe que Dim. ReDim réinitialise
                        #      données sauf si mot Preserve après ReDim, auquel cas seule last dimension size peut être
                        #      modifiée.
                        #    - ReDim can't change data type, et ne peut être effectué que sur une array dynamique, mais autant
                        #      de fois que l'on veut.
                        #  - Se souvenir que VARIANTE (non-ARRAY) peut contenir des ARRAY de tailles différentes successivement
                        #    aussi
                        #WithEvents : à mettre si l'on doit utiliser les event handlers de cette classe ???
                        #New : initialise un Object, de sorte que l'on peut l'utiliser sans faire de Set VAR = VAL préalable???
                        #SCOPE : peut être Dim (utilisation du défaut), Public, Private ou Static. Cf plus haut.
                        #Si Option Explicit, déclarations obligatoires.
VAR[CHAR] = VAL         #Comme VAR = VAL, mais déclare type aussi via CHAR :
                        #  - DOUBLE : #
                        #  - CURRENCY : @
                        #  - INT : %
                        #  - LONG : &
                        #  - LONG LONG : ^
                        #  - SINGLE : !
                        #  - STRING : $
[SCOPE] Const VAR
[As TYPE] = VAL         #VAR const. Private par défaut.

Set CLASS = VAL         #Affectation d'objets.
[Let] VAR = VAL         #Affectation de variable de type fondamental
VAR = ARRAY             #Impossible, sauf :
                        #  - si VAR est une VARIANTE
                        #  - et que VAR n'est pas une ARRAY
                        #  - VAR devient alors une VARIANTE simple contenant une ARRAY (et non une ARRAY de VARIANTE simples).
                        #    Reassignable avec nouvel array alors.

VAR                     #Déférencement normal
VAR(UINT...)            #Déférencement d'array
Array([VAL...])         #Renvoie une VARIANTE_ARRAY
Erase ARRAY             #Initialise array dynamique à 0 dimensions, ou initialise valeurs d'un array non-dynamique.
L|UBound(ARRAY[,UINT])  #Renvoie index min/max de la dimension UINT (déf: 1) d'ARRAY. Semble propre à VBA 7.0

Collection              #Array de types divers. A créer vide via Dim VAR As New Collection. Commence à index 1.
COLLECTION.Add(ITEM     #Rajoute un élément ITEM.
[,KEY,BEFORE,AFTER])    #KEY est une STRING utilisée par BEFORE ou AFTER pour le positionnement si ces derniers sont une STRING
                        #S'ils sont un NUM, alors positionnement numérique
COLLECTION.Remove(INDEX)#INDEX peut être position NUM ou key STRING.
COLLECTION.Item(INDEX)  #Déférencement. Pareil pour INDEX.
COLLECTION.Count        #Renvoie taille.

Type STRUCT             #Création de STRUCT. Accès aux membres via STRUCT.VAR
  VAR [as TYPE]...      #STRUCT doivent être private dans un object module.
End Type                #STRUCT ne peuvent être arguments/return type que de procedures private

Private Function FONC()
As STRUCT
  FONC.VAR = VAL...
End Function            #Il est bon de creer une fonction d'initialisation pour les STRUCT.

CONSTRUCTOR ==>         #Il ne semble pas y en avoir. Il semble que c'est le getter des autres classes renvoyant une classe,
                        #qui sont en charge de construire la classe (et donc de prendre arguments de construction)

Me                      #Référence à l'objet courant (par ex. dans un handler)

                                  ┌────────────────┐
                                  │   PROCEDURES   │
                                  └────────────────┘

PROCEDURE ==>           #Sub, Function ou Property.

[Call] FONC([ARGS...])  #Execution de FONC
                        #Named parameter peut être fait via NAME:=ARG. Args suivants doivent être named parameters alors.
FONC [ARGS...]          #Même chose. Plus simple, mais ne marche pas quand :
                        #   - autre FONC() dans les ARGS
                        #   - utilisation de FONC(...).MEMBRE
                        #Cependant, FONC() sans argument est à proscrire, au profit de FONC

[SCOPE...] Sub FONC     #Declaration de routine. QUAL peut être :
([QUAL...]              #   - ByRef (déf) : par référence
VAR[()][as TYPE]...)    #   - ByVal : par valeur
  ...                   #   - Optional. Est Missing si manquant.
  [Exit Sub]...         #   - ParamArray : argument variadique final, ARRAY de VARIANT (pas affecté par OptionBase)
  ...                   #Si (), une array est passée (toujours par référence)
End Sub                 #TYPE est par défaut VARIANT
                        #SCOPE : cf plus haut
[SCOPE...] Function     #Différence Function et Sub : Sub ne peut pas renvoyer de value.
FONC(ARGS) [As TYPE[()]]#La VAL placée dans FONC est renvoyée (FONC = 0 par défaut)
        ...             #Type de FONC est VARIANTE en faite.
PROCEDURE ==>           #Sub, Function ou Property.

        [FONC = VAL]
        [Exit Function]
        ...
End Function

Property Get|Set|Let    #Comme Sub et Function (getter,setter,???). Je ne comprends pas différence.

End                     #Fin du programme

                                  ┌────────────────┐
                                  │   STRUCTURES   │
                                  └────────────────┘

IDENTATION ==>          #Les blocs sont indiqués par identation

If TEST Then
  ...
[Else
  ...]
[Else If TEST
  ...]
End If
If TEST Then ...        #Possible d'éviter End If si tout sur même ligne (avec éventuellement des :)

For VAR = NUM To NUM2
[Step NUM3]
  ...
  [Exit For]            #Equivaut en C à for ( VAR = NUM ; VAR <= NUM2 ; VAR += NUM3 )
  ...                   #Step peut être négatif, auquel cas test est <=. Sinon est >=
Next [VAR]              #VAR est utile que lors de For nested

For Each VAR in
ARRAY/COLLECTION
  ...
  [Exit For]
  ...
Next                    #Si ARRAY, VAR doit être VARIANTE. Si COLLECTION, doit être VARIANTE ou OBJECT (non type fondamental)

Do Until|While TEST
  ...
  [Exit Do]
  ...
Loop

Do
  ...
  [Exit Do]
  ...
Loop Until|While TEST

While TEST
  ...
Wend                    #Comme Do While. Déprécié

Choose(UINT,VAL...)     #Equivaut à indexer élément UINT d'array composé de VAL... Si en dehors, renvoie NULL

Select Case VAL
  Case VAL2...
    ...                 #Select loop. Case Else est val par défaut.
  Case Else             #VAL2 peut être :
    ...                 #  - Is <,>,<>,=,<=,>= VAL. VAL tout court est Is = VAL
End Select              #  - VAL1 To VAL2 : range de NUM ou STR

Switch([TEST,VAL]...)   #Renvoie première VAL dont son TEST est True

GoTo, GoSub
On TEST GoTo|GoSub      #Abominations

                                  ┌────────────┐
                                  │   ERRORS   │
                                  └────────────┘

On Error GoTo LABEL     #Signifie que si la fonction courante emet une runtime error, jump to error handler LABEL.
  ...                   #LABEL est une ligne seule avec LABEL:
                        #Si LABEL est 0, disable previous error handler
                        #GoTo LABEL peut être Resume Next, signifiant alors d'ignorer erreur et de continuer
                        #Error handler peut se terminer par :
                        #  - End ou autre
                        #  - Resume 0, retournant au statement problématique
                        #  - Resume Next, allant après le statement problématique
                        #Error codes sont :
                        #  - 3:  Return without GoSub
                        #  - 5:  Invalid procedure call or argument
                        #  - 6:  Overflow
                        #  - 7:  Out of memory
                        #  - 9:  Subscript out of range
                        #  - 10: This array is fixed or temporarily locked
                        #  - 11: Division by zero
                        #  - 13: Type mismatch
                        #  - 14: Out of string space
                        #  - 16: Expression too complex
                        #  - 17: Can't perform requested operation
                        #  - 18: User interrupt occurred
                        #  - 20: Resume without error
                        #  - 28: Out of stack space
                        #  - 35: Sub or Function not defined
                        #  - 47: Too many DLL application clients
                        #  - 48: Error in loading DLL
                        #  - 49: Bad DLL calling convention
                        #  - 51: Internal error
                        #  - 52: Bad file name or number
                        #  - 53: File not found
                        #  - 54: Bad file mode
                        #  - 55: File already open
                        #  - 57: Device I/O error
                        #  - 58: File already exists
                        #  - 59: Bad record length
                        #  - 61: Disk full
                        #  - 62: Input past end of file
                        #  - 63: Bad record number
                        #  - 67: Too many files
                        #  - 68: Device unavailable
                        #  - 70: Permission denied
                        #  - 71: Disk not ready
                        #  - 74: Can't rename with different drive
                        #  - 75: Path/File access error
                        #  - 76: Path not found
                        #  - 91: Object variable or With block variable not set
                        #  - 92: For loop not initialized
                        #  - 93: Invalid pattern string
                        #  - 94: Invalid use of Null
                        #  - 96: Unable to sink events of object because the object is already firing events to the maximum
                        #        number of event receivers that it supports
                        #  - 97: Can not call friend function on object which is not an instance of defining class
                        #  - 98: A property or method call cannot include a reference to a private object, either as an
                        #        argument or as a return value
Err.Raise NUM           #Raise une exception dont l'error code est NUM. Pour un error code non standard, on peut aussi modifier
                        #la description de la pop up avec Err.Description = STRING avant.
                        #NUM devrait être, pour un non-standard, entre 513 et 65535. Si dans un class module, l'additionner à
                        #vbObjectError
Err.Number              #Numéro d'une exception (0 si rien). Remis à 0 après un Resume Next, un Exit ou un Err.Clear

                                  ┌────────────┐
                                  │   EVENTS   │
                                  └────────────┘

Private Sub OBJECT_EVENT
([ARGS])                #Définit un EVENT (si un tel EVENT pour OBJECT existe)
  ...                   #ARGS doit matcher définition et être ByVal.
End Sub                 #OBJECT le nom de la CLASSE. Doit être un OBJECT module, et dans ce module (ex: Chart, Sheet, etc.).

                                  ┌────────────┐
                                  │   AUTRES   │
                                  └────────────┘

DoEvents()              #Yield thread courant

                                  ┌───────────┐
                                  │   DEBUG   │
                                  └───────────┘

Stop                    #Stoppe comme avec un watch point (debugging purpose only)
Debug.Print VAL         #Imprime dans l'intermediate window du VBA IDE
Debug.Assert TEST       #Si FALSE, effectue un Stop

IDE Functions ==>       #  - watch points (expression et variables)
                        #  - break points
                        #  - call stack
                        #  - documentation de l'object model
                        #  - chiffrement du source code (mais bytecode encore dispo)

                                  ┏━━━━━━━━━━━━━━━┓
                                  ┃   FUNCTIONS   ┃
                                  ┗━━━━━━━━━━━━━━━┛

                                  ┌───────────┐
                                  │   MATHS   │
                                  └───────────┘

Sgn(NUM)                #Renvoie signe de NUM (-1, 0 ou 1)
Int(NUM)                #Troncature vers -Inf
Fix(NUM)                #Troncature vers 0
Abs(NUM)
Round(DOUBLE[,INT])     #Arrondi à INT décimales (déf: 0)
Sqr(DOUBLE)
Exp(DOUBLE)
Log(DOUBLE)
Rnd([NUM])              #PRNG selon U(0,1). NUM :
                        #  - <0 : seed est NUM
                        #  - 0 : seed est last number
                        #  - >0 (déf) : prochain nombre dans le cycle
                        #Toujours utilisé Randomize([NUM]) avant, qui définit une seed (déf: le system time)
Cos(NUM),Sin(NUM),
Tan(NUM),Atn(NUM)

                                  ┌─────────────┐
                                  │   STRINGS   │
                                  └─────────────┘

Len(STR)                #Length

STR & STR2              #Concaténation
Left(STR,UINT)          #Renvoie UINT premiers charactères (si dépasse taille, pas d'erreur)
Right(STR,UINT)         #Inverse
Mid(STR,UINT1[,UINT2])  #Renvoie UITN2 caractères (déf tous) depuis position UINT1 dans STR. En écriture possible.
LSet(STR) = STR2
RSet(STR) = STR2        #STR devient STR2, mais aligné à gauche/droite, selon une width de Len(STR)
Split(STR[, CHAR
[, UINT]])              #Renvoie STR découpé selon le délimiteur CHAR (déf " ") sous un ARRAY de taille max UINT.
Join(ARRAY[,CHAR])      #Renvoie concaténation d'ARRAY, avec comme délim CHAR (déf " ")

InStr(STR,STR2)         #Renvoie position de première occurence de STR2 dans STR (0 si aucun)
InStrRev(STR,STR2)
Replace(STR,STR2,STR3   #Dans STR, remplace STR2 par STR3. Pour un max de UINT2 fois (déf: ∞). Commence à la position UINT
[,UINT[,UINT2]])        #de STR.
Filter(ARRAY,STR[,BOOL])#Renvoie un ARRAY2 des éléments d'ARRAY contenant (ou non si BOOL False) STR.

UCase(STRING)
LCase(STRING)           #Changement de casse
StrConv(STRING, ENUM)   #Changement selon ENUM : vbLowerCase, vbUpperCase, vbProperCase (CamelCase), vbUnicode, vbFromUnicode
[R][L]Trim(STRING)      #Enlève leading/trailing whitespaces
StrReverse(STRING)

String(UINT,CHAR)       #Renvoie une STRING répétant UINT fois CHAR

Format(VAL,STRING       #Sorte de printf().
[,FIRSTDAYOFWEEK,       #STRING :
FIRSTWEEKOFYEAR])       #  - EXPR[;EXPR]... :
                        #    - pour VAL numérique, si EXPR2, EXPR2 est pour nombres négatifs. Si EXPR3, EXPR3 est pour 0.
                        #      Si EXPR4, EXPR4 est pour NULL.
                        #    - pour VAL STRING, si EXPR2, EXPR2 est pour "" et NULL
                        #Pour :
                        #  - VAL STRING :
                        #    - caractère littéral
                        #    - & ou @ remplace avec le prochain caractère de VAL. Si plus de caractère, & donne "" et @ " ".
                        #      Après fin d'EXPR, si encore des caractères dans VAL, sont tous mis.
                        #    - ! : prend les caractères de VAL de droite à gauche et non l'inverse
                        #    - < ou > : force lowercase/uppercase pour ensemble de VAL
                        #  - VAL NUM :
                        #    - caractère littéral
                        #    - 0 ou # : comme & ou @ pour STRING, mais avec "" et "0"
                        #    - . : decimal separator
                        #    - % : multiplie VAL par 100
                        #    - , : thousands separator
                        #    - : : time separator
                        #    - / : date separator
                        #    - e- e+ E- E+ : scientific format
                        #  - VAL DATE : par exemple hh:mm:ss
                        #STRING peut aussi être l'un des types par ex possible dans Excel, comme "Short Date", etc.

Chr(UINT)               #Renvoie CHAR numéro ASCII UINT
Asc(CHAR)               #Renvoie numéro ASCII UINT de CHAR
Hex(NUM)
Oct(NUM)                #Renvoie NUM sous forme de STRING avec valeur hexa ou octale

                                  ┌───────────┐
                                  │   DATES   │
                                  └───────────┘

Now()                   #Renvoie DATE courate.
Date = DATE             #Change DATE system.
Time = DATE
DateSerial
(YEAR,MONTH,DAY)        #Renvoie une DATE
DateValue(STRING)       #Renvoie une DATE
TimeSerial,TimeValue    #Pareil pour heure.
Year,Month,MonthName,
Weekday,Day,Hour,Minute,
Second(DATE)            #L'extrait sous forme d'UINT/STRING

                                  ┌────────────────┐
                                  │   FILESYSTEM   │
                                  └────────────────┘

FILE DESCRIPTOR ==>     #STRING sous forme "#NUM". NUM est souvent obtenu via FreeFile. Ensuite on peut faire #VAR directement
                        #pour un argument FD (et non "#" & NUM). Ex : FileNo = FreeFile, puis Open ... As #FileNo
CHEMIN ==>              #Préférer "/". "." et ".." possibles.
                        #PWD est par défaut celui du fichier courant.
Open PATH For MODE      #Ouvre un fichier (manipulé via le FD), dont répertoires.
[Access ACCESS] [LOCK]  #MODE : Append, Binary, Input, Output, Random
As FD                   #ACCESS : Write, Read ou Read Write
                        #LOCK : pour multithreading, Shared (déf), Lock Write, Lock Read ou Lock Read Write
                        #Si non-existant et que non-Input, crée le fichier. Sinon erreur.
Close [FD]              #Close les fichiers ouverts (déf tous) (clean les buffers et libère les locks)
Reset                   #Equivaut à Close ?

Dir(PATH[,ENUM])        #Renvoie PATH s'il correspond à un fichier existant et régulier. Conditions plus larges possibles via
                        #ENUM (or'd) :
                        #  - vbNormal (déf)
                        #  - vbDirectory : répertoire
                        #  - vbHidden : fichier caché aussi
                        #  - vbReadOnly : fichier read-only aussi
FileCopy(PATH,PATH2)    #Copy fichier PATH vers PATH2. Tous deux ne doivent pas être ouverts, ni des DIR.
Kill PATH               #Supprime fichier. Ne doit pas être ouvert, ni un DIR.
Name PATH As PATH2      #Déplace un fichier. Tous deux ne doivent pas être ouverts, ni PATH2 un DIR.
MkDir PATH
RmDir PATH              #Seulement si DIR vide

CurDir [PATH]           #Renvoie $PWD pour drive STRING (défaut drive courant)
ChDir PATH              #Change $PWD. Si drive différent, change $PWD de ce drive, mais ne change pas drive courant.
ChDrive PATH            #Change drive courant.

FileLen PATH            #Renvoie taille du fichier.
FileDateTime PATH       #Renvoie mtime sous forme de DATE
GetAttr PATH            #Renvoie ENUM (cf plus haut vbNormal, etc.)
SetAttr PATH, ENUM

Get(FD[, UINT], VAR)    #Met CHAR lu dans FD à position UINT (défaut get pointer) dans VAR.
Put(FD[, UINT], VAR)    #Inverse.

Print FD STR
Width FD UINT           #Impose une largeur de colonnes.

                                  ┌────────────┐
                                  │   SYSTEM   │
                                  └────────────┘


Shell(STRING[,ENUM])    #STRING est le PATH d'un programme, suivi éventuellement d'arguments. L'exécute via le shell.
                        #ENUM indique focus, etc. : vbHide (déf, toujours focus), vbNormal[Non]Focus, vbMinimized[Non]Focus,
                        #vbMaximizedFocus. Renvoie le task ID NUM.
AppActivate VAL         #Donne focus à une application selon son task ID NUM ou son nom STRING
SendKeys STRING         #Tape des touches du clavier, pour l'application active courante.
                        #STRING peut être :
                        #  - "Hello"
                        #  - Touches spéciales : {TOUCHE}, avec : BS BREAK CAPSLOCK DEL DOWN|RIGHT|UP|DOWN END ENTER (ou ~)
                        #                                         ESC HELP HOMEINS NUMLOCK PGDN|UP PRTSC SCROLLLOCK TAB F1
                        #  - ~, +, % et doivent être dans {}
                        #  - +TOUCHE pour SHIFT, ^ pour CTRL et % pour ALT
                        #  - +(TOUCHE...), etc.
                        #  - {KEYS NUM} pour répétition

Environ(INDEX)          #Environment variables (UINT ou STRING). Exemple :
                        #  - USERDOMAIN:   ether-PC
                        #  - USERNAME:     ether
                        #  - USERPROFILE:  C:\Users\ether
                        #  - COMPUTERNAME: ETHER-PC
                        #  - LOGONSERVER:  \\ETHER-PC
                        #  - OS:           Windows_NT
                        #  - Path:         C:\Program Files\Microsoft Office\Office12\;C:\Windows\system32;C:\Windows;
                        #                  C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\
                        #  - TEMP:         C:\Users\ether\AppData\Local\Temp
                        #  - NUMBER_OF_PROCESSORS:   1
                        #  - PROCESSOR_ARCHITECTURE: x86
                        #  - PROCESSOR_IDENTIFIER:   x86 Family 6 Model 28 Stepping 10, GenuineIntel

MsgBox(STR[,ENM[,STR2]])#Pop-up sans demande d'input, affichant STR, avec comme boutons ceux d'ENUM
                        #Utiliser Chr(13) pour newline. STR2 est le titre de la popup.
                        #Renvoie vbOK, vbRetry, etc.
                        #Enums (or'd) :
                        #  - vbOKOnly, vbOKCancel, vbAbortRetryIgnore, vbYesNoCancel, vbYesNo, vbRetryCancel : boutons
                        #    (déf: OKOnly)
                        #  - vbCritical, vbQuestion, vbExclamation, vbInformation : image (déf: aucune)
                        #  - vbDefaultButton[1|2|3|4] : choix du bouton par défaut
                        #  - vbApplicationModal, vbSystemModal : modal popup (SystemModal bloque toutes applications)
                        #  - vbMsgBoxHelpButton : adds Help button
                        #  - vbMsgBoxSetForeground : Specifies the message box window as the foreground window
                        #  - vbMsgBoxRight : Text is right aligned.
                        #  - vbMsgBoxRtlReading : right-to-left
InputBox(STR[,STR2      #Input Box avec message STR, titre STR3, texte par défaut STR2. Renvoie ce qui est entré ("" si Cancel
[,STR3]])               #ou si "" entré)

QBColor(STRING)         #Renvoie valeur de couleur indexée STRING ("LightBlue", "Red", etc.)
RGB(RED,GREEN,BLUE)     #Pareil

Timer                   #Renvoie secondes depuis minuit.
Beep                    #Emet un beep

                                  ┌─────────────────┐
                                  │   INTER APPLI   │
                                  └─────────────────┘

UTILISATION D'AUTRES API#Utiliser Powerpoint Object Model dans du VBA Excel : aller dans Tools > Référence
 ==>                    #Récupérer un top level object :
                        #  - Autre application doit être ouverte :
                        #      Dim VAR As APPLI.Application
                        #      Set VAT = New APPLI.Application
                        #      '...
                        #      VAT.Quit
                        #  - Récupérer l'objet par exemple avec Powerpoint :
                        #
                        #Top level objet :
                        #  - .xls : Workbook
                        #  - .ppt : Presentation