/****************************************************************************
**
*F Match( <symbol>, <msg>, <skipto> ) . match current symbol and fetch next
**
** 'Match' is the main interface between the scanner and the parser. It
** performs the four most common actions in the scanner with just one call.
** First it checks that the current symbol stored in the variable 'Symbol'
** is the expected symbol as passed in the argument <symbol>. If it is,
** 'Match' reads the next symbol from input and returns. Otherwise 'Match'
** first prints the current input line followed by the syntax error message:
** '^ syntax error, <msg> expected' with '^' pointing to the current symbol.
** It then skips symbols up to one in the resynchronisation set <skipto>.
** Actually 'Match' calls 'SyntaxError' so its comments apply here too.
**
** One kind of typical 'Match' call has the form
**
** 'Match( Symbol, "", 0L );'.
**
** This is used if the parser knows that the current symbol is correct, for
** example in 'ReadReturn' the first symbol must be 'S_RETURN', otherwise
** 'ReadReturn' would not have been called. Called this way 'Match' will of
** course never raise a syntax error, therefore <msg> and <skipto> are of no
** concern. The effect of this call is merely to read the next symbol from
** input.
**
** Another typical 'Match' call is in 'ReadIf' after we read the if symbol
** and the condition following, and now expect to see the 'then' symbol:
**
** Match( S_THEN, "then", STATBEGIN|S_ELIF|S_ELSE|S_FI|follow );
**
** If the current symbol is 'S_THEN' it is matched and the next symbol is
** read. Otherwise 'Match' prints the current line followed by the error
** message: '^ syntax error, then expected'. Then 'Match' skips all symbols
** until finding either a symbol that can begin a statment, an 'elif' or
** 'else' or 'fi' symbol, or a symbol that is contained in the set <follow>
** which is passed to 'ReadIf' and contains all symbols allowing one of the
** calling functions to resynchronize, for example 'S_OD' if 'ReadIf' has
** been called from 'ReadFor'. <follow> always contain 'S_EOF', which 'Read'
** uses to resynchronise.
**
** If 'Match' needs to read a new line from '*stdin*' or '*errin*' to get
** the next symbol it prints the string pointed to by 'Prompt'.
*/
void Match (
UInt symbol,
const Char * msg,
TypSymbolSet skipto )
{
Char errmsg [256];
if (STATE(InterpreterStartLine) == 0 && symbol != S_ILLEGAL) {
STATE(InterpreterStartLine) = STATE(SymbolStartLine);
}
// if 'STATE(Symbol)' is the expected symbol match it away
if ( symbol == STATE(Symbol) ) {
STATE(Symbol) = NextSymbol();
}
/* else generate an error message and skip to a symbol in <skipto> */
else {
strlcpy( errmsg, msg, sizeof(errmsg) );
strlcat( errmsg, " expected", sizeof(errmsg) );
SyntaxError( errmsg );
while ( ! IS_IN( STATE(Symbol), skipto ) )
STATE(Symbol) = NextSymbol();
}
}
IOxfReactive::TakeEventStatus Controller::On_processEvent() {
IOxfReactive::TakeEventStatus res = eventNotConsumed;
if(state_10_processEvent() > 0)
{
res = eventConsumed;
if(!IS_IN(On))
{
return res;
}
}
if(Timing_processEvent() > 0)
{
res = eventConsumed;
if(!IS_IN(On))
{
return res;
}
}
if(res == eventNotConsumed)
{
res = On_handleEvent();
}
return res;
}
// XXX: this is very close to tool_cube_iter.
static int tool_selection_iter(goxel_t *goxel, const inputs_t *inputs,
int state, const vec2_t *view_size,
bool inside)
{
extern const mat4_t FACES_MATS[6];
const bool down = inputs->mouse_down[0];
const bool up = !down;
int snaped = 0;
int face = -1;
vec3_t pos, normal;
plane_t face_plane;
box_t box;
uvec4b_t box_color = HEXCOLOR(0xffff00ff);
// See if we can snap on a selection face.
if (inside && !box_is_null(goxel->selection) &&
IS_IN(state, STATE_IDLE, STATE_SNAPED, STATE_SNAPED_FACE)) {
goxel->tool_snape_face = -1;
if (goxel_unproject_on_box(goxel, view_size, &inputs->mouse_pos,
&goxel->selection, &pos, &normal, &face)) {
goxel->tool_snape_face = face;
state = STATE_SNAPED_FACE;
}
}
if (!box_is_null(goxel->selection) && goxel->tool_snape_face != -1)
face_plane.mat = mat4_mul(goxel->selection.mat,
FACES_MATS[goxel->tool_snape_face]);
if (inside && face == -1)
snaped = goxel_unproject(goxel, view_size, &inputs->mouse_pos,
&pos, &normal);
if (snaped) {
pos.x = round(pos.x - 0.5) + 0.5;
pos.y = round(pos.y - 0.5) + 0.5;
pos.z = round(pos.z - 0.5) + 0.5;
}
if (state == STATE_IDLE) {
goxel->tool_t = 0;
goxel->tool_snape_face = -1;
if (snaped) state = STATE_SNAPED;
}
if (state == STATE_SNAPED) {
if (!snaped) return STATE_CANCEL;
goxel_set_help_text(goxel, "Click and drag to set selection.");
goxel->tool_start_pos = pos;
box = get_box(&goxel->tool_start_pos, &pos, &normal, 0,
&goxel->plane);
render_box(&goxel->rend, &box, false, &box_color, false);
if (down) {
state = STATE_PAINT;
goxel->painting = true;
}
}
if (state == STATE_PAINT) {
goxel_set_help_text(goxel, "Drag.");
goxel->selection = get_box(&goxel->tool_start_pos, &pos, &normal, 0,
&goxel->plane);
if (up) {
state = STATE_PAINT2;
goxel->tool_plane = plane_from_normal(pos, goxel->plane.u);
}
}
if (state == STATE_PAINT2) {
goxel_set_help_text(goxel, "Adjust height.");
render_plane(&goxel->rend, &goxel->tool_plane, &goxel->grid_color);
pos = vec3_add(goxel->tool_plane.p,
vec3_project(vec3_sub(pos, goxel->tool_plane.p),
goxel->plane.n));
goxel->selection = get_box(&goxel->tool_start_pos, &pos, &normal, 0,
&goxel->plane);
if (down) {
goxel->painting = false;
return STATE_WAIT_UP;
}
}
if (state == STATE_WAIT_UP) {
goxel->tool_plane = plane_null;
goxel->selection = box_get_bbox(goxel->selection);
return up ? STATE_IDLE : STATE_WAIT_UP;
}
if (IS_IN(state, STATE_SNAPED_FACE, STATE_MOVE_FACE))
goxel_set_help_text(goxel, "Drag to move face");
if (state == STATE_SNAPED_FACE) {
if (face == -1) return STATE_IDLE;
render_img(&goxel->rend, NULL, &face_plane.mat);
if (down) {
state = STATE_MOVE_FACE;
goxel->tool_plane = plane(pos, normal,
vec3_normalized(face_plane.u));
}
}
if (state == STATE_MOVE_FACE) {
if (up) return STATE_IDLE;
goxel_unproject_on_plane(goxel, view_size, &inputs->mouse_pos,
&goxel->tool_plane, &pos, &normal);
pos = vec3_add(goxel->tool_plane.p,
vec3_project(vec3_sub(pos, goxel->tool_plane.p),
vec3_normalized(face_plane.n)));
pos.x = round(pos.x);
pos.y = round(pos.y);
pos.z = round(pos.z);
goxel->selection = box_move_face(goxel->selection,
goxel->tool_snape_face, pos);
}
return state;
}
