lol/doc/grammar/easymesh-scanner.l

%{
//
// Lol Engine
//
// Copyright: (c) 2010-2013 Sam Hocevar <sam@hocevar.net>
//            (c) 2009-2013 Cédric Lecacheur <jordx@free.fr>
//            (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
//   This program is free software; you can redistribute it and/or
//   modify it under the terms of the Do What The Fuck You Want To
//   Public License, Version 2, as published by Sam Hocevar. See
//   http://www.wtfpl.net/ for more details.
//

#if defined HAVE_CONFIG_H
#   include "config.h"
#endif

#include <cstdlib>
using std::exit;
using std::malloc;
using std::realloc;
using std::free;

#include "core.h"
#include "easymesh/easymesh-compiler.h"

typedef lol::EasyMeshParser::token token;
typedef lol::EasyMeshParser::token_type token_type;

#ifndef YY_DECL
#   define YY_DECL lol::EasyMeshParser::token_type \
        lol::EasyMeshScanner::lex(lol::EasyMeshParser::semantic_type* yylval, \
                                  lol::EasyMeshParser::location_type* yylloc)
#endif

#define yyterminate() return token::T_END
#define YY_NO_UNISTD_H
#define YY_USER_ACTION yylloc->columns(yyleng);
%}

%option c++ prefix="EasyMesh"
%option batch yywrap nounput stack

%%

%{  /* reset location at the beginning of yylex() */
    yylloc->step();
%}

(csgu|csgunion)          { return token::T_CSGUNION; }
(csgs|CsgSub)            { return token::T_CSGSUBSTRACT; }
(csgsl|CsgSubL)          { return token::T_CSGSUBSTRACTLOSS; }
(csga|csgand)            { return token::T_CSGAND; }
(csgx|csgxor)            { return token::T_CSGXOR; }

(lp|loop)                { return token::T_LOOP; }
(sc|setcolor)            { return token::T_COLOR; }
(sca|setcolora)          { return token::T_ACOLOR; }
(scb|setcolorb)          { return token::T_BCOLOR; }
(scv|setcolorv)          { return token::T_VCOLOR; }

(tsw|tglscalewind)       { return token::T_TOGGLESCALEWINDING; }
(tqw|tglquadweight)      { return token::T_TOGGLEQUADWEIGHTING; }
(tpbn|tglpstbuildnormal) { return token::T_TOGGLEPOSTBUILDNORMAL; }
(tvnc|tglvertnocleanup)  { return token::T_TOGGLEVERTNOCLEANUP; }

(vm|vertmerge)           { return token::T_VERTMERGE; }
(vs|vertseparate)        { return token::T_VERTSEPARATE; }

(tx|translatex)          { return token::T_TRANSLATEX; }
(ty|translatey)          { return token::T_TRANSLATEY; }
(tz|translatez)          { return token::T_TRANSLATEZ; }
(t|translate)            { return token::T_TRANSLATE; }
(rx|rotatex)             { return token::T_ROTATEX; }
(ry|rotatey)             { return token::T_ROTATEY; }
(rz|rotatez)             { return token::T_ROTATEZ; }
(r|rotate)               { return token::T_ROTATE; }
(rj|radialjitter)        { return token::T_RADIALJITTER; }
(tax|taperx)             { return token::T_TAPERX; }
(tay|tapery)             { return token::T_TAPERY; }
(taz|taperz)             { return token::T_TAPERZ; }
(twx|twistx)             { return token::T_TWISTX; }
(twy|twisty)             { return token::T_TWISTY; }
(twz|twistz)             { return token::T_TWISTZ; }
(shx|shearx)             { return token::T_SHEARX; }
(shy|sheary)             { return token::T_SHEARY; }
(shz|shearz)             { return token::T_SHEARZ; }
(stx|stretchx)           { return token::T_STRETCHX; }
(sty|stretchy)           { return token::T_STRETCHY; }
(stz|stretchz)           { return token::T_STRETCHZ; }
(bdxy|bendxy)            { return token::T_BENDXY; }
(bdxz|bendxz)            { return token::T_BENDXZ; }
(bdyx|bendyx)            { return token::T_BENDYX; }
(bdyz|bendyz)            { return token::T_BENDYZ; }
(bdzx|bendzx)            { return token::T_BENDZX; }
(bdzy|bendzy)            { return token::T_BENDZY; }
(sx|scalex)              { return token::T_SCALEX; }
(sy|scaley)              { return token::T_SCALEY; }
(sz|scalez)              { return token::T_SCALEZ; }
(s|scale)                { return token::T_SCALE; }
(mx|mirrorx)             { return token::T_MIRRORX; }
(my|mirrory)             { return token::T_MIRRORY; }
(mz|mirrorz)             { return token::T_MIRRORZ; }
(ch|chamfer)             { return token::T_CHAMFER; }
(splt|splittriangle)     { return token::T_SPLITTRIANGLE; }
(smth|smooth)            { return token::T_SMOOTHMESH; }
(dup|duplicate)          { return token::T_DUPLICATE; }

(ac|addcylinder)         { return token::T_CYLINDER; }
(asph|addsphere)         { return token::T_SPHERE; }
(acap|addcapsule)        { return token::T_CAPSULE; }
(ato|addtorus)           { return token::T_TORUS; }
(ab|addbox)              { return token::T_BOX; }
(ascb|addsmoothchamfbox) { return token::T_SMOOTHCHAMFBOX; }
(afcb|addflatchamfbox)   { return token::T_FLATCHAMFBOX; }
(as|addstar)             { return token::T_STAR; }
(aes|addexpandedstar)    { return token::T_EXPANDEDSTAR; }
(ad|adddisc)             { return token::T_DISC; }
(at|addtriangle)         { return token::T_TRIANGLE; }
(aq|addquad)             { return token::T_QUAD; }
(acg|addcog)             { return token::T_COG; }

%{ /* =======  BASE COLOR TYPES  ========================================= */ %}
%{ /* COLOR */ %}
#[0-9a-fA-F]{3} {
        uint32_t tmp = std::strtol(yytext + 1, nullptr, 16);
        yylval->u32val = 0x11000000u * (tmp >> 8)
                       | 0x00110000u * ((tmp >> 4) & 0xf)
                       | 0x00001100u * (tmp & 0xf)
                       | 0x000000ffu;
        return token::COLOR; }
#[0-9a-fA-F]{4} {
        uint32_t tmp = std::strtol(yytext + 1, nullptr, 16);
        yylval->u32val = 0x11000000u * (tmp >> 12)
                       | 0x00110000u * ((tmp >> 8) & 0xf)
                       | 0x00001100u * ((tmp >> 4) & 0xf)
                       | 0x00000011u * (tmp & 0xf);
        return token::COLOR; }
#[0-9a-fA-F]{6} {
        yylval->u32val = 0xffu
                       | 0x100u * (uint32_t)std::strtol(yytext + 1, nullptr, 16);
        return token::COLOR; }
#[0-9a-fA-F]{8} {
        yylval->u32val = (uint32_t)std::strtol(yytext + 1, nullptr, 16);
        return token::COLOR; }

%{ /* =======  BASE DATA TYPES  ========================================= */ %}
%{ /* BOOL */ %}
true { yylval->bval = true; return token::BOOLEAN; }
false { yylval->bval = false; return token::BOOLEAN; }
%{ /* FLOAT */ %}
[-+]?[0-9]*\.[0-9]+([eE][-+]?[0-9]+)? {
        yylval->fval = (float)std::atof(yytext); return token::F_NUMBER; }
%{ /* INT */ %}
[-+]?[0-9]+ {
        yylval->ival = std::atoi(yytext); return token::I_NUMBER; }

%{ /* ======= COMMENTS ======= */ %}
"//".* { /* ignore this */ }

%{ /* Semantics tokens */ %}
"-"   { return token_type('-'); }
"("   { return token_type('('); }
")"   { return token_type(')'); }
"{"   { return token_type('{'); }
"}"   { return token_type('}'); }
[\[]  { return token_type('['); }
[\]]  { return token_type(']'); }
[ ,]  { /* ignore this */ }
[\n]  { /* ignore this */ }
.     { return token::T_ERROR; }

%%

lol::EasyMeshScanner::EasyMeshScanner(char const *command)
    : EasyMeshFlexLexer(0, 0),
      m_input(command)
{
}

lol::EasyMeshScanner::~EasyMeshScanner()
{
}

int lol::EasyMeshScanner::LexerInput(char* buf, int max_size)
{
    (void)max_size; /* unused for now */

    buf[0] = m_input[0];
    if (buf[0])
        ++m_input;
    return buf[0] ? 1 : 0;
}

#ifdef yylex
#undef yylex
#endif
int EasyMeshFlexLexer::yylex()
{
    std::cerr << "in EasyMeshFlexLexer::yylex() !" << std::endl;
    return 0;
}

int EasyMeshFlexLexer::yywrap()
{
    return 1;
}