[DOC] Process Method's

[DOC] Process Method's

Postby CicTec » Mon Nov 18, 2013 1:36 am

NOTA: Prima di leggere questa documentazione, si raccomanda di leggere dettagliatamente le seguenti documentazioni:
  • Scope's and Type Access


Un metodo è un blocco di codice (simile ad una FUNCTION) che esegue particolari operazioni o manipolazioni di dati, ed è legato ad un tipo di PROCESS concreto.
I metodi di un processo, formano la interfaccia dello stesso.


1 - TIPI DI METODI
Il tipo di un metodo indica l'accesso e la forma con il quale il metodo può essere utilizzato.

Gemix supporta i seguenti tipi di metodi:
  • PUBLIC - Questo tipo di metodo è visibile e utilizzabile in qualunque parte del programma.
  • PRIVATE - Questo tipo di metodo è visibile e utilizzabile solo nella zona del programma al quale appartiene (il PROCESS dove è definito).
  • CALLBACK - Questo tipo di metodo è utilizzabile solo attraverso un FOBJECT, per tanto, non è possibile chiamare esplicitamente un metodo callback. La sua funzione principale è potere creare interfacce che rappresentano sistemi di eventi basati in callbacks


2 - DICHIARAZIONE DI METODI
Tutti i metodi appartenenti ad un PROCESS specifico, devono essere dichiarati per poter essere visibili e utilizzabili nel programma.

La dichiarazione dei metodi si effettua nella sezione DECLARE del programma, ed ha la seguente forma:
methods proctype_name
method_decls...
end

  • proctype_name - Rappresenta il nome di un tipo di PROCESS valido (es: "proc").
  • method_decls... - Rappresenta una lista di dichiarazioni di prototipi di metodo, un prototipo ha la seguente forma:
    • method [access_modifier] [return_type] name([signature]);
      • access_modifier - Rappresenta il tipo di metodo ed il suo accesso (PUBLIC, PRIVATE o CALLBACK).
      • return_type - Rappresenta il tipo di ritorno del metodo (INT, FLOAT, DOUBLE, etc...).
      • name - Rappresenta il nome del metodo (es: "set").
      • signature - Rappresenta la lista di parametri (es: set(int)).

Esempio:
Source Code (Gemix) [ Download ] [ Hide ]
  • program process_methods;
  • ...
  • declare
  •   methods proc
  •     method public string get_name();
  •     method public proc set_name(string);
  •     method public proc set_age(int);
  •     method private configure();
  •     method info();
  •  
  •     method callback onclick();
  •   end
  • ...
  • begin
  •   ...
  • end
  •  
  • process proc()
  •   ...
  • begin
  •   ...
  • end
  •  

L'esempio precedente dichiara i seguenti metodi appartenenti al tipo PROCESS "proc":
  • Un metodo di nome "get_name", di tipo di accesso "PUBLIC", con tipo di ritorno "STRING", senza parametri.
  • Un metodo di nome "set_name", di tipo di accesso "PUBLIC", con tipo di ritorno "proc", con 1 parametro "STRING".
  • Un metodo di nome "set_age", di tipo de accesso "PUBLIC", con tipo di ritorno "proc", con 1 parametro "INT".
  • Un metodo di nome "configure", di tipo de accesso "PRIVATE", con tipo di ritorno "INT" (default), senza parametri.
  • Un metodo di nome "info", di tipo de accesso "PRIVATE" (default), con tipo di ritorno "INT" (default), senza parametri.
  • Un metodo di nome "onclick", di tipo de accesso "CALLBACK", con tipo di ritorno "INT" (default), senza parametri.
NOTA:
  • Se si utilizza un nome di PROCESS non valido o inesistente per "proctype_name", si avrà un errore di compilazione.
  • Se non viene specificato il "access_modifier", per default il metodo sarà di tipo "PRIVATE".
  • Se non viene specificato il "return_type", per default questo sarà "INT".
  • E' possibile dichiarare più metodi con lo stesso nome, tuttavia la "signature" deve essere univoca per ogni metodo (per creare overloads), altrimenti si avrà un errore di compilazione.
  • La "signature" di un metodo deve essere una lista di tipi di parametri separati dal simbolo ",". Se si tenta di specificare un nome per il tipo di parametro, si avrà un errore di compilazione.


3 - DEFINIZIONE DI METODI
Una volta dichiarati i metodi appartenenti ad un PROCESS specifico, è necessario definirli affinchè siano utilizzabili (chiamabili) nel programma.

La definizione dei metodo si effettua nella sezione METHODS del PROCESS appartenente, ed ha la seguente forma:
methods
method_defs...

  • method_defs... - Rappresenta una lista di definizioni di metodi, una definizione ha la seguente forma:
    • method [access_modifier] [return_type] name([signature]);
      [ private
      data_defs... ]
      begin
      instructions_code...
      end

      • access_modifier - Rappresenta il tipo di metodo ed il suo accesso (PUBLIC, PRIVATE o CALLBACK).
      • return_type - Rappresenta il tipo di ritorno del metodo (INT, FLOAT, DOUBLE, etc...).
      • name - Rappresenta il nome del metodo "(es: "set").
      • signature - Rappresenta la lista di parametri (es: set(int value)).
      • private - Rappresenta la sezione dove è possibile definire dati privati per il metodo.
      • begin/end - Rappresenta la coppia che forma il corpo (definizione) del metodo.
      • instructions_code... - Rappresenta una lista di istruzioni che formano la implementazione del metodo.

Esempio:
Source Code (Gemix) [ Download ] [ Hide ]
  • program process_methods;
  • ...
  • declare
  •   methods proc
  •     method public string get_name();
  •     method public proc set_name(string);
  •     method public proc set_age(int);
  •     method private configure();
  •     method info();
  •  
  •     method callback onclick();
  •   end
  • ...
  • begin
  •   ...
  • end
  •  
  • process proc()
  • methods
  •   method public string get_name()
  •   begin
  •     return(name);
  •   end  
  •  
  •   method public proc set_name(string name)
  •   begin
  •     this.name = name;
  •     return(this);
  •   end
  •  
  •   method public proc set_age(int age)
  •   begin
  •     this.age = age;
  •     return(this);
  •   end
  •        
  •   method private configure()
  •   begin
  •   end
  •        
  •   method info()
  •   begin
  •   end
  •        
  •   method callback onclick();
  •   begin
  •   end
  • begin
  •   ...
  • end
  •  

L'esempio precedente definisce i seguenti metodi appartenenti al tipo PROCESS "proc":
  • Un metodo di nome "get_name" di tipo di accesso "PUBLIC", con tipo di ritorno "STRING", senza parametri.
  • Un metodo di nome "set_name" di tipo di accesso "PUBLIC", con tipo di ritorno "proc", con 1 parametro "STRING" di nome "name".
  • Un metodo di nome "set_age" di tipo de accesso "PUBLIC", con tipo di ritorno "proc", con 1 parametro "INT" di nome "age".
  • Un metodo di nome "configure" di tipo de accesso "PRIVATE", con tipo di ritorno "INT" (default), senza parametri.
  • Un metodo di nome "info" di tipo de accesso "PRIVATE" (default), con tipo di ritorno "INT" (default), senza parametri.
  • Un metodo di nome "onclick di tipo de accesso "CALLBACK", con tipo di ritorno "INT" (default), senza parametri.
NOTA:
  • Tutti i metodi appartenenti ad un PROCESS specifico e dichiarati precedentemente, devono essere definiti, altrimenti si avrà un errore di compilazione.
  • Se si tenta di definire un metodo non dichiarato precedentemente nella sezione DECLARE del programma, si avrà un errore di compilazione.
  • Il prototipo della definizione del metodo deve coincidere con quello della dichiarazione, altrimenti si avrà un errore di compilazione.
  • Se non viene specificato il "access_modifier", per default il metodo sarà di tipo "PRIVATE".
  • Se non viene specificato il "return_type", per default questo sarà "INT".
  • E' possibile definire più metodi con lo stesso nome, tuttavia la "signature" deve essere univoca per ogni metodo (per crear overloads), altrimenti si avrà un errore di compilazione.
  • La "signature" di un metodo deve essere una lista di tipi e nomi di parametri separati dal simbolo ",". Se il parametro non ha un nome assegnato, si avrà un errore di compilazione.
  • Affinché una definizione di metodo sia valida, deve contenere la coppia "BEGIN/END" (definizione) che forma il corpo del metodo, altrimenti si avrà un errore di compilazione. Non è necessario che il metodo contenga "instructions_code..." affinchè la definizione dello stesso sia valida.
  • L'ordine di definizione dei metodi può essere distinto dall'ordine di dichiarazione degli stessi, l'importante è che tutti i metodi dichiarati, siano definiti.
  • Se "instructions_code..." contiene una o più sentenze FRAME, si avrà un errore di compilazione, poiché un metodo non può utilizzare FRAME (sentenza riservata solo ad entità speciali come PROCESS o FUNCTION).


4 - MODELLI DI METODI E MODELLI DI CHIAMATE
Il modello di un metodo stabilisce in quale forma il metodo può essere chiamato.
Il modello di chiamata di un metodo indica la sintassi utilizzabile per chiamare uno o più metodi.

Gemix supporta i seguenti modelli di metodi:
  • NORMAL - Rappresenta un metodo il cui tipo di ritorno è diverso dal tipo di PROCESS al quale il metodo appartiene.
  • CHAIN - Rappresenta un metodo il cui tipo di ritorno è uguale al tipo di PROCESS al quale il metodo appartiene.

Esempio:
Source Code (Gemix) [ Download ] [ Hide ]
  • program process_methods;
  • ...
  • declare
  •   methods proc
  •     method public proc set_age(int); // chain method
  •     method public proc set_name(string); // chain method
  •     method public string get_name(); // normal method
  •     method public info(); // normal method
  •   end
  • ...
  •  

Supporta inoltre i seguenti modelli di chiamate:
  • CASCADING - Con questo modello è possibile chiamare solo un metodo in una singola istruzione, N chiamate di metodi richiedono N istruzioni. Le forme di chiamate cascading possono essere:
    • DIRECT: method_name([arguments_list]);
    • QUALIFIED: process_instance_id./->method_name([arguments_list]);
      • process_instance_id - Rappresenta un identificatore di istanza valido, dello stesso tipo PROCESS al quale il metodo appartiene (es: proc_id, this, id, etc...);
      • ./-> - Rappresentano gli operatori di accesso allo scope (utilizzati per chiamate qualificate, per una trattazione dettagliata degli scopes e tipi di accessi vedere la DOC "Scope's and Type Access").
      • method_name - Rappresenta il nome del metodo da chiamare.
      • () - Rappresenta l'operatore di chiamata.
      • arguments_list - Rappresenta una lista di valori separati dal simbolo ",", passati ai parametri del metodo.
  • CHAINING - Con questo modello è possibile chiamare uno o più metodi in una singola istruzione. Le forme di chiamate chaining possono essere:
    • DIRECT: method_name([arguments_list])./->[method_name([arguments_list])...]./->method_name([arguments_list]);
    • QUALIFIED: process_instance_id./->[b]method_name([arguments_list])./->[method_name([arguments_list])...]./->method_name([arguments_list]);
      • process_instance_id - Rappresenta un identificatore di istanza valido, dello stesso tipo PROCESS al quale il metodo appartiene (es: proc_id, this, id, etc...);
      • ./-> - Rappresentano gli operatori di accesso allo scope (utilizzati per chiamate qualificate, per una trattazione dettagliata degli scopes e tipi di accessi vedere la DOC "Scope's and Type Access").
      • method_name - Rappresenta il nome del metodo da chiamare.
      • () - Rappresenta l'operatore di chiamata.
      • arguments_list - Rappresenta una lista di valori separati dal simbolo ",", passati ai parametri del metodo.

Esempio:
Source Code (Gemix) [ Download ] [ Hide ]
  • program process_methods;
  • ...
  • declare
  •   methods proc
  •     method public string get_name();
  •     method public proc set_name(string);
  •     method public proc set_age(int);
  •     method private configure();
  •     method info();
  •  
  •     method callback onclick();
  •   end
  •  
  • global
  •   proc proc_id[2], proc_id3;
  •  
  • begin
  •   proc_id[0] = proc();
  •   proc_id[1] = proc();
  •   proc_id[2] = proc();
  •  
  •   // Method cascading...
  •   proc_id[0].set_name("Gemix"); // OK, chiamata "cascading" corretta.
  •   proc_id[0].set_age(100); // OK, chiamata "cascading" corretta.
  •   proc_id[0].configure(); // ERROR, chiamata "cascading" non valida, "configure" è di tipo "PRIVATE" e non può essere chiamato esternamente.
  •   proc_id3.set_name("DIV-Like"); // OK, chiamata "cascading" corretta, tuttavia genera errore in esecuzione poiché "proc_id3" non contiene un ID di istanza valido (valore 0).  
  •  
  •   // Method chaining...
  •   proc_id[1].set_name("Gemix").set_age(100); // OK, chiamata "chaining" corretta.
  •   proc_id[2].set_name("Studio").set_age(101).configure(); // ERROR, chiamata "chaining" non valida, "configure" è di tipo "PRIVATE" e non può essere chiamato esternamente.
  •   proc_id3.set_name("DIV-Like").set_age(999); // OK, chiamata "chaining" corretta, tuttavia genera errore in esecuzione poiché "proc_id3" non contiene un ID di istanza valido (valore 0).
  • end
  •  
  • process proc()
  • private
  •   string name;
  •   int age;
  •  
  • methods
  •   method public string get_name()
  •   begin
  •     return(name);
  •   end  
  •  
  •   method public proc set_name(string name)
  •   begin
  •     this.name = name;
  •     return(this);
  •   end
  •  
  •   method public proc set_age(int age)
  •   begin
  •     this.age = age;
  •     return(this);
  •   end
  •        
  •   method private configure()
  •   begin
  •   end
  •        
  •   method info()
  •   begin
  •   end
  •        
  •   method callback onclick();
  •   begin
  •   end
  •  
  • begin
  •   // Method cascading...
  •   set_name("DIV-Like");
  •   set_age(999);
  •   configure();
  •   //onclick(); // ERROR, il metodo è di tipo CALLBACK, e non può essere chiamato esplicitamente.
  •  
  •   // Method chaining...
  •   set_name("DIV-Like").set_age(999).configure();
  • end
  •  

L'esempio precedente utilizza le seguenti istruzioni di chiamate:
  • L'istruzione "proc_id[0].set_name("Gemix");" nel blocco "process_methods" utilizza il modello di chiamata "CASCADING" ("QUALIFIED") per il metodo "set_name". La chiamata è corretta poiché "proc_id[0]" è dello stesso tipo PROCESS al quale il metodo appartiene, inoltre il metodo è di tipo "PUBLIC", e può (e deve) essere chiamato esternamente mediante forma "QUALIFIED".
  • L'istruzione "proc_id[0].set_age(100);" nel blocco "process_methods" utilizza il modello di chiamata "CASCADING" ("QUALIFIED") per il metodo "set_age". La chiamata è corretta poiché "proc_id[0]" è dello stesso tipo PROCESS al quale il metodo appartiene, inoltre il metodo è di tipo "PUBLIC", e può (e deve) essere chiamato esternamente mediante forma "QUALIFIED".
  • L'istruzione "proc_id[0].configure();" nel blocco "process_methods" utilizza il modello di chiamata "CASCADING" ("QUALIFIED") per il metodo "configure". La chiamata genera errore di compilazione, poiché anche se "proc_id[0]" è dello stesso tipo PROCESS al quale il metodo appartiene, il metodo è di tipo "PRIVATE" e non può essere chiamato esternamente.
  • L'istruzione "proc_id3.set_name("DIV-Like");" nel blocco "process_methods" utilizza il modello di chiamata "CASCADING" ("QUALIFIED") per il metodo "set_name". La chiamata è corretta poiché "proc_id3" è dello stesso tipo PROCESS al quale il metodo appartiene, ed il metodo è di tipo "PUBLIC", e può (e deve) essere chiamato esternamente mediante forma "QUALIFIED". Tuttavia genera errore in esecuzione poiché proc_id3" non contiene un ID di istanza valido (valore 0).
  • L'istruzione "proc_id[1].set_name("Gemix").set_age(100);" nel blocco "process_methods" utilizza il modello di chiamata "CHAINING" ("QUALIFIED") per i metodi "set_name" e "set_age". Le chiamate sono corrette poiché "proc_id[1]" è dello stesso tipo PROCESS al quale i metodi appartengono, inoltre i metodi sono di tipo "PUBLIC", e possono (e devono) essere chiamati esternamente mediante forma "QUALIFIED", ed entrambi restituiscono lo stesso tipo PROCESS al quale appartengono.
  • L'istruzione "proc_id[2].set_name("Studio").set_age(101).configure();" nel blocco "process_methods" utilizza il modello di chiamata "CHAINING" ("QUALIFIED") per i metodi "set_name", "set_age" e "configure". Le chiamate di "set_name" e "set_age" sono corrette poiché "proc_id[2]" dello stesso tipo PROCESS al quale i metodi appartengono, inoltre i metodi sono di tipo "PUBLIC", e possono (e devono) essere chiamati esternamente mediante forma "QUALIFIED", e tutti eccetto l'ultimo restituiscono lo stesso tipo PROCESS al quale appartengono. Tuttavia la chiamata per il metodo "configure" genera errore di compilazione, poiché il metodo è di tipo "PRIVATE" e non può essere chiamato esternamente.
  • L'istruzione "proc_id3.set_name("DIV-Like").set_age(999);" nel blocco "process_methods" utilizza il modello di chiamata "CHAINING" ("QUALIFIED") per i metodi "set_name" e "set_age". Le chiamate sono corrette poiché "proc_id3" è dello stesso tipo PROCESS al quale i metodi appartengono, e i metodi sono di tipo "PUBLIC", e possono (e devono) essere chiamati esternamente mediante forma "QUALIFIED", ed entrambi restituiscono lo stesso tipo PROCESS al quale appartengono. Tuttavia genera errore in esecuzione poiché "proc_id3" non contiene un ID di istanza valido (valore 0).
  • L'istruzione "set_name("DIV-Like");" nel blocco "proc" utilizza il modello di chiamata "CASCADING" ("DIRECT") per il metodo "set_name". La chiamata è corretta, essendo effettuata nella stessa zona (PROCESS scope) al quale il metodo appartiene, inoltre è di tipo "PUBLIC", e può essere chiamato mediante forma "DIRECT" (o opzionalmente "QUALIFIED").
  • L'istruzione "set_age(999);" nel blocco "proc" utilizza il modello di chiamata "CASCADING" ("DIRECT") per il metodo "set_age". La chiamata è corretta, essendo effettuata nella stessa zona (PROCESS scope) al quale il metodo appartiene, inoltre è di tipo "PUBLIC", e può essere chiamato mediante forma "DIRECT" (o opzionalmente "QUALIFIED").
  • L'istruzione "configure();" nel blocco "proc" utilizza il modello di chiamata "CASCADING" ("DIRECT") per il metodo "configure". La chiamata è corretta, essendo effettuata nella stessa zona (PROCESS scope) al quale il metodo appartiene, inoltre è di tipo "PRIVATE", e può essere chiamato mediante forma "DIRECT" (o opzionalmente "QUALIFIED").
  • L'istruzione (commentata) "onclick();" nel blocco "proc" utilizza il modello di chiamata "CASCADING" ("DIRECT") per il metodo "onclick". La chiamata genera errore poiché anche se effettuata nella stessa zona (PROCESS scope) al quale il metodo appartiene, questo è di tipo "CALLBACK" è non può essere chiamato esplicitamente (mediante forma "DIRECT" o "QUALIFIED"), ma solo attraverso un FOBJECT.
  • L'istruzione "set_name("DIV-Like").set_age(999).configure();" nel blocco "proc" utilizza il modello di chiamata "CHAINING" ("DIRECT") per li metodi "set_name", "set_age" e "configure". Le chiamate sono corrette poichè sono effettuate nella stessa zona (PROCESS scope) al quale i metodi appartengono, inoltre i metodi sono di tipo "PUBLIC" e "PRIVATE", e possono essere chiamati mediante forma "DIRECT" (o opzionalmente "QUALIFIED"), e tutti eccetto l'ultimo restituiscono lo stesso tipo PROCESS al quale appartengono.
NOTA:
  • Se si tenta di chiamare un metodo inesistente (modello di chiamata "CASCADING" o "CHAINING" ("DIRECT" o "QUALIFIED")), si avrà un errore di compilazione.
  • Se si tenta di chiamare un metodo di tipo PRIVATE esternamente (modello di chiamata "CASCADING" o "CHAINING"), si avrà un errore di compilazione.
  • Se si tenta di chiamare esplicitamente un metodo di tipo CALLBACK, (modello di chiamata "CASCADING" o "CHAINING"), si avrà un errore di compilazione. Questo tipo di metodo può essere chiamato solo attraverso un FOBJECT (per una trattazione dettagliata sugli FOBJECT, vedere la DOC "Function Object's").
  • In un modello di chiamata "CHAINING", solo l'ultimo metodo chiamato può essere di modello "NORMAL", gli altri devono essere di modello "CHAIN", altrimenti si avrà un errore di compilazione.
  • Un metodo può chiamare se stesso (chiamata ricorsiva), un'altro metodo o blocco PROCESS/FUNCTION.
  • Se si tenta di chiamare un metodo esternamente (modello di chiamata "CASCADING" o "CHAINING" in forma "QUALIFIED") e l'ID dell'istanza del tipo PROCESS non è valido, si avrà un errore in fase di esecuzione.
  • Il modello di chiamata "CHAINING" per chiamate multiple di metodo è più efficiente rispetto all'equivalente modello di chiamata "CASCADING" in termini di esecuzione, quindi si raccomanda di utilizzare questo modello quando possibile.


5 - METODI BUILT-IN
Un metodo built-in, è uno speciale metodo predefinito di tipo CALLBACK, utilizzato dal core di Gemix per l'esecuzione di eventi particolari.


5.1 - METODI BUILT-IN: DICHIARAZIONE
Tutti i metodi built-in sono automaticamente dichiarati per il tipo PROCESS che li definisce, e non è necessario (ne possibile) dichiararli esplicitamente.


5.2 - METODI BUILT-IN: DEFINIZIONE
Una definizione di metodo built-in ha la seguente forma:
method callback [return_type] name([signature]);
begin
instructions_code...
end

  • callback - Rappresenta il tipo di metodo ed il suo accesso).
  • return_type - Rappresenta il tipo di ritorno del metodo (INT, FLOAT, DOUBLE, etc...).
  • name - Rappresenta il nome del metodo "(es: "set").
  • signature - Rappresenta la lista di parametri (es: set(int value)).
  • begin/end - Rappresenta la coppia che forma il corpo (definizione) del metodo.
  • instructions_code... - Rappresenta una lista di istruzioni che formano la implementazione del metodo.

5.3 - METODI BUILT-IN: SUPPORTATI
Gemix supporta attualmente i seguenti metodi built-in:
  • INITIALIZE (prototipo: method callback initialize()) - Questo metodo (se definito in un tipo PROCESS) è chiamato automaticamente dal core, un attimo dopo la creazione dell'istanza del tipo PROCESS que lo definisce, e un'attimo prima dell'esecuzione del corpo del PROCESS (BEGIN/END). L'utilità di questo metodo è di poter inizializzare dati e allocare risorse appartenenti al PROCESS.
  • SIGNALS (prototipo: method callback signals()) - Questo metodo (se definito in un tipo PROCESS) è chiamato automaticamente dal core, immediatamente dopo l'esecuzione della funzione SIGNAL applicata al tipo PROCESS stesso. L'utilità di questo metodo è di eseguire particolari azioni in risposta al tipo di segnale ricevuto dal tipo PROCESS.
  • FINALIZE (prototipo: method callback finalize()) - Questo metodo (se definito in un tipo PROCESS) è chiamato automaticamente dal core, un attimo prima della distruzione di una istanza del tipo PROCESS che lo definisce (quando si eseguirà un segnale S_KILL ricevuto, la sentenza RETURN o END del tipo PROCESS). L'utilità principale di questo metodo è poter deallocare risorse appartenenti al PROCESS, e eventualmente eseguire azioni particolari.

Esempio:
Source Code (Gemix) [ Download ] [ Hide ]
  • compiler_options _use_cstyle;
  • program process_methods;
  •  
  • declare
  •   methods proc
  •     method public string get_name();
  •     method public proc set_name(string);
  •     method public proc set_age(int);
  •   end
  •  
  • private
  •   proc proc_id;
  •  
  • begin
  •   mode_set(320, 200, 32);
  •  
  •   proc_id = proc();
  •   proc_id.set_name("Gemix").set_age(999); // Method chaining...
  •      
  •   repeat
  •     if(keydown(_f))
  •       signal(proc_id, s_freeze);
  •     elseif(keydown(_s))
  •       signal(proc_id, s_sleep);
  •     elseif(keydown(_k))
  •       signal(proc_id, s_kill);  
  •     elseif(keydown(_w))
  •       signal(proc_id, s_wakeup);  
  •     end
  •  
  •     frame;
  •   until(keydown(_esc));
  •   let_me_alone();
  • end
  •  
  • process proc()
  • private
  •   string name;
  •   string which;
  •   int age;
  •   int dir = 1;
  •   int id_txt[4];
  •  
  • methods
  •   method callback initialize()
  •   begin
  •     name  = "Unknown";
  •     which = "initialize";
  •                        
  •     id_txt[0] = write(0, 160, 10, 4, name);            
  •     id_txt[1] = write(0, 160, 20, 4, &age);            
  •     id_txt[2] = write(0, 160, 30, 4, which);
  •     id_txt[3] = write(0, 160, 40, 4, &reserved.status);
  •        
  •     x     = 160;
  •     y     = 100;
  •     graph = map_new(10, 10, 0x0000FF00);  
  •   end
  •  
  •   method callback signals()
  •   begin
  •     which = "signals";
  •        
  •     switch(reserved.status)
  •       case 2: // wakeup:    
  •         if(id_txt[4] != 0)
  •           text_delete(id_txt[4]);      
  •         end
  •       end
  •  
  •       case 3: // sleep:      
  •         if(id_txt[4] != 0)
  •           text_delete(id_txt[4]);      
  •         end
  •         id_txt[4] = write(0, 160, 100, 4, "SLEEPING...");
  •       end
  •  
  •       case 4: // freeze:      
  •         if(id_txt[4] != 0)
  •           text_delete(id_txt[4]);      
  •         end
  •         id_txt[4] = write(0, 160, 100, 4, "FROZEN...");
  •       end
  •     end
  •   end
  •  
  •   method callback finalize()
  •   begin
  •     if(id_txt[0] != 0) text_delete(id_txt[0]); end     
  •     if(id_txt[1] != 0) text_delete(id_txt[1]); end     
  •     if(id_txt[2] != 0) text_delete(id_txt[2]); end
  •     if(id_txt[3] != 0) text_delete(id_txt[3]); end
  •     if(id_txt[4] != 0) text_delete(id_txt[4]); end
  •          
  •     map_unload(graph); 
  •   end
  •  
  •   method public proc set_name(string name)
  •   begin
  •     this.name = name;
  •     return(this);
  •   end
  •  
  •   method public proc set_age(int age)
  •   begin
  •     this.age = age;
  •     return(this);
  •   end
  •        
  • begin
  •   loop
  •     switch(dir)
  •       case 1: // right
  •         x += 2;
  •         if(x > 320) dir = 2; end
  •       end
  •       case 2: // left
  •         x -= 2;
  •         if(x < 0) dir = 1; end
  •       end
  •     end
  •    
  •     if(keydown(_space))
  •       return;
  •     end
  •    
  •     frame;
  •   end
  • end
  •  

L'esempio precedente verrà eseguito nella seguente forma:
  • L'istruzione "proc_id = proc();" creerà una istanza del tipo PROCESS "proc", il core di Gemix chiamerà automaticamente il metodo built-in "initialize" (definito nello stesso tipo PROCESS) il quale si incaricherà di inizializzare i dati dell'istanza, creare vari testi nello schermo (con WRITE) ed un grafico in memoria (con MAP_NEW) che sarà utilizzato dall'istanza del tipo PROCESS per il rendering.
  • Le istruzioni "keydown" per i tasti "F, S, K e W" eseguiranno la funzione SIGNAL per un tipo di segnale specifico, il core di Gemix chiamera automaticamente il metodo built-in "signals" (definito nello stesso tipo PROCESS) il quale si incaricherà di eseguire un'azione per ogni tipo specifico di segnale che l'istanza del tipo PROCESS abbia ricevuto. Nel caso del segnale S_KILL, il core di Gemix chiamerà automaticamente anche il metodo built-in "finalize" (definito nello stesso tipo PROCESS) un attimo prima di distruggere l'istanza del tipo PROCESS.
  • L'istruzione "keydown" per il tasto "SPACE" eseguirà la sentenza RETURN dell'istanza del tipo PROCESS, il core di Gemix chiamerà automaticamente il metodo built-in "finalize" (definito nello stesso tipo PROCESS) il quale si incaricherà di distruggere (con TEXT_DELETE) i testi creati, e scaricare dalla memoria (con MAP_UNLOAD) il grafico creato precedentemente per il rendering, un attimo prima di distruggere l'istanza del tipo PROCESS.
  • L'istruzione "keydown" per il tasto "ESC" finalizzerà il loop principale del programma, l'istruzione seguente (LET_ME_ALONE) lancerà un segnale S_KILL all'istanza del tipo PROCESS "proc", il core di Gemix chiamerà automaticamente il metodo built-in "finalize" (definito nello stesso tipo PROCESS) il quale si incaricherà di distruggere (con TEXT_DELETE) i testi creati, e scaricare dalla memoria (con MAP_UNLOAD) il grafico creato precedentemente per il rendering, un attimo prima di distruggere l'istanza del tipo PROCESS.
NOTA:
  • Se si tenta di dichiarare un metodo built-in esplicitamente, si avrà un errore di compilazione.
  • Se si tenta di definire un metodo built-in non supportato, si avrà un errore di compilazione.
  • Il prototipo della definizione del metodo built-in deve coincidere con quello della dichiarazione, altrimenti si avrà un errore di compilazione.
  • Se si tenta di dichiarare/definire più metodi con lo stesso nome di un metodo built-in (per creare overloads), si avrà un errore di compilazione.
  • La "signature" nella definizione di un metodo built-in (se indicata nel prototipo della dichiarazione) deve essere una lista di tipi e nomi di parametri separati dal simbolo ",". Se il parametro non ha assegnato un nome, si avrà un errore di compilazione.
  • Affinché una definizione di metodo built-in sia valid, deve contenere la coppia "BEGIN/END" (definizione) che forma il corpo del metodo, altrimenti si avrà un errore di compilazione. Non è necessario che il metodo contenga "instructions_code..." affinché la definizione dello stesso sia valida.
  • L'ordine di definizione dei metodi built-in può essere distinto dall'ordine di dichiarazione degli stessi, e non è necessario che i metodi built-in dichiarati, siano definiti.
  • Se "instructions_code..." contiene una o più sentenze FRAME, si avrà un errore di compilazione, poiché un metodo built-in non può utilizzare FRAME (sentenza riservata solo ad entità speciali come PROCESS o FUNCTION).
  • Se si tenta di assegnare un metodo built-in ad un FOBJECT, si avrà un errore di compilazione. Un metodo built-in non può essere chiamato esplicitamente in nessuna forma.
  • Se si tenta di chiamare esplicitamente un metodo built-in, si avrà un errore di compilazione. Un metodo built-in può essere chiamato solo automaticamente dal core di Gemix.
User avatar
CicTec
 
Posts: 15201
Joined: Thu Jul 31, 2008 10:18 pm

Return to Documentazione

Who is online

Users browsing this forum: No registered users and 1 guest