sergio/takana

1//! El árbol del programa.
2
3use std::rc::Rc;
4use crate::regex::Regex;
5
6#[derive(Debug, Clone, Copy, PartialEq)]
7pub enum BinOp { Suma, Resta, Mult, Div, Modulo, Potencia }
8
9#[derive(Debug, Clone, Copy, PartialEq)]
10pub enum CmpOp { Lt, Le, Gt, Ge, Eq, Ne }
11
12#[derive(Clone)]
13pub enum Expr {
14    Num(f64),
15    Cad(String),
16    /// Una ERE suelta: como expresión vale `$0 ~ /re/`.
17    Ere(Rc<Regex>),
18    Var(String),
19    Campo(Box<Expr>),
20    /// `a[i]`, `a[i,j]` (los índices se unen con SUBSEP).
21    Indice(String, Vec<Expr>),
22    Asigna(Box<Lugar>, Box<Expr>),
23    /// `+=`, `-=`, … con su operador.
24    AsignaOp(Box<Lugar>, BinOp, Box<Expr>),
25    Bin(BinOp, Box<Expr>, Box<Expr>),
26    Cmp(CmpOp, Box<Expr>, Box<Expr>),
27    /// `~` y `!~`. El segundo `bool` dice si está negado.
28    Coincide(Box<Expr>, Box<Expr>, bool),
29    Y(Box<Expr>, Box<Expr>),
30    O(Box<Expr>, Box<Expr>),
31    No(Box<Expr>),
32    Neg(Box<Expr>),
33    Pos(Box<Expr>),
34    Ternario(Box<Expr>, Box<Expr>, Box<Expr>),
35    /// Concatenación por yuxtaposición: `a b`.
36    Concat(Box<Expr>, Box<Expr>),
37    /// `++x` / `x++` (y `--`). `previo` = es prefijo.
38    Incr(Box<Lugar>, bool, f64),
39    /// `(i, j) in a` y `i in a`.
40    En(Vec<Expr>, String),
41    Llamada(String, Vec<Expr>),
42    Builtin(String, Vec<Expr>),
43    /// `getline` en sus cuatro formas.
44    Getline(Getline),
45    /// `(expr)` agrupada: hay que recordarlo para distinguir `(a,b) in arr` de una lista.
46    Grupo(Box<Expr>),
47}
48
49#[derive(Clone)]
50pub enum Getline {
51    /// `getline [lugar]` — de la entrada normal.
52    Simple(Option<Box<Lugar>>),
53    /// `getline [lugar] < "fichero"`.
54    DeFichero(Option<Box<Lugar>>, Box<Expr>),
55    /// `"cmd" | getline [lugar]`.
56    DeTuberia(Box<Expr>, Option<Box<Lugar>>),
57}
58
59/// Algo a lo que se puede asignar.
60#[derive(Clone)]
61pub enum Lugar {
62    Var(String),
63    Campo(Box<Expr>),
64    Indice(String, Vec<Expr>),
65}
66
67#[derive(Clone)]
68pub enum Redir {
69    /// `> f`
70    Fichero(Box<Expr>),
71    /// `>> f`
72    Anexa(Box<Expr>),
73    /// `| "cmd"`
74    Tuberia(Box<Expr>),
75}
76
77#[derive(Clone)]
78pub enum Sent {
79    Expr(Expr),
80    Print(Vec<Expr>, Option<Redir>),
81    Printf(Vec<Expr>, Option<Redir>),
82    Bloque(Vec<Sent>),
83    Si(Expr, Box<Sent>, Option<Box<Sent>>),
84    Mientras(Expr, Box<Sent>),
85    HazMientras(Box<Sent>, Expr),
86    /// `for (init; cond; paso) cuerpo`
87    Para(Option<Box<Sent>>, Option<Expr>, Option<Box<Sent>>, Box<Sent>),
88    /// `for (k in a) cuerpo`
89    ParaEn(String, String, Box<Sent>),
90    Corta,
91    Sigue,
92    Siguiente,
93    SiguienteFichero,
94    Sale(Option<Expr>),
95    Retorna(Option<Expr>),
96    Borra(String, Vec<Expr>),
97    /// `delete a` entero.
98    BorraTodo(String),
99    Nada,
100}
101
102#[derive(Clone)]
103pub enum Patron {
104    Begin,
105    End,
106    /// Sin patrón: la acción corre para cada registro.
107    Siempre,
108    Expr(Expr),
109    /// `expr1, expr2` — rango. El `bool` es el estado (dentro/fuera), que vive en el intérprete.
110    Rango(Expr, Expr),
111}
112
113#[derive(Clone)]
114pub struct Regla {
115    pub patron: Patron,
116    pub accion: Option<Vec<Sent>>,
117    /// Índice del estado de rango, para las reglas `expr1, expr2`.
118    pub rango_id: usize,
119}
120
121#[derive(Clone)]
122pub struct Funcion {
123    pub nombre: String,
124    pub params: Vec<String>,
125    pub cuerpo: Vec<Sent>,
126}
127
128#[derive(Clone, Default)]
129pub struct Programa {
130    pub reglas: Vec<Regla>,
131    pub funciones: Vec<Funcion>,
132    pub rangos: usize,
133}