/**
* \brief Numeral token -> double precision floating point
*
* \param f1oat Resulting number
* \param token Token (CTX Fryer C real-time library \c token_t instance)
*
* \retval ATTR_EVAL_OK if the operation succeeds
* \retval ATTR_EVAL_ERROR in case of failure (failed to allocate result space)
*/
attr_eval_status_t token2num(void **f1oat, void *token) {
assert(NULL != f1oat);
assert(NULL != token);
/* Create token C-string (copy) */
char *c_str = token_string((token_t *)token);
if (NULL == c_str) return ATTR_EVAL_ERROR;
/* Allocate numeric representation memory */
*f1oat = malloc(sizeof(double));
if (NULL == *f1oat) {
free(c_str); /* release token C-string */
return ATTR_EVAL_ERROR;
}
/* Convert string to float */
*((double *)*f1oat) = atof(c_str);
/* Release token C-string */
free(c_str);
/*
INFO("Created value %g", *(double *)*f1oat);
*/
return ATTR_EVAL_OK;
}
static int get_next_token (void)
{
int c, token;
c = io_current();
/* The EOF token. */
if (c == EOF) return T_EOF;
/* The seperator token. */
if (c == ';' || c == ',')
{
io_next();
return T_SEPERATOR;
}
/* The EOL token. */
if (c == '\r' || c == '\n')
return token_eol(c);
/* A relational token. */
token = token_relation();
if (token)
return token;
/* An arithmetic token. */
token = token_operation();
if (token)
return token;
/* A keyword token. */
token = token_keyword();
if (token)
return token;
/* The string token. */
if (c == '"')
return token_string();
/* The number token. */
if (isdigit(c))
return token_number();
/* The letter (variable) token. */
if (isalnum(c) && islower(c))
{
text.letter = c;
io_next();
return T_LETTER;
}
io_next();
/* Scanned unrecognized data. */
return T_ERROR;
}
// Replace the current ID token with an abstract keyword, if it is one
static ast_token_id keyword_replace(build_parser_t* builder)
{
assert(builder != NULL);
token_id keyword_id = lexer_is_abstract_keyword(token_string(builder->token));
if(keyword_id == TK_LEX_ERROR)
return AT_ID;
token_set_id(builder->token, keyword_id);
return AT_TOKEN;
}
/* Process a dataref attribute.
* The dataref keyword should be found before calling this, but nothing else.
*/
static bool dataref_attribute(build_parser_t* builder, ast_t* node)
{
assert(builder != NULL);
if(get_token(builder) != AT_ID)
{
build_error(builder, "Expected {dataref name}");
return false;
}
const char* ref_name = stringtab(token_string(builder->token));
add_subtree_ref(builder, node, ref_name, NULL);
return true;
}
TOKEN _slc_get_next_token(TOKENIZER_STATE* state)
{
const char* old_start;
/* Eat whitespace */
do
{
old_start = state->str.start;
state->str = ltrim(state->str);
eat_newline(&state->str, &state->line);
} while(old_start != state->str.start);
TOKEN ret;
ret.own = false;
ret.line = state->line;
if(state->str.start == state->str.end)
{
ret.type = TOKEN_EOF;
ret.str = slc_from_c_str("<EOF>");
goto exit;
}
if(token_double_colon(&state->str, &ret))
goto exit;
if(token_character(&state->str, &ret, '$', TOKEN_DOLLAR))
goto exit;
if(token_character(&state->str, &ret, ';', TOKEN_SEMICOLON))
goto exit;
if(token_character(&state->str, &ret, '{', TOKEN_LEFT_BRACE))
goto exit;
if(token_character(&state->str, &ret, '}', TOKEN_RIGHT_BRACE))
goto exit;
if(token_character(&state->str, &ret, ':', TOKEN_COLON))
goto exit;
if(token_character(&state->str, &ret, '=', TOKEN_ASSIGN))
goto exit;
if(token_character(&state->str, &ret, '~', TOKEN_TILDE))
goto exit;
if(token_character(&state->str, &ret, '#', TOKEN_HASH))
goto exit;
if(token_line_comment(&state->str, &ret))
goto exit;
if(token_block_comment(&state->str, &ret, state))
goto exit;
if(token_string(&state->str, &ret, state))
goto exit;
exit:
state->cur_token = ret;
return ret;
}
/* Process a scope attribute.
* The scope keyword should be found before calling this, but nothing else.
*/
static bool scope_attribute(build_parser_t* builder, ast_t* node)
{
assert(builder != NULL);
ast_scope(node);
while(peek_token(builder) == AT_ID)
{
get_token(builder);
const char* name = stringtab(token_string(builder->token));
add_subtree_ref(builder, node, name, name);
}
return true;
}
/* Load node attributes, if any.
* Attributes are a list of keywords, each prefixed with a colon, following a
* node name. For example:
* seq:scope
*
* The node name must have been parsed before calling this, but not the colon.
*/
static ast_t* get_attributes(build_parser_t* builder, ast_t* node)
{
assert(builder != NULL);
while(peek_token(builder) == AT_LBRACE)
{
get_token(builder);
if(get_token(builder) != AT_ID)
{
build_error(builder, "Expected attribute in {}");
return NULL;
}
const char* attr = token_string(builder->token);
if(strcmp("scope", attr)==0)
{
if(!scope_attribute(builder, node))
return NULL;
}
else if(strcmp("def", attr) == 0)
{
if(!def_attribute(builder, node))
return NULL;
}
else if(strcmp("dataref", attr) == 0)
{
if(!dataref_attribute(builder, node))
return NULL;
}
else
{
build_error(builder, "Unrecognised attribute \"%s\"", attr);
return NULL;
}
if(get_token(builder) != AT_RBRACE)
{
build_error(builder, "Expected } after attribute %s", attr);
return NULL;
}
}
return node;
}
int scan(char *filename) {
yyin = fopen(filename,"r");
if (!yyin) {
fprintf(stderr,"scan error: unable to open %s\n",filename);
exit(1);
}
while(yyin) {
int t = yylex();
if (!t)
break;
printf("%s", token_string(t));
if ( t == TOKEN_STRING_LITERAL || t == TOKEN_CHAR_LITERAL) {
char string[600];
strcpy(string,yytext);
convertString(string);
printf(" %s", string);
}
printf("\n");
}
fclose(yyin);
return 0;
}
int do_parse_json(char * buffer,int* clock)
{
int i;
int type_flag = -1;
int clock_flag = -1;
int parser_return_code;
jsmntok_t token[10];
jsmn_parser p;
for(i=0; i<10; i++) token[i].type=-1;
jsmn_init(&p);
parser_return_code = jsmn_parse(&p, buffer, token, 10);
if(parser_return_code != JSMN_SUCCESS) return ERROR;
//SZUKAJ TYPU I ZEGARA
for(i=0; i<10; i++)
{
if(token[i].type == -1) break;
if( token_string(buffer, token[i], "type") || token_string(buffer, token[i], "Type") || token_string(buffer, token[i], "TYPE") ) type_flag = i+1;
if( token_string(buffer, token[i], "clock") || token_string(buffer, token[i], "Clock") || token_string(buffer, token[i], "CLOCK") ) clock_flag = i+1;
}
fprintf(stderr,"### type_flag: %d, clock_flag: %d\n", type_flag, clock_flag);
//NIE ZNALEZIONO! BLAD
if(type_flag == -1 || clock_flag == -1 ) return ERROR;
//ZLE TYPY! BLAD
if(token[type_flag].type != JSMN_STRING && token[clock_flag].type != JSMN_PRIMITIVE) return ERROR;
int rec_clock = strtol( buffer+token[clock_flag].start, NULL, 0 );
update_clock(rec_clock);
(*clock) = rec_clock;
if( token_string(buffer, token[type_flag], "order") ) return ORDER;
else if( token_string(buffer, token[type_flag], "ok") ) return OK;
else return ERROR;
}
const char* ast_name(ast_t* ast)
{
assert(ast != NULL);
return token_string(ast->t);
}
// Load a sequence of nodes until the specified terminator is found
static ast_t* get_nodes(build_parser_t* builder, ast_token_id terminator)
{
assert(builder != NULL);
ast_t* ast = NULL;
ast_t* last_child = NULL;
while(true)
{
ast_token_id id = get_token(builder);
ast_t* child = NULL;
bool is_type = false;
if(id == terminator)
{
if(ast == NULL)
build_error(builder, "Syntax error");
if(ast_id(ast) == TK_MINUS && ast_childcount(ast) == 1)
ast_setid(ast, TK_UNARY_MINUS);
return ast;
}
if(id == AT_ID)
id = keyword_replace(builder);
switch(id)
{
case AT_LPAREN:
child = get_nodes(builder, AT_RPAREN);
break;
case AT_LSQUARE:
child = get_type(builder, ast);
is_type = true;
break;
case AT_ERROR: // Propogate
break;
case AT_STRING:
case AT_TOKEN:
child = ast_token(builder->token);
save_token(builder);
get_attributes(builder, child);
break;
case AT_ID:
if(strcmp("id", token_string(builder->token)) == 0)
return get_id(builder, ast);
build_error(builder, "Unrecognised identifier \"%s\"",
token_string(builder->token));
break;
default:
build_error(builder, "Syntax error");
break;
}
if(child == NULL)
{
// An error occurred and should already have been reported
ast_free(ast);
return NULL;
}
if(ast == NULL)
{
ast = child;
last_child = NULL;
}
else if(is_type)
{
ast_settype(ast, child);
}
else
{
if(last_child == NULL)
ast_add(ast, child);
else
ast_add_sibling(last_child, child);
last_child = child;
}
}
}
void ICACHE_FLASH_ATTR server_recv_cb(void *arg, char *http_raw, unsigned short length) {
struct espconn *pespconn = (struct espconn *)arg;
//print("[server_recv_cb] Received data:");
char method[10];
char path[60];
char headers[60];
char body[256];
parse_http(http_raw, length, method, path, headers, body);
int GET = (os_strcmp(method, "GET") == 0);
int POST = (os_strcmp(method, "POST") == 0);
if (GET) { // No body if not [post/put/patch]ing
// Static files
if (os_strcmp(path, "/base.css") == 0) { send_ok(pespconn, base_css); }
else if (os_strcmp(path, "/connect.js") == 0) { send_ok(pespconn, connect_js); }
else if (os_strcmp(path, "/register.js") == 0) { send_ok(pespconn, register_js); }
// JSON responses
else if (os_strcmp(path, "/connection.json") == 0) {
int station_connect_status = wifi_station_get_connect_status();
if (station_connect_status == STATION_GOT_IP) {
struct ip_info ipConfig;
wifi_get_ip_info(STATION_IF, &ipConfig);
char json_str[54];
os_sprintf(json_str, "{\"status\": \"connected\", \"ip\": \"%d.%d.%d.%d\"}", IP2STR(&ipConfig.ip));
send_json(pespconn, json_str);
}
else {
char *status_str;
if (connection_status == CONNECTION_UNCONFIGURED) status_str = "unconfigured";
else
switch (station_connect_status) {
case STATION_CONNECTING: status_str = "connecting"; break;
case STATION_WRONG_PASSWORD: status_str = "failed"; break;
case STATION_NO_AP_FOUND: status_str = "failed"; break;
case STATION_CONNECT_FAIL: status_str = "failed"; break;
}
char json_str[54];
os_sprintf(json_str, "{\"status\": \"%s\"}", status_str);
send_json(pespconn, json_str);
}
}
else if (os_strcmp(path, "/registration.json") == 0) {
char *status_str;
switch (registration_status) {
case REGISTER_UNREGISTERED: status_str = "unregistered"; break;
case REGISTER_REGISTERING: status_str = "registering"; break;
case REGISTER_REGISTERED: status_str = "registered"; break;
case REGISTER_FAILED: status_str = "failed"; break;
}
char json_str[54];
os_sprintf(json_str, "{\"status\": \"%s\"}", status_str);
send_json(pespconn, json_str);
}
// HTML pages
else if (os_strcmp(path, "/read") == 0) {
if (registration_status == REGISTER_REGISTERED) {
char temp_json_str[128];
char hum_json_str[128];
measurement_json(temp_json_str, "temperature", "F", last_temp);
measurement_json(hum_json_str, "humidity", "%", last_hum);
char full_json_str[256] = "";
strcat(full_json_str, temp_json_str);
strcat(full_json_str, hum_json_str);
full_json_str[os_strlen(temp_json_str)+os_strlen(hum_json_str)] = 0;
send_ok_templated(pespconn, full_json_str);
} else {
send_ok_templated(pespconn, last_unknown);
}
}
else if (os_strcmp(path, "/register") == 0) {
send_ok_templated(pespconn, register_html);
}
else if (os_strcmp(path, "/scan.json") == 0) {
char json_str[256] = "[";
int si = 0;
for (; si < n_scanned; si++) {
char json_obj[100];
os_sprintf(json_obj, "{\"ssid\": \"%s\", \"rssi\": %d}", scanned_stations[si], scanned_dbs[si]);
os_strcat(json_str, json_obj);
if (si < n_scanned - 1) {
os_strcat(json_str, ",");
} else {
os_strcat(json_str, "]");
}
}
send_json(pespconn, json_str);
}
else if (os_strcmp(path, "/") == 0) {
send_ok_templated(pespconn, index_html);
}
else {
send_404(pespconn);
}
return;
}
else if (POST) {
// Parse JSON with jsmn
jsmn_parser parser;
jsmn_init(&parser);
jsmntok_t tokens[32];
jsmnerr_t r;
r = jsmn_parse(&parser, body, 1024, tokens, 256);
if (r < 0) {
//print("JSON Parse error?");
return;
}
// Look for ssid and pass
char station_ssid[20];
char station_pass[20];
//print("JSON Parse success?");
if (os_strcmp(path, "/connect.json") == 0) {
// Parse ssid and pass from JSON
int ti = 0;
int has_ssid = 0;
int has_pass = 0;
int on_ssid = 0;
int on_pass = 0;
for(; tokens[ti].end; ti++) {
char tv[256];
token_string(tv, body, tokens[ti]);
if (on_ssid) {
//print("Found ssid");
on_ssid = 0;
os_strcpy(station_ssid, tv);
has_ssid = 1;
}
if (on_pass) {
//print("Found pass");
on_pass = 0;
os_strcpy(station_pass, tv);
has_pass = 1;
if (has_ssid) { break; }
}
on_ssid = ti % 2 == 1 && os_strcmp(tv, "ssid") == 0;
on_pass = ti % 2 == 1 && os_strcmp(tv, "pass") == 0;
}
//ets_uart_printf("Hopefully ssid=%s and pass=%s\r\n", station_ssid, station_pass);
send_ok(pespconn, "<h1>maia</h1><p>OK</p>");
setup_station(station_ssid, station_pass);
}
else if (os_strcmp(path, "/register.json") == 0) {
// Parse email and password from JSON
int ti = 0;
char user_email[64];
char user_password[64];
int has_email = 0;
int has_password = 0;
int on_email = 0;
int on_password = 0;
for(; tokens[ti].end; ti++) {
char tv[256];
token_string(tv, body, tokens[ti]);
if (on_email) {
//print("Found email");
on_email = 0;
os_strcpy(user_email, tv);
has_email = 1;
}
if (on_password) {
//print("Found password");
on_password = 0;
os_strcpy(user_password, tv);
has_password = 1;
if (has_email) { break; }
}
on_email = ti % 2 == 1 && os_strcmp(tv, "email") == 0;
on_password = ti % 2 == 1 && os_strcmp(tv, "password") == 0;
}
char register_response[256];
os_sprintf(register_response, "Registering as %d...", DEVICE_ID);
send_ok_templated(pespconn, register_response);
char register_json[256];
os_sprintf(register_json, "{"
"\"device_id\": \"0x%x\","
"\"kind\": \"%s\","
"\"email\": \"%s\","
"\"password\": \"%s\""
"}", DEVICE_ID, DEVICE_KIND, user_email, user_password);
registration_status = REGISTER_REGISTERING;
post_json(API_BASE "/devices.json", register_json);
}
else {
send_404(pespconn);
}
return;
}
send_404(pespconn);
return;
}
