Una riga di metodi inizia con un nome di metodo, che può essere:

• FUNCTION [RETURN]
• WHILE [CONTINUE] [BREAK] [LOOP]
• REPEAT [CONTINUE] [BREAK] [UNTIL]
• FOR [CONTINUE] [BREAK] [NEXT]
• IF [ELSE] [FI]
• SWITCH [ON] [ONC] [OTHER] [OFF]
• SET
• PSET
• IGNORE
• CONSOLE
• CONSOLELN
• ERROR
• ERRORLN
• ABORT
• PRINT
• PRINTLN
• DEBUG
• PAUSE
• CONST
• TEXT

I metodi tra '[' e ']' possono apparire solo se, in una riga precedente, compare il metodo fuori parentesi che li precede, in modo da farli corrispondere.

CONTINUE e BREAK possono apparire dentro WHILE, REPEAT e FOR; poiché svolgono una funzione simile in tutti e tre i casi, si è deciso di mantenere lo stesso nome; CONTINUE passa il controllo all'operazione di test del WHILE, REPEAT o FOR più interno, saltando eventuali altri metodi che seguirebbero nell'ordine naturale; BREAK passa il controllo alla prima istruzione successiva alla fine del ciclo WHILE, REPEAT o FOR più interno.

Per ogni riga, solo un metodo può essere specificato:

; Corretto
IF Test
  SET Result = "Vero"
ELSE
  SET Result = "Falso"
FI 
; Errato
IF Test SET Result = "Vero"
ELSE SET Result = "Falso" FI 

L'indentazione è del tutto arbitraria e può essere omessa o aumentata, come l'utente preferisce; si consiglia, tuttavia, di non ometterla per mantenere leggibile il codice del programma (regola di buona programmazione).
Anche il numero degli spazi/tabulazioni che separano i parametri è ininfluente.

É possibile anche iniziare direttamente una riga con una funzione (metodo nullo), ma non con un identificatore, una stringa o un numero (ovviamente). L'unica eccezione è rappresentata dal metodo SET, che può essere implicito; in questo caso, però, è obbligatorio mantenere il simbolo '=' tra l'identificatore ad inizio riga e l'espressione da assegnarvi, in questo modo:

; Corretto
S = "Questa è una stringa"

; Corretto
SET S = "Questa è una stringa"

; Corretto
SET S "Questa è una stringa"

; Errato: necessario '='
S "Questa è una stringa"

Ecco una succinta descrizione degli altri metodi, ad eccezione di FUNCTION (che è descritto nella sezione sulle UDF) e dei metodi dichiarativi CONST e TEXT (descritti nella sezione sulle costanti):

WHILE [nExpr]
  [metodo
  [metodo..]]
  [CONTINUE | BREAK]
LOOP 

Esegue i metodi compresi tra WHILE e LOOP finché nExpr non diviene falsa. Il valore di nExpr è così valutato: 0 = falsa, altro = vera. CONTINUE salta tutti i metodi fino al LOOP e rivaluta l'espressione test; BREAK fa lo stesso, ma causa l'uscita diretta dal ciclo, saltando la valutazione di nExpr.

REPEAT
  [metodo
  [metodo..]]
  [CONTINUE | BREAK]
UNTIL nExpr 

Esegue tutti i metodi compresi tra REPEAT e UNTIL finché nExpr non diviene vera; tutti i metodi sono eseguiti almeno una volta. Il valore di nExpr è così valutato: 0 = falsa, altro = vera. CONTINUE salta tutti i metodi fino ad UNTIL e rivaluta la espressione test; BREAK fa lo stesso, ma causa l'uscita diretta dal ciclo, saltando la valutazione di nExpr.

FOR id [=] nExp1 TO nExp2 [STEP nExp3]
  [metodo]
  [metodo..]
  [CONTINUE | BREAK]
NEXT 

Assegna ad id il valore nExp1, quindi ripete tutti i metodi tra FOR e NEXT finché id non diviene superiore (o inferiore, in base al segno di nExp3) ad nExp2; ad ogni NEXT, ad id viene sommato il valore di nExp3; se la parte STEP è omessa, di default id è incrementato di 1. Se nExp3 è positivo, nExp1 deve essere <= nExp2; se nExp3 è negativo, nExp1 deve essere >= nExp2. CONTINUE salta tutti i metodi fino a NEXT, incrementa id e rivaluta l'espressione sul ciclo; BREAK salta tutti i metodi e fa uscire dal ciclo, senza incrementare id o valutare la condizione di uscita.

SWITCH expr [func]
  ON[C] exp1_1[, exp1_2..]
    [metodo..]
  [ON[C] exp2_1[, exp2_2..]
    [metodo..]]
  [OTHER
    [metodo..]]
OFF 

Esegue tutti i metodi all'interno del primo ON/ONC per cui func(expr, expX) risulta vera (valore != 0); se più espressioni sono indicate nella riga ON/ONC, i metodi del caso relativo sono eseguiti qualora una qualsiasi delle espressioni risulti vera; le espressioni sono valutate nell'ordine indicato, da sinistra a destra.
Nel caso di ON, l'esecuzione prosegue quindi dal metodo successivo ad OFF; nel caso di ONC, prosegue con il corpo del successivo caso, in cascata, fino alla fine del corpo del successivo caso ON o OTHER incontrato, oppure fino ad OFF (se non ci sono altri casi).

Esempio

SET X = 1
SWITCH X
  ONC 1, 2, 3
    CONSOLELN "Stampa questa.."
  ONC 4
    CONSOLELN "e questa.."
  ON 5
    CONSOLELN "e questa (ultima)"
  ONC 6
    CONSOLELN "Questa non viene stampata"
OFF

func può essere una UDF o una qualsiasi funzione predefinita con due parametri (es. EQ, STREQ, IN); se non è specificata, di default è assunta EQ.
Ci deve essere sempre almeno un caso ON oppure ONC (ovviamente).
Se il caso OTHER è specificato, deve sempre apparire immediatamente prima di OFF; i metodi nel suo corpo sono eseguiti solo nel caso in cui nessuna delle precedenti espressioni sia vera (oppure in cascata).

IF nExpr
  [metodo
  [metodo..]]
[ELSE
  [metodo
  [metodo..]]]
FI 

Esegue i metodi che seguono nExpr e precedono ELSE o FI se nExpr risulta vero, i metodi che seguono ELSE e precedono FI se nExpr risulta falso; sia i metodi 'then' che i metodi 'else' possono essere omessi.

SET id [=] expr 
[SET] id = expr 

Assegna il valore expr ad id; se id non esiste, viene aggiunto alla lista degli identificatori validi; è possibile anche assegnare lo stesso valore a più variabili con SET id1 [=] id2 = id3 .. = expr; in questo caso, il simbolo '=' deve essere obbligatoriamente indicato e tutti i simboli che si trovano alla sinistra di un segno '=' devono essere identificatori. SET può anche essere omesso qualora si specifichi il segno '='.

PSET id [=] expr
[PSET] id = expr 

Come SET, ma permette di impostare il valore di variabili pubbliche dall'interno di funzioni. Può comparire solo all'interno di una UDF. Anche PSET può essere utilizzato per assegnare uno stesso valore a più variabili pubbliche; tutti i simboli a sinistra del segno '=' devono essere identificatori di variabili pubbliche, mentre nell'espressione finale tutte le variabili sono locali (ad eccezione di quelle dentro PUB).

Gli identificatori pubblici sono accessibili anche attraverso il prefisso '_', che affianca la funzione PUB; pertanto, l'espressione:

B = PUB(A)

può essere scritta come:

B = _A

Anche gli assegnamenti rispettano la stessa convenzione:

PSET A = B

è equivalente a:

_A = B

IGNORE 

Salta alla prossima riga (ed ignora il resto del programma); non può comparire all'interno di una UDF.

CONSOLE expr

Stampa expr su stdout

CONSOLELN expr

Stampa expr su stdout e vi accoda CEOL

ERROR expr

Stampa expr su stderr

ERRORLN expr

Stampa expr su stderr e vi accoda EEOL

ABORT nExpr

Esce immediatamente con livello di errore nExpr.

PRINT expr

Scrive il valore dell'espressione sul file di uscita

PRINTLN expr

Scrive il valore dell'espressione sul file di uscita e vi accoda EOL

DEBUG 

Stampa il valore di tutte le variabili globali in quel momento; utile per verificare perché il programma non fa quanto atteso; se si desidera verificare il valore di una singola variabile, utilizzare CONSOLELN. Le variabili locali, pile, code, mappe di bit, vettori, insiemi, alberi AVL non sono comunque stampati: è necessario ricorrere a CONSOLELN per visualizzare i loro valori.

PAUSE [cExpr]

Stampa l'espressione indicata (oppure, se omessa, un messaggio standard che richiede l'intervento dell'utente) e sospende l'esecuzione finché l'utente non preme Invio; i dati sono richiesti dall'ingresso standard.

Ogni metodo deve essere concluso su una riga; nel caso l'espressione sia molto lunga, si termini la linea con '\' e si prosegua alla riga successiva.

I metodi:

PRINT PRINTLN CONSOLE CONSOLELN ERROR ERRORLN PAUSE SET PSET RETURN

permettono il concatenamento di expr per giustapposizione; pertanto:

PRINTLN "Questa " TOKEN(Frase, 2, " ") " una prova" 

è equivalente a:

PRINTLN STRCAT(STRCAT("Questa ", TOKEN(Frase, 2, " ")), " una prova") 

Ciò permette, quindi, di ottenere una maggiore leggibilità ed accresce la velocità di scrittura del programma, potendo risparmiare molte parentesi nel caso di concatenamenti multipli.

Ecco la traduzione delle strutture di controllo C in Proteus:

while (test)
{
  ...
}

WHILE Test
  ...
LOOP

if (test)
{
  ...
}
else
{
  ...
}

IF Test
  ...
ELSE
  ...
FI

switch (exp)
{
  case val1_1:
  case val1_2:
    ...
    break;
  case val2:
    ...
  default:
    ...
    break;
}

SWITCH Exp
  ON Val1_1, Val1_2
    ...
  ONC Val2
    ...
  OTHER
    ...
OFF

for (x=s; x <= e; x += i)
{
  ...
}

FOR X = S TO E STEP I
  ...
NEXT

do
{
  ...
} while (!test);

REPEAT
  ...
UNTIL Test

(test) ? (exp1) : (exp2)

IIF(test, exp1, exp2)

Proteus segnala eventuali errori sintattici, riportando il tipo dell'errore, il nome del file e la riga alla quale è stato rilevato.

Ecco due esempi di costrutti scorretti:

WHILE LT(P, 10)
  IF EQ(P, 7)
    LOOP
  FI
  .. 

Errore: non vi devono essere IF aperti al momento del LOOP; LOOP chiude idealmente tutte le istruzioni nel ciclo WHILE; per passare direttamente al test, utilizzare CONTINUE in questo caso.

IF LT(P, 10)
  WHILE LT(P, 5)
ELSE
  ..

Errore: non è possibile "saltare" fuori da un ciclo WHILE; in parole povere, non si possono chiudere all'interno di un WHILE strutture condizionali aperte al di fuori di esso.