aboutsummaryrefslogtreecommitdiff
path: root/src/ls_kw_impl.c
blob: 6330be0a19c1ef37c98fb41634affe5663cd38cb (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
// This software disclaims copyright. Do what you want with it. Be gay, do
// crime. Originally written by Alexis Lockwood in 2021. Ⓐ

// --- DEPENDENCIES ------------------------------------------------------------

// Supporting modules
#include "ls_internal.h"
#include "ls_kws.h"
#include "ls_expr.h"
#include "ls_lex.h"
#include "ls_goto.h"

// Standard headers
#include <stdbool.h>
#include <stddef.h>
#include <inttypes.h>
#include <string.h>

// --- PRIVATE MACROS ----------------------------------------------------------
// --- PRIVATE DATATYPES -------------------------------------------------------
// --- PRIVATE CONSTANTS -------------------------------------------------------
// --- PRIVATE FUNCTION PROTOTYPES ---------------------------------------------

/// Call for keywords without implementations.
static void _no_impl(ls_t * self);

void ls_kw_fun_GOTO(ls_t * self);

// --- PUBLIC VARIABLES --------------------------------------------------------
// --- PRIVATE VARIABLES -------------------------------------------------------
// --- PUBLIC FUNCTIONS --------------------------------------------------------

void ls_kw_fun_ABS(ls_t * self) { _no_impl(self); }
void ls_kw_fun_AND(ls_t * self) { _no_impl(self); }
void ls_kw_fun_AS(ls_t * self) { _no_impl(self); }
void ls_kw_fun_ASC(ls_t * self) { _no_impl(self); }
void ls_kw_fun_AT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_ATN(ls_t * self) { _no_impl(self); }
void ls_kw_fun_CALL(ls_t * self) { _no_impl(self); }
void ls_kw_fun_CAT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_CHR(ls_t * self) { _no_impl(self); }
void ls_kw_fun_CLOSE(ls_t * self) { _no_impl(self); }
void ls_kw_fun_COS(ls_t * self) { _no_impl(self); }
void ls_kw_fun_COUNT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_DATA(ls_t * self) { _no_impl(self); }
void ls_kw_fun_DEC(ls_t * self) { _no_impl(self); }
void ls_kw_fun_DEF(ls_t * self) { _no_impl(self); }
void ls_kw_fun_END(ls_t * self) { ls_throw_err(self, LS_STOPPED); }
void ls_kw_fun_EQV(ls_t * self) { _no_impl(self); }
void ls_kw_fun_ERASE(ls_t * self) { _no_impl(self); }
void ls_kw_fun_ERROR(ls_t * self) { _no_impl(self); }
void ls_kw_fun_FN(ls_t * self) { _no_impl(self); }
void ls_kw_fun_HEX(ls_t * self) { _no_impl(self); }
void ls_kw_fun_IF(ls_t * self)
{
	// TODO how to support ELSE - the current parsing method doesn't
	// really allow it. Should we bother?
	ls_value_t cond;
	ls_eval_expr(self, &cond, LS_TOK_NONE);

	if (cond.ty != LS_TY_INT)
		ls_throw_err(self, LS_SYNTAX_ERROR);

	if (cond.body.integer.value == 0)
	{
		ls_consume_to_eol(self);
		return;
	}
	else
	{
		ls_token_t tok = ls_lex(self);

		if (tok == LS_KW_GOTO)
			ls_kw_fun_GOTO(self);
		else if (tok == LS_KW_THEN)
			// TODO (THEN) - need to factor something out of
			// ls_exec_line
			_no_impl(self);
		else
			ls_throw_err(self, LS_SYNTAX_ERROR);
	}
}

void ls_kw_fun_IMP(ls_t * self) { _no_impl(self); }
void ls_kw_fun_INPUT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_LEFT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_LET(ls_t * self) { _no_impl(self); }
void ls_kw_fun_LOG(ls_t * self) { _no_impl(self); }
void ls_kw_fun_MID(ls_t * self) { _no_impl(self); }
void ls_kw_fun_NOT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_OCT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_ON(ls_t * self) { _no_impl(self); }
void ls_kw_fun_OR(ls_t * self) { _no_impl(self); }
void ls_kw_fun_OPEN(ls_t * self) { _no_impl(self); }
void ls_kw_fun_PACK(ls_t * self) { _no_impl(self); }
void ls_kw_fun_RANDOMIZE(ls_t * self) { _no_impl(self); }
void ls_kw_fun_READ(ls_t * self) { _no_impl(self); }

void ls_kw_fun_REM(ls_t * self)
{
	ls_consume_to_eol(self);
}

void ls_kw_fun_RESTORE(ls_t * self) { _no_impl(self); }
void ls_kw_fun_RIGHT(ls_t * self) { _no_impl(self); }
void ls_kw_fun_RND(ls_t * self) { _no_impl(self); }
void ls_kw_fun_SIN(ls_t * self) { _no_impl(self); }
void ls_kw_fun_SQR(ls_t * self) { _no_impl(self); }
void ls_kw_fun_STEP(ls_t * self) { _no_impl(self); }
void ls_kw_fun_SWAP(ls_t * self) { _no_impl(self); }
void ls_kw_fun_TAN(ls_t * self) { _no_impl(self); }
void ls_kw_fun_THEN(ls_t * self) { _no_impl(self); }
void ls_kw_fun_TO(ls_t * self) { _no_impl(self); }
void ls_kw_fun_UNPACK(ls_t * self) { _no_impl(self); }
void ls_kw_fun_UNTIL(ls_t * self) { _no_impl(self); }
void ls_kw_fun_VAL(ls_t * self) { _no_impl(self); }
void ls_kw_fun_WRITE(ls_t * self) { _no_impl(self); }
void ls_kw_fun_XOR(ls_t * self) { _no_impl(self); }

// --- PRIVATE FUNCTION DEFINITIONS --------------------------------------------

static void _no_impl(ls_t * self)
{
	ls_throw_err(self, LS_BAD_KEYWORD);
}