oberon.h

   1 #ifndef EMBEDED_OBERON_SCRIPT_H
   2 #define EMBEDED_OBERON_SCRIPT_H
   3
   4 #include <libgccjit.h>
   5
   6 typedef struct gen_proc_s gen_proc_t;
   7 typedef struct gen_type_s gen_type_t;
   8 typedef struct gen_var_s gen_var_t;
   9 typedef struct gen_block_s gen_block_t;
  10 typedef struct gen_context_s gen_context_t;
  11
  12 struct gen_proc_s
  13 {
  14         gcc_jit_function * gcc_func;
  15 };
  16
  17 struct gen_type_s
  18 {
  19         gcc_jit_type * gcc_type;
  20         gcc_jit_struct * gcc_struct;
  21 };
  22
  23 struct gen_var_s
  24 {
  25         gcc_jit_lvalue * gcc_lvalue;
  26         gcc_jit_param * gcc_param;
  27         gcc_jit_field * gcc_field;
  28 };
  29
  30 struct gen_block_s
  31 {
  32         gcc_jit_block * gcc_block;
  33         gen_block_t * up;
  34 };
  35
  36 struct gen_context_s
  37 {
  38         gcc_jit_context * gcc_context;
  39         gcc_jit_result * gcc_result;
  40         gen_block_t * block;
  41 };
  42
  43 typedef struct oberon_type_s oberon_type_t;
  44 typedef struct oberon_object_s oberon_object_t;
  45 typedef struct oberon_module_s oberon_module_t;
  46 typedef struct oberon_context_s oberon_context_t;
  47 typedef struct oberon_scope_s oberon_scope_t;
  48
  49 typedef struct oberon_item_s oberon_item_t;
  50 typedef struct oberon_oper_s oberon_oper_t;
  51 typedef union oberon_expr_u oberon_expr_t;
  52
  53 /*
  54  * Структура oberon_scope_s (oberon_type_t) реализует стекообразную
  55  * область видимости объектов.
  56  * Поля:
  57  *   ctx  -- контекст в котором область видимости была создана;
  58  *   list -- список объявлений. Первый элемент всегда существует,
  59  *           но не используется и должен быть пропущен.
  60  *   up   -- ссылка на облась видимости уровнем выше.
  61  */
  62
  63 struct oberon_scope_s
  64 {
  65         oberon_context_t * ctx;
  66         oberon_object_t * list;
  67         oberon_scope_t * up;
  68
  69         oberon_object_t * parent;
  70         int local;
  71 };
  72
  73 /*
  74  * Формы типов данных.
  75  * Тип VOID используется как заглушка возврата типа в обычных процедурах
  76  */
  77
  78 enum
  79 {
  80         OBERON_TYPE_VOID,
  81         OBERON_TYPE_INTEGER,
  82         OBERON_TYPE_BOOLEAN,
  83         OBERON_TYPE_PROCEDURE,
  84         OBERON_TYPE_ARRAY,
  85         OBERON_TYPE_RECORD,
  86         OBERON_TYPE_POINTER
  87 };
  88
  89 /*
  90  * Структура oberon_type_s (oberon_type_t) описывает типы данных.
  91  * Поля:
  92  *   class -- Форма типа данных (OBERON_TYPE_*).
  93  *   size  -- Размер примитива в байтах или количество ячеек массива.
  94  *            Ноль для открытых массивов.
  95  *   num_decl -- Количество объявленых полей в структуре или сигнатуре процедуры.
  96  *   base  -- Базовый тип структуры или тип возврата процедуры.
  97  *   decl -- Список объявлений. Перебор начинается с первого элемента.
  98  *
  99  * Таблица использования полей:
 100  *   class size num_decl base decl
 101  *   VOID  -    -        -    -
 102  *   INT   +    -        -    -
 103  *   BOOL  +    -        -    -
 104  *   PROC  -    +        +    +
 105  */
 106
 107 struct oberon_type_s
 108 {
 109         int class;
 110         int size;
 111
 112         int num_decl;
 113         oberon_type_t * base;
 114         oberon_object_t * decl;
 115
 116         int recursive;
 117         int initialized;
 118         gen_type_t * gen_type;
 119 };
 120
 121 /*
 122  * Классы объектов.
 123  *   VAR -- переменная.
 124  *   TYPE -- тип данных.
 125  *   PROC -- процедура.
 126  *   PARAM -- параметр процедуры.
 127  *   VAR_PARAM -- VAR-параметр процедуры.
 128  */
 129
 130 enum
 131 {
 132         OBERON_CLASS_VAR,
 133         OBERON_CLASS_TYPE,
 134         OBERON_CLASS_PROC,
 135         OBERON_CLASS_PARAM,
 136         OBERON_CLASS_VAR_PARAM,
 137         OBERON_CLASS_CONST,
 138         OBERON_CLASS_FIELD
 139 };
 140
 141 /*
 142  * Структура oberon_object_s (oberon_object_t) описывает все
 143  * объявления которые могут иметь имя. От констант, до процедур.
 144  * Поля:
 145  *   name -- имя объекта.
 146  *   class -- класс объекта (OBERON_CLASS_*).
 147  *   type -- ссылка на тип переменной, дескриптор типа или сигнатуру процедуры.
 148  *   next -- ссылка на следующий объект в списке.
 149  */
 150
 151 struct oberon_object_s
 152 {
 153         char * name;
 154         int class;
 155
 156         int local;
 157         int linked;
 158         int initialized;
 159
 160         oberon_object_t * parent;
 161         int has_return; // for proc
 162
 163
 164         oberon_type_t * type;
 165         oberon_item_t * value;
 166         oberon_object_t * next;
 167
 168         gen_var_t * gen_var;
 169         gen_proc_t * gen_proc;
 170 };
 171
 172 /*
 173  * Структура oberon_module_s (oberon_module_t) описывает объявление модуля.
 174  * Поля:
 175  *   name -- настоящее имя модуля.
 176  *   decl -- все глобальные объявления в модуле.
 177  *   begin -- Указатель на сгенерированный код тела модуля (секция BEGIN).
 178  */
 179
 180 struct oberon_module_s
 181 {
 182         char * name;
 183
 184         oberon_scope_t * decl;
 185
 186         void (* begin)();
 187 };
 188
 189 /*
 190  * Структура oberon_context_s (oberon_context_t) учитывает текущее состояние интерпретатора.
 191  * Один экземпляр не может использоваться в нескольких потоках одновременно.
 192  * Поля:
 193  *   code    -- входной буффер для сканера.
 194  *   code_index -- Текущая позия в буффере.
 195  *   с       -- последний прочитанный символ.
 196  *   token   -- последний прочитанный токен.
 197  *   string  -- буфер с прочитанной строкой / идентификатором.
 198  *              всегда имеет уникальный адрес и может изменяться.
 199  *   integer -- прочитанное целое число.
 200  *   decl    -- текущая область видимости.
 201  *   mod     -- текущий модуль.
 202  *   int_type, bool_type, void_type -- стандартные типы.
 203  *   world_scope -- область видимости "мир" - выше модуля.
 204  */
 205
 206 struct oberon_context_s
 207 {
 208         const char * code;
 209         int code_index;
 210
 211         char c;
 212         int token;
 213         char * string;
 214         int integer;
 215
 216         oberon_scope_t * decl;
 217         oberon_module_t * mod;
 218
 219         oberon_type_t * int_type;
 220         oberon_type_t * bool_type;
 221         oberon_type_t * void_type;
 222         oberon_type_t * void_ptr_type;
 223         oberon_scope_t * world_scope;
 224
 225         gen_context_t * gen_context;
 226 };
 227
 228 enum
 229 {
 230         MODE_VAR,
 231         MODE_INTEGER,
 232         MODE_BOOLEAN,
 233         MODE_CALL,
 234         MODE_INDEX,
 235         MODE_FIELD,
 236         MODE_DEREF,
 237         MODE_NIL
 238 };
 239
 240 enum
 241 {
 242         OP_LOGIC_NOT,
 243         OP_UNARY_MINUS,
 244         OP_ADD,
 245         OP_SUB,
 246         OP_MUL,
 247         OP_DIV,
 248         OP_MOD,
 249         OP_LOGIC_AND,
 250         OP_LOGIC_OR,
 251         OP_EQ,
 252         OP_NEQ,
 253         OP_LSS,
 254         OP_LEQ,
 255         OP_GRT,
 256         OP_GEQ
 257 };
 258
 259 struct oberon_item_s
 260 {
 261         int is_item; // == 1
 262         oberon_type_t * result;
 263         oberon_expr_t * next;
 264
 265         int mode;
 266         int integer;
 267         int boolean;
 268         oberon_object_t * var;
 269
 270         oberon_item_t * parent;
 271
 272         int num_args;
 273         oberon_expr_t * args;
 274 };
 275
 276 struct oberon_oper_s
 277 {
 278         int is_item; // == 0
 279         oberon_type_t * result;
 280         oberon_expr_t * next;
 281
 282         int op;
 283         oberon_expr_t * left;
 284         oberon_expr_t * right;
 285 };
 286
 287 union oberon_expr_u
 288 {
 289         struct {
 290                 int is_item;
 291                 oberon_type_t * result;
 292                 oberon_expr_t * next;
 293         };
 294
 295         oberon_item_t item;
 296         oberon_oper_t oper;
 297 };
 298
 299 oberon_context_t * oberon_create_context();
 300 void oberon_destroy_context(oberon_context_t * ctx);
 301 void oberon_register_global_type(oberon_context_t * ctx, oberon_type_t * type);
 302 oberon_module_t * oberon_compile_module(oberon_context_t * ctx, const char * code);
 303 void oberon_error(oberon_context_t * ctx, const char * fmt, ...);
 304
 305 #endif // EMBEDED_OBERON_SCRIPT_H