[DOC] Scope's and Type Access

by **CicTec** » Mon Nov 18, 2013 1:36 am

In Gemix tutti i programmi sono formati da una serie di "entità" (per entità ci si riferisce a qualunque elemento definito o predefinito del programma, dotato di nome, es: typedef, struct, variabile, funzione, metodo, processo, etc...).

Uno "scope" è una zona del programma dove una entità è visibile e/o accessibile.

1 - TIPI DI SCOPE
In Gemix esistono 2 tipi di scope:

GLOBAL - Rappresenta l'intero programma, le entità definite in questo scope hanno visibilità e accesso in qualunque parte del programma.
LOCAL - Rappresenta una zona concreta del programma, per default le entità definite in questo scope hanno visibilità e accesso solo in questa parte del programma, salvo che il tipo di accesso sia pubblico.

Le entità definite in uno scope "LOCAL" possono avere 2 tipi di accesso:

PUBLIC - Indica che la entità è accessibile da qualunque parte del programma se opportunamente qualificata, o direttamente se si trova nella zona del programma alla quale appartiene.
PRIVATE - Indica che la entità è accessibile solo nella zona del programma alla quale appartiene.

1.2 - TIPI DI SCOPE - DEFINIZIONE DI ENTITA'
Qualunque entità prima di essere utilizzabile, deve essere definita.

A seconda del tipo di entità, questa necessita di essere definita in una sezione specifica del programma indicata per mezzo di qualche parola chiave che identifichi il tipo e lo scope alla quale appartiene.

La forma tipica di un programma in Gemix, l'ordine ed il tipo di sezioni è il seguente:

Code: Select all: { [ compiler_options ] { program name; [ include "file_name1.prg" ... include "file_nameN.prg" ] [ const const_defs... ... [end] ] [ declare { methods processtype_name method_decls... end } ... [end] ] [ typedef { type name field_defs... end } ... [end] ] [ global data_defs... ... [end] ] { [ local data_defs... ... [end] ] } [ private data_defs... ... [end] ] begin instructions_code... ... end } { [ process name([param_list]) * [ public data_defs... ... [end] ] [ private data_defs... ... [end] ] [ methods { method [access_modifier] [return_type] name([param_list]) [ private data_defs... ... [end] ] begin ... end ] } begin instructions_code... ... end ] } { [ function [access_modifier] [return_type] name([param_list]) * [ private data_defs... ... [end] ] begin instructions_code... ... end ] } } legend: { } = scope [ ] = optional * = in any order

Se il programma è formato da vari file sorgenti (.PRG) la tipica forma per l'ordine ed il tipo di sezioni di un file di inclusione (quello che non definisce il punto di ingresso del programma mediante la parola PROGRAM) è il seguente:

Code: Select all: { [ compiler_options ] [ include "file_name1.prg" ... include "file_nameN.prg" ] [ const const_defs... ... [end] ] [ declare { methods processtype_name method_decls... end } ... [end] ] [ typedef { type name field_defs... end } ... [end] ] [ global data_defs... ... [end] ] { [ local data_defs... ... [end] ] } { [ process name([param_list]) * [ public data_defs... ... [end] ] [ private data_defs... ... [end] ] [ methods { method [access_modifier] [return_type] name([param_list]) [ private data_defs... ... [end] ] begin ... end ] } begin instructions_code... ... end ] } { [ function [access_modifier] [return_type] name([param_list]) * [ private data_defs... ... [end] ] begin instructions_code... ... end ] } } legend: { } = scope [ ] = optional * = in any order

Nel seguente listato è possibile vedere le varie sezioni disponibili:

CONST - In questa sezione vengono definite entità che corrispondono a dati costanti, queste entità appartengono allo scope "GLOBAL".
TYPEDEF - In questa sezione vengono definite entità che rappresentano nuovi tipi di dati definiti dall'utente, queste entità appartengono allo scope "GLOBAL".
GLOBAL - In questa sezione vengono definite entità che corrispondono a dati variabili (variabili, arrays, strutture), queste entità appartengono allo scope "GLOBAL".
LOCAL - In questa sezione vengono definite entità che corrispondono a dati variabili (variabili, arrays, strutture), queste entità appartengono allo scope "LOCAL" con tipo di accesso "PUBLIC" (possono essere utilizzate in qualunque punto del programma se opportunamente qualificate).
PUBLIC - In questa sezione vengono definite entità che corrispondono a dati variabili (variabili, arrays, strutture), queste entità appartengono allo scope "LOCAL" con tipo di accesso "PUBLIC" (possono essere utilizzate in qualunque punto del programma se opportunamente qualificate).
PRIVATE - In questa sezione vengono definite entità che corrispondono a dati variabili (variabili, arrays, strutture), queste entità appartengono allo scope "LOCAL" con tipo di accesso "PRIVATE" (possono essere utilizzate solo nella parte del programa alla quale appartengono).
PARAM_LIST - In questa sezione vengono definite entità che corrispondono a dati variabili (variabili e puntatori), queste entità appartengono allo scope "LOCAL" del blocco nel quale sono definite con tipo di accesso "PUBLIC o PRIVATE" (in base a come sono definite).
PROCESS - Questa keyword permette di definire entità che corrispondono a blocchi di codice di uso speciale nel linguaggio, potendo rappresentare entità fisiche del gioco (menu, arma, nemico, protagonista, etc...), queste entità appartengono allo scope "GLOBAL".
METHOD - Questa keyword permette di definire entità che corrispondono a blocchi di codice che eseguono azioni o manipolazioni di dati nel gioco (IA, fisica, setting, getting, etc...) legate ai processi, queste entità appartengono allo scope "LOCAL" del processo al quale appartengono con tipo di accesso "PUBLIC, PRIVATE o CALLBACK" (in base a come sono definite).
FUNCTION - Questa keyword permette di definire entità che corrispondono a blocchi di codice che eseguono azioni o manipolazioni di dati nel gioco (IA, fisica, setting, getting, etc...), queste entità appartengono allo scope "GLOBAL" con tipo di accesso "PUBLIC o CALLBACK" (in base a come sono definite).

Esempio:

Source Code (Gemix) [ Download ] [ Hide ]

program scopes_and_type_access;
const
  my_const = 10;
 
typedef
  type my_type
    int my_var;
  end
 
global
  //int my_type; // genera errore se decommentato, poichè il nome non è nuovo (entità GLOBAL type my_type)
  int my_var;
 
local
  int my_var;
  
private
  //int my_var; // genera errore se decommentato, poichè il nome non è nuovo (entità LOCAL int my_var)
  int my_var2;
 
begin
  ...
end
 
process proc(int my_param, private int my_param2, public int my_param3)
public
  int my_public;
 
private
  int my_private;
 
methods
  method my_method(int my_param, private int my_param2)
  private
    int my_private;
  begin
    ...
  end
 
begin
  ...
end
 
function func(int my_param, private int my_param2)
private
  int my_private;
 
begin
  ...
end
 

L'esempio precedente crea le seguenti entità

Una entità di nome "my_const" che rappresenta una costante, appartenente allo scope "GLOBAL".
Una entità di nome "my_type" che rappresenta un tipo definito dall'utente, appartenente allo scope "GLOBAL".
Una entità di nome "my_var" che rappresenta una variabile, appartenente allo scope "LOCAL" del tipo "my_type" nella quale è definita, con tipo di accesso PUBLIC (default).
Una entità di nome "my_var" che rappresenta una variabile, appartenente allo scope "GLOBAL".
Una entità di nome "my_var" che rappresenta una variabile, appartenente allo scope "LOCAL" di qualunque blocco (PROCESS o FUNCTION) che venga definito, con accesso "PUBLIC" (default).
Una entità di nome "my_var2" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "scopes_and_type_access", con accesso "PRIVATE".
Una entità di nome "proc" che rappresenta un blocco di codice ed entità fisica del programma, appartenente allo scope "GLOBAL".
Una entità di nome "my_param" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "proc", con accesso "PRIVATE" (default).
Una entità di nome "my_param2" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "proc", con accesso "PRIVATE".
Una entità di nome "my_param3" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "proc", con accesso "PUBLIC".
Una entità di nome "my_public" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "proc", con accesso "PUBLIC".
Una entità di nome "my_private" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "proc", con accesso "PRIVATE".
Una entità di nome "my_method" che rappresenta un blocco di codice per eseguire azioni o manipolare dati, appartenente allo scope "LOCAL" del blocco "proc", con accesso "PRIVATE" o "PUBLIC" (in base a come è stato definito).
Una entità di nome "my_param" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "my_method", con accesso "PRIVATE".
Una entità di nome "my_var" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "my_method", con accesso "PRIVATE" (default).
Una entità di nome "my_param2" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "my_method", con accesso "PRIVATE".
Una entità di nome "my_private" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "my_method", con accesso "PRIVATE".
Una entità di nome "func" che rappresenta un blocco di codice per eseguire azioni o manipolare dati, appartenente allo scope "GLOBAL", con accesso "PUBLIC" (default).
Una entità di nome "my_param" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "func", con accesso "PRIVATE" (default).
Una entità di nome "my_param2" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "func", con accesso "PRIVATE".
Una entità di nome "my_private" che rappresenta una variabile, appartenente allo scope "LOCAL" del blocco "func", con accesso "PRIVATE".

NOTA:

Per default tutte le entità predefinite (dei moduli di libreria), definite nelle sezioni CONST, TYPEDEF, GLOBAL e FUNCTION, appartengono allo scope "GLOBAL".
Per default tutte le entità predefinite (dei moduli di libreria), definite nelle sezioni LOCAL, appartengono allo scope "LOCAL".
Se si tenta di definire due o più entità con lo stesso nome nello stesso scope, si avrà un errore di compilazione.
E' possibile definire entità con lo stesso nome, se queste appartengono a scope distinti, eccetto i seguenti casi:
- Si definisca una entità nello scope "LOCAL" che corrisponda a un dato, il cui nome sia uguale ad un'altra entità definita nello scope "GLOBAL" nella sezione CONST o TYPEDEF.
- Si definisca una entità nello scope "LOCAL" di un'altra entità "container" (TYPEDEF o STRUCT) il cui nome sia uguale ad un'altra entità definita nello scope "GLOBAL" come PROCESS o FUNCTION.
Le entità definite nello scope "GLOBAL" hanno un ordine di priorità a seconda della sezione o forma in cui sono definite, questo ordine è il seguente: CONST, TYPEDEF, PROCESS/FUNCTION, GLOBAL. Se si tenta di definire una entità con lo stesso nome di un'altra definita in una sezione con priorità maggiore alla attuale, si avrà un errore di compilazione.
Le entità definite nello scope "LOCAL" hanno un ordine di priorità a seconda della sezione o forma in cui sono definite, questo ordine è il seguente: DECLARE, LOCAL, PARAM_LIST, PUBLIC, PRIVATE. Se si tenta di definire una entità con lo stesso nome di un'altra definita in una sezione con priorità maggiore alla attuale, si avrà un errore di compilazione.

1.3 - TIPI DI SCOPE - PRIORITA' DI ACCESSO E FORME DI ACCESSO QUALIFICATO O DIRETTO
Entità con lo stesso nome possono essere definite, se appartenenti a scope distinti.

Se più entità hanno lo stesso nome, la priorità ed il tipo di accesso cambia a seconda della zona nella quale si vuole accedere.
Le forme di accesso alle entità possono essere:

DIRETTA: entity_name - Dove "entity_name" rappresenta il nome della entità alla quale si vuole accedere.
QUALIFICATA: scope_name./->entity_name - Dove "scope_name" rappresenta lo scope (o la entità-scope) al quale la entità appartiene e "entity_name" rappresenta il nome della entità alla quale si vuole accedere.
- Gli operatori "." e "->" sono chiamati operatori di accesso e vengono utilizzati per le forme di acceso qualificato.

Le regole di priorità e di accesso sono le seguenti:

Le entità che appartengono allo scope "LOCAL" di entità PROCESS, possono essere accessibili direttamente, o opzionalmente qualificati con la parola chiave LOCAL, THIS, ID o WHOAMI ed hanno priorità maggiore rispetto alle entità appartenenti allo scope "GLOBAL". Viceversa è necessario qualificare la entità con la parola chiave LOCAL, THIS, ID, WHOAMI o altra entità che rappresenti lo scope alla quale appartiene per poter accedere alla stessa (se il tipo di accesso è "PUBLIC").
Le entità che appartengono allo scope "LOCAL" di entità METHOD, possono essere accessibili solo direttamente ed hanno una priorità maggiore rispetto alle entità appartenenti allo scope "GLOBAL" o allo scope "LOCAL" della entità PROCESS al quale la entità METHOD appartiene.
Le entità che appartengono allo scope "LOCAL" di entità FUNCTION, possono essere accessibili direttamente, o opzionalmente qualificate con la parola chiave LOCAL, THIS, ID o WHOAMI.
Le entità che appartengono allo scope "LOCAL" di altre entità "container" (tipo TYPEDEF, STRUCT, etc...) possono essere accessibili solo qualificando la entità con un'altra entità che rappresenti lo scope al quale appartiene.
Le entità che appartengono allo scope "GLOBAL" possono essere accessibili direttamente, o opzionalmente qualificate con la parola chiave GLOBAL, se non esistono altre entità con lo stesso nome definite nella zona dalla quale si vuole accedere. Viceversa è necessario qualificare la entità con la parola chiave GLOBAL per poter accedere alla stessa. Tuttavia, se la entità è definita nella sezione CONST o TYPEDEF (o come PROCESS/FUNCTION e non si tratta di una chiamata) non sarà possibile qualificarla.

Esempio:

Source Code (Gemix) [ Download ] [ Hide ]

program scopes_and_type_access;
const
  my_const = 10;
 
declare
  ...
 
typedef
  type my_type
    int my_var;
  end
 
global
  int my_var;
  my_type my_type_var;
  proc proc_instance;
  
begin
  x = my_const;
  my_var = 1; // si riferisce alla entità definita nello scope "GLOBAL". Forme alternative qualificate: global.my_var = 1.
  my_type_var.my_var = 3;
  proc_instance.x = 10; // OK, è possibile accedere alla entità "x" esternamente visto che il tipo di accesso è PUBLIC
  proc_instance.my_var = 10; // ERROR, non è possibile accedere alla entità "my_var" esternamente visto che il tipo di accesso è PRIVATE 
  clear_screen(); // si riferisce alla entità definita nello scope "GLOBAL". Forme alternative qualificate: global.clear_screen().
end
 
process proc()
private
  int my_var;
  int my_var2;
 
methods
  method clear_screen()
  private
    int my_var;
  begin
    my_var = 10; // si riferisce alla entità definita nello scope "LOCAL" di "clear_screen"
    local.my_var = 10; // si riferisce alla entità definita nello scope "LOCAL" di "proc". Forme alternative qualificate: this.my_var = 10, id.my_var = 10, whoami.my_var = 10.
    global.my_var = 10; // si riferisce alla entità definita nello scope "GLOBAL"
    my_var2 = 100; // si riferisce alla entità definita nello scope "LOCAL" di "proc". Forme alternative qualificate: this.my_var2 = 100, id.my_var2 = 100, whoami.my_var2 = 100.
  end
 
begin
  my_var = 20; // forme alternative qualificate: local.my_var = 20, this.my_var = 20, id.my_var = 20, whoami.my_var = 20.
  global.my_var = 20; // si riferisce alla entità definita nello scope "GLOBAL"
  clear_screen(); // si riferisce alla entità definita nello scope "LOCAL" del blocco "proc". Forme alternative qualificate: local.clear_screen(), this.clear_screen(), id.clear_screen(), whoami.clear_screen()
  global.clear_screen(); // si riferisce alla entità definita nello scope "GLOBAL"
end
 
function func()
private
  int my_var;
 
begin
  my_var = 30; // si riferisce alla entità definita nello scope "LOCAL" del blocco "func". Forme alternative qualificate: local.my_var = 30, this.my_var = 30, id.my_var = 30, whoami.my_var = 30.
  global.my_var = 30; // si riferisce alla entità definita nello scope "GLOBAL"
end
 

Nell'esempio precedente si accede alle seguenti entità:

Alla entità "my_const" appartenente allo scope "GLOBAL", dalla zona "LOCAL" del blocco "scopes_and_type_access". Essendo una entità definita nella sezione CONST è possibile ad essa solo in forma diretta.
Alla entità "my_var" appartenente allo scope "GLOBAL", dalla zona "LOCAL" del blocco "scopes_and_type_access". Essendo una entità definita nella sezione GLOBAL e non avendo altre entità con lo stesso nome definite nello scope "LOCAL" dell'entità "scopes_and_type_access", è possibile accedere ad essa in forma diretta (o opzionalmente in forma qualificata).
Alla entità "my_var" appartenente allo scope "LOCAL" della entità "my_type_var", dalla zona "LOCAL" del blocco "scopes_and_type_access". Essendo una entità definita nello scope di un'altra entità (TYPEDEF) è possibile accedere ad essa esternamente solo in forma qualificata, utilizzando una entità che rappresenti lo scope al quale appartiene (in questo caso la entità "my_type_var" rappresenta lo scope, visto che è definita come TYPEDEF la quale definisce una entità che definisce inoltre uno scope "LOCAL", ereditato dalla entità "my_type_var" nella definizione).
Alla entità predefinita "x" con tipo di accesso PUBLIC appartenente allo scope "LOCAL" del blocco "proc", dalla zona "LOCAL" del blocco "scopes_and_type_access". Essendo una entità definida nello scope di un'altra entità (PROCESS) è possibile accedere ad essa solo in forma qualificata, utilizzando una entità che rappresenti lo scope al quale appartiene (in questo caso la entità "proc_instance" rappresenta lo scope, visto che è definita come PROCESS la quale definisce una entità che definisce inoltre uno scope "LOCAL", ereditato dalla entità "proc_instance" nella definizione).
Alla entità "my_var" con tipo di accesso PRIVATE appartenente allo scope "LOCAL" del blocco "proc", dalla zona "LOCAL" del blocco "scopes_and_type_access". Essendo di tipo di accesso PRIVATE, non è possibile accedere ad essa esternamente (in forma diretta o qualificata).
Alla entità "clear_screen" appartenente allo scope "GLOBAL", dalla zona "LOCAL" del blocco "scopes_and_type_access". Essendo una entità definita nello scope "GLOBAL" e non avendo lo stesso nome di un'altra entità definita nello scope "LOCAL" del blocco dal quale si vuole accedere, es possibile accedere ad essa in forma diretta (o opzionalmente in forma qualificata).
Alla entità "my_var" appartenente allo scope "LOCAL" del blocco "clear_screen". Essendo una entità definita nello stesso scope del blocco dal quale si vuole accedere ed essendo il blocco di tipo METHOD, è possibile accedere ad essa solo in forma diretta.
Alla entità "my_var" appartenente allo scope "LOCAL" del blocco "proc", dalla zona "LOCAL" del blocco "clear_screen". Essendo una entità definita nello scope "LOCAL" del blocco "proc" ed avendo lo stesso nome di un'altra entità definita nello scope "LOCAL" del blocco dal quale si vuole accedere, es possibile accedere ad essa solo in forma qualificata.
Alla entità "my_var" appartenente allo scope "GLOBAL", dalla zona "LOCAL" del blocco "clear_screen". Essendo una entità definita nello scope "GLOBAL" e avendo lo stesso nome di un'altra entità definita nello scope "LOCAL" del blocco dal quale si vuole accedere, è possibile accedere ad essa solo in forma qualificata.
Alla entità "my_var2" appartenente allo scope "LOCAL" del blocco "proc", dalla zona "LOCAL" del blocco "clear_screen". Essendo una entità definita nello scope "LOCAL", non avendo lo stesso nome di un'altra entità definita nello scope "LOCAL" del blocco dal quale si vuole accedere ed essendo quest'ultimo appartenente a sua volta allo stesso scope "LOCAL" dell'entità stessa, è possibile accedere ad essa solo in forma diretta (o opzionalmente in forma qualificata).
Alla entità "my_var" appartenente allo scope "LOCAL" del blocco "proc". Essendo una entità definita nello stesso scope del blocco dal quale si vuole accedere, è possibile accedere ad essa in forma diretta (o opzionalmente in forma qualificata).
Alla entità "my_var" appartenente allo scope "GLOBAL", dalla zona "LOCAL" del blocco "proc". Essendo una entità definita nello scope "GLOBAL" ed avendo lo stesso nome di un'altra entità definita nello scope "LOCAL" del blocco dal quale si vuole accedere, è possibile accedere ad essa solo in forma qualificata.
Alla entità "clear_screen" appartenente allo scope "LOCAL" del blocco "proc". Essendo una entità definita nello stesso scope del blocco dal quale si vuole accedere, è possibile accedere ad essa in forma diretta (o opzionalmente in forma qualificata).
Alla entità "clear_screen" appartenente allo scope "GLOBAL", dalla zona "LOCAL" del blocco "proc". Essendo una entità definita nello scope "GLOBAL" ed avendo lo stesso nome di un'altra entità definita nello scope "LOCAL" del blocco dal quale si vuole accedere, è possibile accedere ad essa solo in forma qualificata.
Alla entità "my_var" appartenente allo scope "LOCAL" del blocco "func". Essendo una entità definita nello stesso scope del blocco dal quale si vuole accedere, è possibile accedere ad essa in forma diretta (o opzionalmente in forma qualificata).
Alla entità "my_var" appartenente allo scope "GLOBAL", dalla zona "LOCAL" del blocco "func". Essendo una entità definita nello scope "GLOBAL" ed avendo lo stesso nome di un'altra entità definita nello scope "LOCAL" del blocco dal quale si vuole accedere, è possibile accedere ad essa solo in forma qualificata.

NOTA:

Se si tenta di utilizzare la forma qualificata per una entità utilizzata come tipo per la definizione di un'altra entità, si avrà un errore di compilazione.
Se si tenta di accedere ad una entità inesistente (in forma diretta o qualificata), si avrà un errore di compilazione.
Se si tenta di accedere ad una entità con tipo di accesso PRIVATE, fuori dallo scope al quale appartiene (esternamente), si avrà un errore di compilazione.
Se si tenta di accedere ad una entità definita in uno scope "LOCAL" di una entità TYPEDEF, utilizzando come scope direttamente il nome della entità TYPEDEF (e no un'altra entità definita come questo tipo), si avrà un errore di compilazione.
E' possibile accedere ad una entità METHOD definita nello scope "LOCAL" di una entità PROCESS utilizzando come scope direttamente il nome della entità PROCESS stessa (forma qualificata), se questa risulta essere un RVALUE per una inizializzazione/assegnazione di una entità di tipo FOBJECT. Se si tenta di accedere a qualunque altra entità di tipo distinto a METHOD, o per effettuare una chiamata alla entità METHOD stessa, si avrà un errore di compilazione.
E' possibile usare gli operatori di access ("." e "->") indistintamente, tuttavia si raccomanda di utilizzare l'operatore "." per entità-scope che rappresentano variabili normali e l'operatore "->" per entità-scope che rappresentano puntatori.

[DOC] Scope's and Type Access

[DOC] Scope's and Type Access

Who is online