Langage de programmation - Turbo Pascal - Référence des unités



Unit System;

 
INTERFACE

 
Const

  OvrCodeList: Word = 0;        { Liste de code de recouvrement }

  OvrHeapSize: Word = 0;	{ Taille du tampon de recouvrement }

  OvrDebugPtr: Pointer = nil;   { Procédure en crochet du débogueur pour le recouvrement }

  OvrHeapOrg: Word = 0; 	{ Origine du tampon de recouvrement }

  OvrHeapPtr: Word = 0;		{ Pointeur du tampon de recouvrement }

  OvrHeapEnd: Word = 0; 	{ Fin du tampon de recouvrement }

  OvrLoadList: Word = 0; 	{ Liste de chargement des recouvrements }

  OvrDosHandle: Word = 0;  	{ Gestionnaire du recouvrement DOS }

  OvrEmsHandle: Word = $FFFF;	{ Gestionnaire du recouvrement EMS }

  HeapOrg: Pointer = nil;	{ Tas d'orgine }

  HeapPtr: Pointer = nil;  	{ Pointeur du tas }

  HeapEnd: Pointer = nil;	{ Fin du tas }

  FreeList: Pointer = nil;	{ Pointeur de libération de la liste }

  FreeZero: Pointer = nil;	{ Doit être zéro }

  HeapError: Pointer = nil;     { Fonction d'erreur de tas }

  ExitProc: Pointer = nil;  	{ Procedure de sortie }

  ExitCode: Integer = 0;	{ Code de sortie }

  ErrorAddr: Pointer = nil;	{ Adresse d'erreur d'exécution }

  PrefixSeg: Word = 0;  	{ Préfixe de segment de programme }

  StackLimit: Word = 0;		{ Limite inférieur du pointeur de pile }

  InOutRes: Integer = 0;	{ Résultat du tampon d'entrée/sortie }

  RandSeed: Longint = 0; 	{ Générateur aléatoire }

  FileMode: Byte = 2;		{ Mode du fichier ouvert }

  Test8087: Byte = 0;		{ Résultat du test 8087 }

 
Var

  Input: Text;                  { Fichier de l'entrée standard }

  Output: Text;			{ Fichier de la sortie standard }

  SaveInt00: Pointer;		{ Sauvegarde de l'interruption $00 }

  SaveInt02: Pointer;		{ Sauvegarde de l'interruption $02 }

  SaveInt09: Pointer;		{ Sauvegarde de l'interruption $09 }

  SaveInt1B: Pointer;		{ Sauvegarde de l'interruption $1B }

  SaveInt21: Pointer;		{ Sauvegarde de l'interruption $21 }

  SaveInt23: Pointer;		{ Sauvegarde de l'interruption $23 }

  SaveInt24: Pointer;		{ Sauvegarde de l'interruption $24 }

  SaveInt34: Pointer;		{ Sauvegarde de l'interruption $34 }

  SaveInt35: Pointer;		{ Sauvegarde de l'interruption $35 }

  SaveInt36: Pointer;		{ Sauvegarde de l'interruption $36 }

  SaveInt37: Pointer;		{ Sauvegarde de l'interruption $37 }

  SaveInt38: Pointer;		{ Sauvegarde de l'interruption $38 }

  SaveInt39: Pointer;		{ Sauvegarde de l'interruption $39 }

  SaveInt3A: Pointer;		{ Sauvegarde de l'interruption $3A }

  SaveInt3B: Pointer;		{ Sauvegarde de l'interruption $3B }

  SaveInt3C: Pointer;		{ Sauvegarde de l'interruption $3C }

  SaveInt3D: Pointer;		{ Sauvegarde de l'interruption $3D }

  SaveInt3E: Pointer;		{ Sauvegarde de l'interruption $3E }

  SaveInt3F: Pointer;		{ Sauvegarde de l'interruption $3F }

  SaveInt75: Pointer;		{ Sauvegarde de l'interruption $75 }

 
Function ABS(n:Integer):Integer;

Function ABS(n:Real):Real;

Function Addr(x):Pointer;

Procedure Append(varfich:Text);

Function ArcTan(r:Real):Real;

Procedure Assign(var fich:File; nomfich:String);

Function Assigned(Var P):Boolean;

Procedure BlockRead(fich:File; var x;enrs:Word;var enrs_lus:Word);

Procedure BlockWrite(fich:File; var x;enrs:Word;Var enrs_ecrit:Word);

Procedure ChDir(rep:String);

Function Chr(i:Byte):Char;

Procedure Close(fich:File);

Function Concat(ch1,ch2, ...:String):String;

Function Copy(S:String; Index, Count: Integer):String;

Function Cos(r:Real):Real;

Function CSeg:Word;

Procedure Dec(s,n);

Procedure Dec(s);

Procedure Delete(S:String;Pos,nbre:Integer);

Procedure Dispose(p:Pointer);

Procedure Dispose(p:Pointer; Destructor);

Function DSeg:Word;

Function Eof(fich:File):Boolean;

Function Eoln(fich:Text):Boolean;

Procedure Erase(fich:File);

Procedure Exclude(var S:Set of T;I:T);

Function Exp(r:Real):Real;

Function FilePos(fich:File):LongInt;

Function FileSize(fich:File):LongInt;

Procedure FillChar(Var Tampon; nbre:Word; Val:Byte);

Procedure FillChar(Var Tampon; nbre:Word; Val:Char);

Procedure Flush(fich:Text);

Function Frac(n:Real):Real;

Procedure FreeMem(p:Pointer; t:Word);

Procedure GetDir(unite:Word;Var reper:String);

Procedure GetMem(p:Pointer; t:Word);

Procedure Halt;	

Procedure Halt(nbre:Word);

Function Hi(i:Word):Byte;

Procedure Inc(Var s);

Procedure Inc(Var s:n);

Procedure Insert(ch1:String; Var ch2:String;pos:Integer);

Function Int(r:Real):Real;

Function IoResult:Word;

Function Length(ch:String):Integer;

Function Ln(n:Real):Real;

Function Lo(i:Word):Byte;

Procedure Mark(var p:Pointer);

Function MaxAvail:LongInt;

Function MemAvail:LongInt;

Procedure MkDir(reper:String);

Procedure Move(Const orig;var dest;nbre:Word);

Procedure New(var p:Pointer, Init:Constructor);

Function Odd(i:LongInt):Boolean;

Function Ofs(ident):Word;

Function Ord(s):LongInt;

Function ParamCount:Word;

Function Pos(search,source:String):Integer;

Function Pred(s:type):type;

Function Ptr(seg,ofs:Word):Pointer;

Function Random(max:Word):Word;

Procedure Randomize;

Procedure Read(var1, var2,...);

Procedure Read(var fich:Text;var1, var2,...);

Procedure ReadLn(var1, var2,...);

Procedure ReadLn(var fich:Text;var1, var2,...);

Procedure Release(p:Pointer);

Procedure Rename(Var fich:File; nouveaunom:String);

Procedure Reset(Var fich:File);

Procedure Rewrite(Var fich:Text);

Procedure RmDir(reper:String);

Function Round(n:Real):LongInt;

Procedure RunError(nbre:Word);

Procedure Seek(Var fich:File; nbre:Word);

Function SeekEof(Var fich:Text):Boolean;

Function SeekEoLn(Var fich:Text):Boolean;

Procedure SetTextBuf(Var fich:Text;Var buffer;Taille:Word);

Function Sin(r:Real):Real;

Function SPtr:Word;

Function Sqr(x:Integer):Integer;

Function Sqr(x:Real):Real;

Function Sqrt(r:Real):Real;

Function SSeg:Word;

Procedure Str(nbre:format;Var ch:String);

Function Succ(s:type):type;

Function Swap(i:Word):Word;

Function Trunc(r:Real):LongInt;

Procedure Truncate(fich:File);

Function UpCase(ch:Char):Char;

Procedure Val(ch:String; Var nbre:Real;Var err:Integer);

Procedure Write(var1, var2,...);

Procedure Write(var fich:File;var1, var2,...);

Procedure WriteLn(var1, var2,...);

Procedure WriteLn(var fich:File;var1, var2,...);

 
IMPLEMENTATION
Dernière mise à jour : Dimanche, le 20 avril 2014
Section courante

A propos

Section administrative du site
