1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

function test(aHexCode: string): string;
var
  HexBH: string;
  DecBH, myPos: integer;
begin
  myPos:=Length(aHexCode)-3;
  HexBH := copy(aHexCode, myPos, 2);        // meine $11 rausholen
  DecBH := StrToInt('$'+HexBH) -$17;        // meine $11 mit $17 subtrahieren
  HexBH := format('%x', [DecBh]);           // meine $11 - $11 = FA in string wandeln wobei hier eigentlich FFFFFFFA rauskommt

  if Length(HexBH) > 2 then                 // wenn die Länge von HexBH größer als 2 ist
  Delete(HexBH, 1, Length(HexBH)-2);        // wird alles, bis auf die letzen 2 Zeichen gelöscht (also hier alles bis auf FA)
  Delete(aHexCode, myPos, 2);               // die stelle wo vorhin meine $11 waren löschen
  insert(HexBH, aHexCode, myPos);           // meine $FA da einfügen wo vorhin $11 war

  result := aHexCode;
end;					

1:
2:
3:
4:

type
  TMyArray = array[0..Laenge-1] of Byte;
var
  A: TMyArray;					

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

type
  TMyArray = array of Byte;
var
  A: TMyArray;

procedure InitArray(const ALen: Integer);
begin
  SetLength(A,ALen);
end;

procedure DoneArray;
begin
  Finalize(A);
end;					

1:

A[0] := 100;					

1:
2:
3:
4:
5:

s:=''; 
for i:=0 to high(key) do
begin
  s:=s+IntToHex(Key[i],2);
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

function ArrayToKey(const A: array[0..3] of Byte): Cardinal; // 4 Byte
var
  I: Integer;  
begin
  Result := 0;
  for I := 0 to 3 do
  begin
    Result := (Result shl 8) or A[I];
  end;
end;					

1:
2:
3:
4:

  A := A+AByte ; //4.Stelle
  A := A+($100*AByte); //3.Stelle
  A := A+($10000AByte); //2.Stelle
  A := A+($1000000*AByte); //1.Stelle					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

var
  a: array of byte;

implementation

{$R *.dfm}

...

var
  tempStr, Hex: string;
  i, len: integer;
begin
  Hex:='EE01FF44';

  Len := Length(Hex) div 2;
  SetLength(a, Len+1);
  for i := 1 to Len do
  begin
    tempStr:='$'+copy(Hex, i*2-1, 2);
    a[i]:=byte(StrToInt(tempStr));
  end;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:

var
  c, i: integer;
  Hex: string;
begin
  for i:=low(a) to high(a) do
  begin
    c:= (c shl 8) or a[i];
  end;
  hex:=IntToHex(c, 8);					

1:

c:= (c shl 8) or a[i];					

1:
2:
3:

SHL
Logische Linksverschiebung.
Beide Ausdrücke müssen absolute, direkte Werte sein. Das Ergebnis ist ebenfalls ein absoluter direkter Wert.					

1:
2:
3:

OR
Bitweises OR.
Beide Ausdrücke müssen absolute, direkte Werte sein. Das Ergebnis ist ebenfalls ein absoluter direkter Wert.					

1:
2:
3:
4:
5:

 
A := 1;       // A := 0000 0000 0000 0001b = 1
B := A shl 1; // B := 0000 0000 0000 0010b = 2
C := A shl 2; // C := 0000 0000 0000 0100b = 3
D := A shl 8; // D := 0000 0001 0000 0000b = 256					

1:
2:
3:
4:

A := 2;       // A := 0000 0000 0000 0010b = $002
B := A shl 8; // B := 0000 0010 0000 0000b = $200
C := B or $34;// C := 0000 0010 0011 0100b = $234
D := B + $34; // D := 0000 0010 0011 0100b = $234					

1:

StrToInt('$'+HexString);					

1:

IntToHex(Zahl,8);					

1:
2:
3:
4:
5:
6:
7:

A := 1;       // A := 0000 0000 0000 0001b = 1
B := A shl 1; // B := 0000 0000 0000 0010b = 2
C := A shl 2; // C := 0000 0000 0000 0100b = 3  -> dann müsste das 4 sein oder?
D := A shl 8; // D := 0000 0001 0000 0000b = 256

// mein zusatz
E := A shl 4  // müsste dann 16 sein oder?