/** * \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; }