`Register`  
$-Variablen        ab V25.6  (2005-06)  (in   acon  geht's etwas anders, mehr dazu `weiter unten`) 
In den Befehlen `variable` und `write`  konnten bis V25.5 keine Variablen außer den zum System gehörigen und auch in den Exportparametern genutzten #u-Variablen verwendet werden. Deren Namensraum ist begrenzt, weil die Namen nur aus 1 oder 2 Zeichen bestehen können, und man kann damit keine selbsterklärenden Namen bilden.  
Daher wurde ein eigenes, neues Konzept in die FLEX-Sprache eingebaut, das hier beschrieben wird.
(Später wurden auch noch `persistente Variablen` geschaffen, die in nachfolgenden Sitzungen automatisch wieder da sind.

Die Namen müssen mit $ beginnen, können ansonsten aber alle Zeichen enthalten bis auf das Leerzeichen sowie ';', '=' und '(', und sie können ziemlich lang sein. Groß- und Kleinschreibung sind signifikant. D.h. $Name, $nAmE  und  $NaMe  sind drei verschiedene Variablen. 

Man muß vorher nichts Besonderes tun, um $-Variablen zu nutzen. Die Existenz einer $-Variablen beginnt mit ihrer Besetzung, d.h. es gibt keine gesonderte Deklaration. Es gibt auch keine Typen: alles ist Text, wie bei den #u-Variablen. 
Die Besetzung geht so: 
var "abc"		oder		$Xyz abc
ins $Xyz
also genau wie bei #u-Variablen. Zusätzlich geht auch  $Xyz=abc.  Das mag als besser verständlich empfunden werden, vor allem wenn abc eine Zahl ist. Intern macht das keinen Unterschied, das Programm unterscheidet beim Speichern nicht zwischen Zahlen- und Textvariablen. 

Maximale Länge:
Eine $-Variable kann maximal 64000 Zeichen lang sein. Ist der iV-Text im Moment der Besetzung länger, wird er gekürzt! 
Tip: Der iV-Inhalt kann viel länger sein, bis zu 4 MB (acon: 2MB).  Mit  ins $  kann man den iV-Inhalt in die sog. "zweite iV" (oder iV2) kopieren, mit  var $  später wieder zurück in die "normale" iV. Sehr nützlich kann das sein, wenn man sich mit  get Iurl  längere Texte aus dem Internet hereinholt. Um einen solchen Text dann mit mehreren Befehlen auszuwerten, braucht man ihn nicht in eine $-Variable zu kopieren, wobei er womöglich gekürzt würde. 

Zusatzmöglichkeit:
Wenn in der iV ein Text wie  "$Abc xyz"  steht, wird mit einem schlichten   ins  die Variable  $Abc  mit dem Wert xyz belegt (sog. dynamische Belegung). 

Grundprinzip:
Die Sache ist sehr einfach: Wo bisher im FLEX ein  #uxy  stehen kann, da darf nun auch ein  $name  stehen, mit völlig gleicher Wirkungsweise. Wenn in  $name ein Feldinhalt  mit Unterfeldern steht, geht auch  $name$x,  um das Unterfeld $x herauszulösen, insbes. auch der Sonderfall $name$$, um den Feldanfang, den Abschnitt vor allen Unterfeldern, zu isolieren. 
Ferner kann man in einem RTF-Hilfetext auch schreiben:  %%$Xyz , dann erscheint an der Stelle der Inhalt der Variablen $Xyz. 

Zu beachten sind folgende Besonderheiten : 

Ausnahmen: 
1.  if-Befehle mit $-Variablen innerhalb der Bedingung gehen nicht, wie etwa  if >$name 
 
2. Innerhalb von Manipulationsbefehlen geht so etwas wie  (b"#uab"). Auch hier kann nicht statt #uab eine $-Variable stehen. 

3. Ein `if-Befehl` analog zu  if #nnn geht erst ab V26.7.  
Dies umgeht man so: 
var $name 
if "" jump fehler 
Ab V26.7 kann man aber schreiben: 
if $name ...
if not $name ...

4. `Manipulationsbefehle` sind auch möglich, aber ein Spatium muß hinter dem Variablennamen stehen, also z.B.  
var $name (b"xyz")
Hierbei kann man nur den Zugriff auf Unterfelder nicht mit einer Manipulation kombinieren, also etwa  
var $name$x (b"xyz")
Als Ausweg wählt man Konstruktionen wie  var $name (b"²x" e"²" b"xyz")  oder 
var $name$x 
var (b"xyz") 

Es gelten ferner folgende Regeln:

Besetzen (oben schon kurz angesprochen) kann man die freien Variablen auf zwei Arten. 
Wenn  $Titel  eine $-Variable sein soll, dann weist man ihr folgendermaßen einen Wert zu: 
(genau wie bei #u-Variablen schreibt man Name und Wert einfach nebeneinander hin!) 

$Titel Die Glocke 
Hinter dem Spatium darf nur Text auftreten, der dann komplett der Variablen zugewiesen wird bis zum Zeilenende; 
//-Kommentare gehen in solchen Zeilen nicht, wie ja auch in den mit # beginnenden Zeilen. 
  [Das Spatium ist hier wichtig, anders als bei #u-Variablen, weil die Länge des Namens unbestimmt ist!] 

  oder auch (ebenfalls wie bei #u-Variablen) 

var "Die Glocke"     oder   	var #20          usw. 
ins $Titel                  	ins $Titel

In beiden Fällen werden die Zeichen nicht umcodiert, d.h. im ersten Fall, so genommen, wie sie im FLEX stehen. Führende oder am Ende stehende Leerzeichen werden bei  ins $name  nicht beseitigt, anders als bei Kategorien und  #u-Variablen. Die Beseitigung kann man erreichen, indem man vor den ins-Befehl noch setzt  var (f" " F" ") . 

Hinweis: Mit der Syntax  $Titel #20  wird die Zeichenfolge '#20' in die Variable $Titel geschrieben (und nicht der Inhalt der Kategorie #20) 

Verwenden kann man die Variablen so: 

var ... $Titel ...     bzw.    write ... $Titel ...

d.h. in jedem var- bzw. write-Befehl als Teil des cstring. Zwischen Anführungszeichen hat $ keine Wirkung, d.h. dort werden Variablennamen nicht erkannt! 
Mit ... ist angedeutet, daß dort beliebige andere Elemente stehen können, die es in einem cstring geben kann. 

Es geht auch indirekt, wenn z.B. in #uab die Zeichenfolge $Titel steht: 
var #uab 
var 

danach steht der Inhalt von $Titel in der iV. (Denn der var-Befehl ohne Argument nimmt den Inhalt der iV als cstring.) 

Bei Zuweisung eines neuen Wertes an dieselbe Variable geht der alte Wert verloren. 

Löschen kann man eine Variable, indem man ihr nichts zuweist: 

var "" 
ins $Titel

Sie verschwindet dann aus der Liste, d.h. wird nicht mit einer leeren Zeichenfolge belegt sondern ist dann gar nicht mehr da. 
Und mit 

var "" 
ins $0    bzw.     ins $1   (in   acon  gibt's nur ins $0 ) 

löscht man alle kleinen bzw. großen Variablen auf einmal. 

Prüfen, ob eine Variable belegt ist, geht so: 

if not $name jump fehler 

Innerhalb eines FLEXes sind alle Variablen global, d.h. in einem FLEX-Unterprogramm kann es keine lokalen Variablen geben. Für die Übersichtlichkeit sorgt man z.B. durch geeignete Namensgebung. 

Aber nun noch eine sehr wichtige Besonderheit: 
Wenn der Name mit einem Großbuchstaben oder @ beginnt, bleibt die Variable für die gesamte Sitzung erhalten, sonst nur innerhalb des FLEXes, d.h. bei Beginn eines neuen FLEXes ist sie nicht mehr da. Es gibt also zwei Variablenlisten: die "kleine" und die "große". Wir nennen sie $0- bzw. $1-Variable, der Grund wird unten noch klar. 
Empfehlung: @ nicht als erstes Zeichen verwenden! Es soll in Zukunft für systemspezifische Funktionen reserviert sein. 

Welchen Umfang ein solcher Variablenspeicher haben kann, ist schwer zu sagen. Bei Tests gab es mit 5000 (fünftausend) noch keine Probleme. 
Es handelt sich um eine MFC-Listenklasse; deren Grenzen setzt Windows bzw. der darin verwendete Hash-Algorithmus. 

Was damit nicht geht: 
1.	           Einen Variablennamen trunkiert ansprechen   (wie mit   #ux.  in den Exportparametern) 
2.	Die Variablenliste alphabetisch geordnet durchsehen und dabei bearbeiten/löschen  (wie mit Alt+r die #u-Variablen) 
3.	Gezielt eine Anzahl Variablen mit einem Befehl löschen    (wie mit  #ux~ , um alle #uxy zu löschen) 

Denn die Listenklasse arbeitet mit einem Hash-Algorithmus, und der läßt solche Dinge nicht zu. Dafür ist er schnell. 

Was sich von selbst versteht: 
Die #u-Variablen bleiben in allen Aspekten unverändert erhalten. 
In den Exportparametern hat man keinen Zugriff auf die neuen $-Variablen, mit denen man sich folglich nebenwirkungsfrei austoben kann. 

Zusatzbefehle
Der Umgang mit den $-Variablen wird dadurch komfortabler, denn man wird sie irgendwann nicht nur einrichten und benutzen wollen. 

first $0 
first $1
  Setzt einen Zeiger auf das erste Element der "kleinen" bzw. "großen" Liste und holt dessen Inhalt in die iV. 

next $0 
next $1
  holt das nächste Element aus der kleinen bzw. großen Liste in die  iV, immer in der Form  $name Text 
Mit  if no  oder   if ""  kann man testen, ob es kein Element mehr gab.  Somit kann man in einer Schleife die ganze Liste abarbeiten. 
Zur Ordnung siehe den nächsten Punkt: 

$0>dateiname
$1>dateiname
   schreibt den Inhalt des kleinen bzw. großen Variablenspeichers in die Datei  dateiname. 
Eine erkennbare Ordnung gibt es dabei nicht - das ist typisch für Hash-Listen. D.h. die beim Einlesen gegebene Ordnung bleibt nicht erhalten und läßt sich auch nicht restaurieren. 
   Die Liste hat genau die Form  $name Text, und dbedeutet, daß man sie unmittelbar wieder als FLEX zum Einrichten derselben Variablen benutzen kann. 
 Daraus ergibt sich: 

SuperTip
Schreibt man in seinen _endflx.flx den Befehl  $1>var.flx und in den _start.flx an das Ende den Befehl  exec var, so hat man in der nächsten Sitzung immer sofort wieder die "großen" Variablen der letzten Sitzung. Selbstredend kann man dies nutzen, um alles mögliche an Information von Sitzung zu Sitzung zu transportieren (sog. "persistente" Variablen). 
Hinweis:  Auch die `Phrasen` kann man als persistente Variablen nutzen. 

Klar, es wird sofort der Wunsch nach gezählten und assoziativen Arrays kommen, mehrdimensional natürlich! Aber alles auf einmal geht nicht. Immerhin gibt es durchaus`Möglichkeiten!` 

ZusatzTip 
Mit dem nachfolgenden kleinen FLEX kann man den Variablenspeicher nach einer Zeichenfolge durchsuchen lassen. Wenn es mal mehrere 1000 sind, kann das ja sinnvoll sein... Gefunden werden sowohl die Namen wie die Inhalte der Variablen! 

************************************************************************** 
  VS.FLX :    Suche in den $1-Variablen nach einer bestimmten Zeichenfolge 
  2005-06-20  Gross-/Kleinschreibung egal 

ask Suchwort 
  Eingegebenes Suchwort in #usw speichern 
ins #usw 

first $1 
if no mes Keine Variablen!;end 

:loop 
  Variable in #uzs kopieren (Form ist immer $Name Text) 
ins #uzs 
  Darin nach dem Inhalt von #usw suchen (gross/klein egal) 
  (hinten . anhaengen, sonst wuerde das Suchwort nicht gefunden, wenn 
   es genau am Ende des Variablentextes steht!) 
var #uzs "." 
var (b"~#usw") 
  Wenn es vorkam, anzeigen 
if not "" var #uzs;yes;if yes jump found 
  naechste Variable holen 
next $1 
if not no jump loop 
mes Ende! 
end 
:found 
var "Gefunden: " #uzs 
mes 

************************************************************************* 

Zum Testen wurde eine Kurzliste des BachWerkeVerzeichnisses verwendet, darin standen 1360 Zeilen wie diese: 
$Bwv20 O Ewigkeit, du Donnerwort 

Diese Datei kann man so wie sie ist als FLEX laufen lassen, dann hat man 1360 "große" Variablen belegt! 
Gibt man nach dem Einlesen diesen Befehl: 

x var $BWV214\mes

so erscheint richtig:   Tönet, ihr Pauken! Erschallet Trompeten!

Sonderfall acon
In acon gibt es vorerst (Dez. 2009) folgende zwei Dinge: 

1. Eine besondere $-Variable mit dem schlichten Namen $, ebenfalls in a99. Das ist also quasi eine zweite interne Variable. Mit 
ins $
kopiert man den momentanen Inhalt der normalen  iV hinein, und mit 
var $
holt man sich umgekehrt den Inhalt von  $  in die iV. 

2. $-Variablen mit Namen wie bei a99 gibt es zwar auch, aber mit folgender Einschränkung: 
   Der Unterschied zwischen s und groß ist nicht relevant, weil ja stets nach Abarbeitung eines Jobs das Programm acon 
       wieder beendet wird. (Dennoch sind $a und $A verschiedene Variablen!) 

?variable=h xvar 
?write=h xwrite 
?Register=h xa 
?Manipulationsbefehle=h xcstring=B.  Die 
?if-Befehl=h xif 
?Möglichkeiten!=h xarray 
?persistente Variablen=h vb258#288 
?weiter unten=h =Sonderfall acon 
?Phrasen=h xphrase