Wage

Jedná se o speciální typ proměnné, která reprezentuje mzdovou větu, ale uloženou pouze v paměti!. Vzhledem k tomu, že každý zákazník může mít rozdílný počet mzdových položek, může i typ Wage být v každém systemu jiný! Proto nelze již během překladu provádět typové kontroly! O typu Wage lze zjednodušeně říct, že se jedná o obecné pole čísel, řetězců nebo datumů. K jednotlivým položkám lze, podobně jako u pracovní mzdové věty M, přistupovat pomocí indexu:

dim W : Wage;
W[100] := 500;

S typem Wage se pracuje podobně jako s typem 'M' (pracovní mzdová věta). Oba typy lze do sebe přiřazovat, lze nulovat (ClrWage), od sebe odčítat (SubWage) nebo přičítat (AddWage) :

dim W : Wage;
W := M;
AddWage(M, W, 0, 0);    { W := W + M; sečtení všech numerických typů }
SubWage(M, W, 0, 0);    { W := W - M; rozdíl všech numerických typů }
ClrWage(W, 0, 0);       { nulování všech numerických typů }

Během přiřazení 'W := M;' přejdou do proměnné W všechny položky z pracovní mzdové věty M. Jedinou výjímkou je položka typu kalendář! Tato položka je ve větě M reprezentována relací (identem) do tabulky WCAL. Do proměnné W ovšem přechází jako kalendářní data, která nemají žádný ident a tedy ani žádný vztah k nějaké větě z tabulky WCAL!!!

Toto řešení umožňuje pozdější uložení kalendářních dat do libovolné pracovní věty M tak, že jestliže věta M nebude mít kalendář založen, založí se a přijme data z proměnné Wage. Jestliže věta M bude mít kalendář založen, přijme pouze data z proměnné Wage a uloží je do tabulky WCAL pod stejným identem!!

Během přiřazení 'M := W;'  se plní položky pracovní mzdové věty M a zároveň se data ukládají do položek mzdové cache.

Jak systém pracuje v případě identu mzdové věty

  dim W, W1  : Wage;
 M := W;                { M[dbIdent] := bude nezměněn !! }
 W := M;                { W[dbIdent] := M[dbIdent];      }
 ClrWage(W, 0, 0);      { W[dbIdent] := 0;               }
 ClrWage(M, 0, 0);      { M[dbIdent] := bude nezměněn !! }
 AddWage(M,  W, 0, 0);  { W[dbIdent] := M[dbIdent];      }
 AddWage(W1, W, 0, 0);  { W[dbIdent] := W1[dbIdent];     }
 AddWage(W,  M, 0, 0);  { M[dbIdent] := bude nezměněn !! }
 SubWage(M,  W, 0, 0);  { W[dbIdent] := M[dbIdent];      }
 SubWage(W1, W, 0, 0);  { W[dbIdent] := W1[dbIdent];     }
 SubWage(W,  M, 0, 0);  { M[dbIdent] := bude nezměněn !! }

Jak se system chová v případě zamčené věty

   dim  W : Wage
  W := M;               { je povoleno }
  M := W;               { není povoleno, bude chyba makra }
  AddWage(W, M, 0, 0);  { není povoleno, bude chyba makra }
  AddWage(M, W, 0, 0);  { je povoleno }
  ClrWage(M, 0, 0);     { není povoleno, bude chyba makra }
  ClrWage(W, 0, 0);     { je povoleno }
  SubWage(W, M, 0, 0);  { není povoleno, bude chyba makra }
  SubWage(M, W, 0, 0);  { je povoleno }