mirror of
https://github.com/OpenEmu/OpenEmuKit.git
synced 2025-11-01 11:08:14 +00:00
Stuart Carnie
294 lines
7.0 KiB
Objective-C
294 lines
7.0 KiB
Objective-C
|
|
/* #line 1 "KeyValueScanner.rl" */
|
|
// Copyright (c) 2022, OpenEmu Team
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
// * Neither the name of the OpenEmu Team nor the
|
|
// names of its contributors may be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY OpenEmu Team ''AS IS'' AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL OpenEmu Team BE LIABLE FOR ANY
|
|
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
// ****
|
|
// Generated with
|
|
//
|
|
// ragel -L -C KeyValueScanner.rl -o KeyValueScanner.gen.m
|
|
//
|
|
// ****
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include "KeyValueScanner+Private.h"
|
|
|
|
|
|
/* #line 41 "KeyValueScanner.gen.m" */
|
|
static const char _KVScanner_actions[] = {
|
|
0, 1, 0, 2, 1, 2, 2, 1,
|
|
3, 2, 1, 4, 2, 1, 5, 3,
|
|
0, 1, 2
|
|
};
|
|
|
|
static const char _KVScanner_key_offsets[] = {
|
|
0, 0, 6, 14, 15, 17, 19, 19,
|
|
27, 31, 33, 34, 38
|
|
};
|
|
|
|
static const char _KVScanner_trans_keys[] = {
|
|
36, 95, 65, 90, 97, 122, 61, 95,
|
|
48, 57, 65, 90, 97, 122, 34, 34,
|
|
92, 34, 92, 61, 95, 48, 57, 65,
|
|
90, 97, 122, 43, 45, 48, 57, 48,
|
|
57, 59, 46, 59, 48, 57, 59, 48,
|
|
57, 0
|
|
};
|
|
|
|
static const char _KVScanner_single_lengths[] = {
|
|
0, 2, 2, 1, 2, 2, 0, 2,
|
|
2, 0, 1, 2, 1
|
|
};
|
|
|
|
static const char _KVScanner_range_lengths[] = {
|
|
0, 2, 3, 0, 0, 0, 0, 3,
|
|
1, 1, 0, 1, 1
|
|
};
|
|
|
|
static const char _KVScanner_index_offsets[] = {
|
|
0, 0, 5, 11, 13, 16, 19, 20,
|
|
26, 30, 32, 34, 38
|
|
};
|
|
|
|
static const char _KVScanner_indicies[] = {
|
|
0, 2, 2, 2, 1, 4, 3, 3,
|
|
3, 3, 1, 5, 1, 7, 8, 6,
|
|
10, 11, 9, 9, 13, 12, 12, 12,
|
|
12, 1, 14, 14, 15, 1, 16, 1,
|
|
17, 1, 18, 19, 16, 1, 19, 18,
|
|
1, 0
|
|
};
|
|
|
|
static const char _KVScanner_trans_targs[] = {
|
|
2, 0, 7, 2, 3, 4, 5, 10,
|
|
6, 5, 10, 6, 7, 8, 9, 11,
|
|
11, 1, 12, 1
|
|
};
|
|
|
|
static const char _KVScanner_trans_actions[] = {
|
|
1, 0, 1, 0, 9, 0, 1, 15,
|
|
1, 0, 3, 0, 0, 6, 1, 1,
|
|
0, 0, 0, 12
|
|
};
|
|
|
|
static const char _KVScanner_eof_actions[] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 12, 12
|
|
};
|
|
|
|
static const int KVScanner_start = 1;
|
|
static const int KVScanner_first_final = 10;
|
|
static const int KVScanner_error = 0;
|
|
|
|
static const int KVScanner_en_main = 1;
|
|
|
|
|
|
/* #line 40 "KeyValueScanner.rl" */
|
|
|
|
|
|
void kv_scanner_init( PKVScanner ps, uint8_t const * src, size_t src_len )
|
|
{
|
|
KVScanner *s = (KVScanner *)ps;
|
|
memset (s, 0, sizeof(KVScanner));
|
|
s->src = src;
|
|
s->src_len = src_len;
|
|
s->p = src;
|
|
s->pe = src + src_len;
|
|
s->eof = s->pe;
|
|
|
|
/* #line 123 "KeyValueScanner.gen.m" */
|
|
{
|
|
s->cs = KVScanner_start;
|
|
}
|
|
|
|
/* #line 52 "KeyValueScanner.rl" */
|
|
}
|
|
|
|
#define ret_tok( _tok ) token = _tok;
|
|
|
|
KVToken kv_scanner_scan( PKVScanner ps )
|
|
{
|
|
KVScanner *s = (KVScanner *)ps;
|
|
KVToken token = KVTokenNone;
|
|
|
|
while ( !s->done ) {
|
|
// Check for EOF
|
|
if ( s->p >= s->pe ) {
|
|
s->len = 0;
|
|
token = KVTokenEOF;
|
|
s->done = true;
|
|
break;
|
|
}
|
|
|
|
|
|
/* #line 148 "KeyValueScanner.gen.m" */
|
|
{
|
|
int _klen;
|
|
unsigned int _trans;
|
|
const char *_acts;
|
|
unsigned int _nacts;
|
|
const char *_keys;
|
|
|
|
if ( ( s->p) == ( s->pe) )
|
|
goto _test_eof;
|
|
if ( s->cs == 0 )
|
|
goto _out;
|
|
_resume:
|
|
_keys = _KVScanner_trans_keys + _KVScanner_key_offsets[ s->cs];
|
|
_trans = _KVScanner_index_offsets[ s->cs];
|
|
|
|
_klen = _KVScanner_single_lengths[ s->cs];
|
|
if ( _klen > 0 ) {
|
|
const char *_lower = _keys;
|
|
const char *_mid;
|
|
const char *_upper = _keys + _klen - 1;
|
|
while (1) {
|
|
if ( _upper < _lower )
|
|
break;
|
|
|
|
_mid = _lower + ((_upper-_lower) >> 1);
|
|
if ( (*( s->p)) < *_mid )
|
|
_upper = _mid - 1;
|
|
else if ( (*( s->p)) > *_mid )
|
|
_lower = _mid + 1;
|
|
else {
|
|
_trans += (unsigned int)(_mid - _keys);
|
|
goto _match;
|
|
}
|
|
}
|
|
_keys += _klen;
|
|
_trans += _klen;
|
|
}
|
|
|
|
_klen = _KVScanner_range_lengths[ s->cs];
|
|
if ( _klen > 0 ) {
|
|
const char *_lower = _keys;
|
|
const char *_mid;
|
|
const char *_upper = _keys + (_klen<<1) - 2;
|
|
while (1) {
|
|
if ( _upper < _lower )
|
|
break;
|
|
|
|
_mid = _lower + (((_upper-_lower) >> 1) & ~1);
|
|
if ( (*( s->p)) < _mid[0] )
|
|
_upper = _mid - 2;
|
|
else if ( (*( s->p)) > _mid[1] )
|
|
_lower = _mid + 2;
|
|
else {
|
|
_trans += (unsigned int)((_mid - _keys)>>1);
|
|
goto _match;
|
|
}
|
|
}
|
|
_trans += _klen;
|
|
}
|
|
|
|
_match:
|
|
_trans = _KVScanner_indicies[_trans];
|
|
s->cs = _KVScanner_trans_targs[_trans];
|
|
|
|
if ( _KVScanner_trans_actions[_trans] == 0 )
|
|
goto _again;
|
|
|
|
_acts = _KVScanner_actions + _KVScanner_trans_actions[_trans];
|
|
_nacts = (unsigned int) *_acts++;
|
|
while ( _nacts-- > 0 )
|
|
{
|
|
switch ( *_acts++ )
|
|
{
|
|
case 0:
|
|
/* #line 77 "KeyValueScanner.rl" */
|
|
{ /* action: token_start */ s->ts = s->p; }
|
|
break;
|
|
case 1:
|
|
/* #line 78 "KeyValueScanner.rl" */
|
|
{ /* action: token_end */ s->te = s->p; }
|
|
break;
|
|
case 2:
|
|
/* #line 81 "KeyValueScanner.rl" */
|
|
{ ret_tok( KVTokenString ); {( s->p)++; goto _out; } }
|
|
break;
|
|
case 3:
|
|
/* #line 85 "KeyValueScanner.rl" */
|
|
{ ret_tok( KVTokenIdentifier ); {( s->p)++; goto _out; } }
|
|
break;
|
|
case 4:
|
|
/* #line 89 "KeyValueScanner.rl" */
|
|
{ ret_tok( KVTokenSystemIdentifier ); {( s->p)++; goto _out; } }
|
|
break;
|
|
case 5:
|
|
/* #line 93 "KeyValueScanner.rl" */
|
|
{ ret_tok( KVTokenFloat ); {( s->p)++; goto _out; } }
|
|
break;
|
|
/* #line 246 "KeyValueScanner.gen.m" */
|
|
}
|
|
}
|
|
|
|
_again:
|
|
if ( s->cs == 0 )
|
|
goto _out;
|
|
if ( ++( s->p) != ( s->pe) )
|
|
goto _resume;
|
|
_test_eof: {}
|
|
if ( ( s->p) == ( s->eof) )
|
|
{
|
|
const char *__acts = _KVScanner_actions + _KVScanner_eof_actions[ s->cs];
|
|
unsigned int __nacts = (unsigned int) *__acts++;
|
|
while ( __nacts-- > 0 ) {
|
|
switch ( *__acts++ ) {
|
|
case 1:
|
|
/* #line 78 "KeyValueScanner.rl" */
|
|
{ /* action: token_end */ s->te = s->p; }
|
|
break;
|
|
case 5:
|
|
/* #line 93 "KeyValueScanner.rl" */
|
|
{ ret_tok( KVTokenFloat ); {( s->p)++; goto _out; } }
|
|
break;
|
|
/* #line 270 "KeyValueScanner.gen.m" */
|
|
}
|
|
}
|
|
}
|
|
|
|
_out: {}
|
|
}
|
|
|
|
/* #line 109 "KeyValueScanner.rl" */
|
|
|
|
|
|
if ( s->cs == KVScanner_error )
|
|
{
|
|
return KVTokenError;
|
|
}
|
|
|
|
if ( token != KVTokenNone )
|
|
{
|
|
s->len = s->te - s->ts;
|
|
return token;
|
|
}
|
|
}
|
|
|
|
return KVTokenEOF;
|
|
}
|