static inline enum CONNECTED_GLYPH_TYPE _get_connected_glyph_type(int unicode) { if (_is_number(unicode)) { return CGT_NUMBER; } else if (_is_letter(unicode)) { return CGT_LETTER; } else { return CGT_NULL; } }
static void _set_test_mode(int argc, char **argv, uint8_t mode) { (void) argc; if (_is_number(argv[1])) { kernel_pid_t dev = atoi(argv[1]); if (gnrc_netif_get_by_pid(dev)) { gnrc_netapi_set(dev, NETOPT_RF_TESTMODE, 0, (void *)&mode, sizeof(mode)); return; } } printf("usage: %s <if_id>\n", argv[0]); return; }
static int _netif_set_u16(kernel_pid_t iface, netopt_t opt, uint16_t context, char *u16_str) { unsigned long int res; bool hex = false; if (_is_number(u16_str)) { if ((res = strtoul(u16_str, NULL, 10)) == ULONG_MAX) { puts("error: unable to parse value.\n" "Must be a 16-bit unsigned integer (dec or hex)\n"); return 1; } } else { if ((res = strtoul(u16_str, NULL, 16)) == ULONG_MAX) { puts("error: unable to parse value.\n" "Must be a 16-bit unsigned integer (dec or hex)\n"); return 1; } hex = true; } if (res > 0xffff) { puts("error: unable to parse value.\n" "Must be a 16-bit unsigned integer (dec or hex)\n"); return 1; } if (gnrc_netapi_set(iface, opt, context, (uint16_t *)&res, sizeof(uint16_t)) < 0) { printf("error: unable to set "); _print_netopt(opt); puts(""); return 1; } printf("success: set "); _print_netopt(opt); printf(" on interface %" PRIkernel_pid " to ", iface); if (hex) { printf("0x%04lx\n", res); } else { printf("%lu\n", res); } return 0; }
void SDHandler::_getFileNumber() { std::string path = "/sd/"; _filenames = _read_directory(path); for(vector<std::string>::iterator it = _filenames.begin(); it < _filenames.end(); it++) { std::string extensionTest = (*it).substr((*it).find_last_of(".") + 1); if(strcmp(extensionTest.c_str(), "log") == 0) { std::string numberTest = (*it).substr(0, (*it).find_last_of(".")); if(_is_number(numberTest)) { int value = atoi(numberTest.c_str()); if(value > _fileNumber) { _fileNumber = value; } } } } ++_fileNumber; }
int _netif_config(int argc, char **argv) { if (argc < 2) { kernel_pid_t ifs[GNRC_NETIF_NUMOF]; size_t numof = gnrc_netif_get(ifs); for (size_t i = 0; i < numof && i < GNRC_NETIF_NUMOF; i++) { _netif_list(ifs[i]); } return 0; } else if (_is_number(argv[1])) { kernel_pid_t dev = (kernel_pid_t)atoi(argv[1]); if (_is_iface(dev)) { if (argc < 3) { _netif_list(dev); return 0; } else if (strcmp(argv[2], "set") == 0) { if (argc < 5) { _set_usage(argv[0]); return 1; } return _netif_set(argv[0], dev, argv[3], argv[4]); } else if (strcmp(argv[2], "add") == 0) { if (argc < 4) { _add_usage(argv[0]); return 1; } return _netif_add(argv[0], (kernel_pid_t)dev, argc - 3, argv + 3); } else if (strcmp(argv[2], "del") == 0) { if (argc < 4) { _del_usage(argv[0]); return 1; } return _netif_del((kernel_pid_t)dev, argv[3]); } else { return _netif_flag(argv[0], dev, argv[2]); } } else { puts("error: invalid interface given"); return 1; } } printf("usage: %s [<if_id>]\n", argv[0]); _set_usage(argv[0]); _flag_usage(argv[0]); _add_usage(argv[0]); _del_usage(argv[0]); return 1; }
void GDTokenizerText::_advance() { if (error_flag) { //parser broke _make_error(last_error); return; } if (code_pos>=len) { _make_token(TK_EOF); return; } #define GETCHAR(m_ofs) ((m_ofs+code_pos)>=len?0:_code[m_ofs+code_pos]) #define INCPOS(m_amount) { code_pos+=m_amount; column+=m_amount; } while (true) { bool is_node_path = false; StringMode string_mode=STRING_DOUBLE_QUOTE; switch(GETCHAR(0)) { case 0: _make_token(TK_EOF); break; case '\\': INCPOS(1); if (GETCHAR(0)=='\r') { INCPOS(1); } if (GETCHAR(0)!='\n') { _make_error("Expected newline after '\\'."); return; } INCPOS(1); while(GETCHAR(0)==' ' || GETCHAR(0)=='\t') { INCPOS(1); } continue; case '\t': case '\r': case ' ': INCPOS(1); continue; case '\n': { line++; INCPOS(1); column=0; int i=0; while(GETCHAR(i)==' ' || GETCHAR(i)=='\t') { i++; } _make_newline(i); return; } #if 1 //py style tokenizer case '#': { // line comment skip while(GETCHAR(0)!='\n') { code_pos++; if (GETCHAR(0)==0) { //end of file //_make_error("Unterminated Comment"); _make_token(TK_EOF); return; } } INCPOS(1); column=0; line++; int i=0; while(GETCHAR(i)==' ' || GETCHAR(i)=='\t') { i++; } _make_newline(i); return; } break; #endif case '/': { switch(GETCHAR(1)) { #if 0 // c style tokenizer case '*': { // block comment int pos = code_pos+2; int new_line=line; int new_col=column+2; while(true) { if (_code[pos]=='0') { _make_error("Unterminated Comment"); code_pos=pos; return; } if (_code[pos]=='*' && _code[pos+1]=='/') { new_col+=2; pos+=2; //compensate break; } else if (_code[pos]=='\n') { new_line++; new_col=0; } else { new_col++; } pos++; } column=new_col; line=new_line; code_pos=pos; continue; } break; case '/': { // line comment skip while(GETCHAR(0)!='\n') { code_pos++; if (GETCHAR(0)==0) { //end of file _make_error("Unterminated Comment"); return; } } INCPOS(1); column=0; line++; continue; } break; #endif case '=': { // diveq _make_token(TK_OP_ASSIGN_DIV); INCPOS(1); } break; default: _make_token(TK_OP_DIV); } } break; case '=': { if (GETCHAR(1)=='=') { _make_token(TK_OP_EQUAL); INCPOS(1); } else _make_token(TK_OP_ASSIGN); } break; case '<': { if (GETCHAR(1)=='=') { _make_token(TK_OP_LESS_EQUAL); INCPOS(1); } else if (GETCHAR(1)=='<') { if (GETCHAR(2)=='=') { _make_token(TK_OP_ASSIGN_SHIFT_LEFT); INCPOS(1); } else { _make_token(TK_OP_SHIFT_LEFT); } INCPOS(1); } else _make_token(TK_OP_LESS); } break; case '>': { if (GETCHAR(1)=='=') { _make_token(TK_OP_GREATER_EQUAL); INCPOS(1); } else if (GETCHAR(1)=='>') { if (GETCHAR(2)=='=') { _make_token(TK_OP_ASSIGN_SHIFT_RIGHT); INCPOS(1); } else { _make_token(TK_OP_SHIFT_RIGHT); } INCPOS(1); } else { _make_token(TK_OP_GREATER); } } break; case '!': { if (GETCHAR(1)=='=') { _make_token(TK_OP_NOT_EQUAL); INCPOS(1); } else { _make_token(TK_OP_NOT); } } break; //case '"' //string - no strings in shader //case '\'' //string - no strings in shader case '{': _make_token(TK_CURLY_BRACKET_OPEN); break; case '}': _make_token(TK_CURLY_BRACKET_CLOSE); break; case '[': _make_token(TK_BRACKET_OPEN); break; case ']': _make_token(TK_BRACKET_CLOSE); break; case '(': _make_token(TK_PARENTHESIS_OPEN); break; case ')': _make_token(TK_PARENTHESIS_CLOSE); break; case ',': _make_token(TK_COMMA); break; case ';': _make_token(TK_SEMICOLON); break; case '?': _make_token(TK_QUESTION_MARK); break; case ':': _make_token(TK_COLON); //for methods maybe but now useless. break; case '^': { if (GETCHAR(1)=='=') { _make_token(TK_OP_ASSIGN_BIT_XOR); INCPOS(1); } else { _make_token(TK_OP_BIT_XOR); } } break; case '~': _make_token(TK_OP_BIT_INVERT); break; case '&': { if (GETCHAR(1)=='&') { _make_token(TK_OP_AND); INCPOS(1); } else if (GETCHAR(1)=='=') { _make_token(TK_OP_ASSIGN_BIT_AND); INCPOS(1); } else { _make_token(TK_OP_BIT_AND); } } break; case '|': { if (GETCHAR(1)=='|') { _make_token(TK_OP_OR); INCPOS(1); } else if (GETCHAR(1)=='=') { _make_token(TK_OP_ASSIGN_BIT_OR); INCPOS(1); } else { _make_token(TK_OP_BIT_OR); } } break; case '*': { if (GETCHAR(1)=='=') { _make_token(TK_OP_ASSIGN_MUL); INCPOS(1); } else { _make_token(TK_OP_MUL); } } break; case '+': { if (GETCHAR(1)=='=') { _make_token(TK_OP_ASSIGN_ADD); INCPOS(1); //} else if (GETCHAR(1)=='+') { // _make_token(TK_OP_PLUS_PLUS); // INCPOS(1); } else { _make_token(TK_OP_ADD); } } break; case '-': { if (GETCHAR(1)=='=') { _make_token(TK_OP_ASSIGN_SUB); INCPOS(1); //} else if (GETCHAR(1)=='-') { // _make_token(TK_OP_MINUS_MINUS); // INCPOS(1); } else { _make_token(TK_OP_SUB); } } break; case '%': { if (GETCHAR(1)=='=') { _make_token(TK_OP_ASSIGN_MOD); INCPOS(1); } else { _make_token(TK_OP_MOD); } } break; case '@': if( CharType(GETCHAR(1))!='"' && CharType(GETCHAR(1))!='\'' ) { _make_error("Unexpected '@'"); return; } INCPOS(1); is_node_path=true; case '\'': case '"': { if (GETCHAR(0)=='\'') string_mode=STRING_SINGLE_QUOTE; int i=1; if (string_mode==STRING_DOUBLE_QUOTE && GETCHAR(i)=='"' && GETCHAR(i+1)=='"') { i+=2; string_mode=STRING_MULTILINE; } String str; while(true) { if (CharType(GETCHAR(i))==0) { _make_error("Unterminated String"); return; } else if( string_mode==STRING_DOUBLE_QUOTE && CharType(GETCHAR(i))=='"' ) { break; } else if( string_mode==STRING_SINGLE_QUOTE && CharType(GETCHAR(i))=='\'' ) { break; } else if( string_mode==STRING_MULTILINE && CharType(GETCHAR(i))=='\"' && CharType(GETCHAR(i+1))=='\"' && CharType(GETCHAR(i+2))=='\"') { i+=2; break; } else if( string_mode!=STRING_MULTILINE && CharType(GETCHAR(i))=='\n') { _make_error("Unexpected EOL at String."); return; } else if (CharType(GETCHAR(i))=='\\') { //escaped characters... i++; CharType next = GETCHAR(i); if (next==0) { _make_error("Unterminated String"); return; } CharType res=0; switch(next) { case 'a': res=7; break; case 'b': res=8; break; case 't': res=9; break; case 'n': res=10; break; case 'v': res=11; break; case 'f': res=12; break; case 'r': res=13; break; case '\'': res='\''; break; case '\"': res='\"'; break; case '\\': res='\\'; break; case '/': res='/'; break; //wtf case 'u': { //hexnumbarh - oct is deprecated i+=1; for(int j=0;j<4;j++) { CharType c = GETCHAR(i+j); if (c==0) { _make_error("Unterminated String"); return; } if (!((c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F'))) { _make_error("Malformed hex constant in string"); return; } CharType v; if (c>='0' && c<='9') { v=c-'0'; } else if (c>='a' && c<='f') { v=c-'a'; v+=10; } else if (c>='A' && c<='F') { v=c-'A'; v+=10; } else { ERR_PRINT("BUG"); v=0; } res<<=4; res|=v; } i+=3; } break; default: { _make_error("Invalid escape sequence"); return; } break; } str+=res; } else { str+=CharType(GETCHAR(i)); } i++; } INCPOS(i); if (is_node_path) { _make_constant(NodePath(str)); } else { _make_constant(str); } } break; case 0xFFFF: { _make_token(TK_CURSOR); } break; default: { if (_is_number(GETCHAR(0)) || (GETCHAR(0)=='.' && _is_number(GETCHAR(1)))) { // parse number bool period_found=false; bool exponent_found=false; bool hexa_found=false; bool sign_found=false; String str; int i=0; while(true) { if (GETCHAR(i)=='.') { if (period_found || exponent_found) { _make_error("Invalid numeric constant at '.'"); return; } period_found=true; } else if (GETCHAR(i)=='x') { if (hexa_found || str.length()!=1 || !( (i==1 && str[0]=='0') || (i==2 && str[1]=='0' && str[0]=='-') ) ) { _make_error("Invalid numeric constant at 'x'"); return; } hexa_found=true; } else if (!hexa_found && GETCHAR(i)=='e') { if (hexa_found || exponent_found) { _make_error("Invalid numeric constant at 'e'"); return; } exponent_found=true; } else if (_is_number(GETCHAR(i))) { //all ok } else if (hexa_found && _is_hex(GETCHAR(i))) { } else if ((GETCHAR(i)=='-' || GETCHAR(i)=='+') && exponent_found) { if (sign_found) { _make_error("Invalid numeric constant at '-'"); return; } sign_found=true; } else break; str+=CharType(GETCHAR(i)); i++; } if (!( _is_number(str[str.length()-1]) || (hexa_found && _is_hex(str[str.length()-1])))) { _make_error("Invalid numeric constant: "+str); return; } INCPOS(str.length()); if (hexa_found) { int val = str.hex_to_int(); _make_constant(val); } else if (period_found) { real_t val = str.to_double(); //print_line("*%*%*%*% to convert: "+str+" result: "+rtos(val)); _make_constant(val); } else { int val = str.to_int(); _make_constant(val); } return; } if (GETCHAR(0)=='.') { //parse period _make_token(TK_PERIOD); break; } if (_is_text_char(GETCHAR(0))) { // parse identifier String str; str+=CharType(GETCHAR(0)); int i=1; while(_is_text_char(GETCHAR(i))) { str+=CharType(GETCHAR(i)); i++; } bool identifier=false; if (str=="null") { _make_constant(Variant()); } else if (str=="true") { _make_constant(true); } else if (str=="false") { _make_constant(false); } else { bool found=false; struct _bit { Variant::Type type; const char *text;}; //built in types static const _bit type_list[]={ //types {Variant::BOOL,"bool"}, {Variant::INT,"int"}, {Variant::REAL,"float"}, {Variant::STRING,"String"}, {Variant::VECTOR2,"vec2"}, {Variant::VECTOR2,"Vector2"}, {Variant::RECT2,"Rect2"}, {Variant::MATRIX32,"Matrix32"}, {Variant::MATRIX32,"mat32"}, {Variant::VECTOR3,"vec3"}, {Variant::VECTOR3,"Vector3"}, {Variant::_AABB,"AABB"}, {Variant::_AABB,"Rect3"}, {Variant::PLANE,"Plane"}, {Variant::QUAT,"Quat"}, {Variant::MATRIX3,"mat3"}, {Variant::MATRIX3,"Matrix3"}, {Variant::TRANSFORM,"trn"}, {Variant::TRANSFORM,"Transform"}, {Variant::COLOR,"Color"}, {Variant::IMAGE,"Image"}, {Variant::_RID,"RID"}, {Variant::OBJECT,"Object"}, {Variant::INPUT_EVENT,"InputEvent"}, {Variant::NODE_PATH,"NodePath"}, {Variant::DICTIONARY,"dict"}, {Variant::DICTIONARY,"Dictionary"}, {Variant::ARRAY,"Array"}, {Variant::RAW_ARRAY,"RawArray"}, {Variant::INT_ARRAY,"IntArray"}, {Variant::REAL_ARRAY,"FloatArray"}, {Variant::STRING_ARRAY,"StringArray"}, {Variant::VECTOR2_ARRAY,"Vector2Array"}, {Variant::VECTOR3_ARRAY,"Vector3Array"}, {Variant::COLOR_ARRAY,"ColorArray"}, {Variant::VARIANT_MAX,NULL}, }; { int idx=0; while(type_list[idx].text) { if (str==type_list[idx].text) { _make_type(type_list[idx].type); found=true; break; } idx++; } } if (!found) { //built in func? for(int i=0;i<GDFunctions::FUNC_MAX;i++) { if (str==GDFunctions::get_func_name(GDFunctions::Function(i))) { _make_built_in_func(GDFunctions::Function(i)); found=true; break; } } //keywor } if (!found) { struct _kws { Token token; const char *text;}; static const _kws keyword_list[]={ //ops {TK_OP_IN,"in"}, {TK_OP_NOT,"not"}, {TK_OP_OR,"or"}, {TK_OP_AND,"and"}, //func {TK_PR_FUNCTION,"func"}, {TK_PR_FUNCTION,"function"}, {TK_PR_CLASS,"class"}, {TK_PR_EXTENDS,"extends"}, {TK_PR_TOOL,"tool"}, {TK_PR_STATIC,"static"}, {TK_PR_EXPORT,"export"}, {TK_PR_SETGET,"setget"}, {TK_PR_VAR,"var"}, {TK_PR_PRELOAD,"preload"}, {TK_PR_ASSERT,"assert"}, {TK_PR_YIELD,"yield"}, {TK_PR_CONST,"const"}, //controlflow {TK_CF_IF,"if"}, {TK_CF_ELIF,"elif"}, {TK_CF_ELSE,"else"}, {TK_CF_FOR,"for"}, {TK_CF_WHILE,"while"}, {TK_CF_DO,"do"}, {TK_CF_SWITCH,"switch"}, {TK_CF_BREAK,"break"}, {TK_CF_CONTINUE,"continue"}, {TK_CF_RETURN,"return"}, {TK_CF_PASS,"pass"}, {TK_SELF,"self"}, {TK_ERROR,NULL} }; int idx=0; found=false; while(keyword_list[idx].text) { if (str==keyword_list[idx].text) { _make_token(keyword_list[idx].token); found=true; break; } idx++; } } if (!found) identifier=true; } if (identifier) { _make_identifier(str); } INCPOS(str.length()); return; } _make_error("Unknown character"); return; } break; } INCPOS(1); break; } }
int _netif_config(int argc, char **argv) { if (argc < 2) { kernel_pid_t ifs[GNRC_NETIF_NUMOF]; size_t numof = gnrc_netif_get(ifs); for (size_t i = 0; i < numof && i < GNRC_NETIF_NUMOF; i++) { _netif_list(ifs[i]); } return 0; } else if (_is_number(argv[1])) { kernel_pid_t dev = (kernel_pid_t)atoi(argv[1]); if (_is_iface(dev)) { if (argc < 3) { _netif_list(dev); return 0; } else if (strcmp(argv[2], "set") == 0) { if (argc < 5) { _set_usage(argv[0]); return 1; } return _netif_set(argv[0], dev, argv[3], argv[4]); } else if (strcmp(argv[2], "add") == 0) { if (argc < 4) { _add_usage(argv[0]); return 1; } return _netif_add(argv[0], (kernel_pid_t)dev, argc - 3, argv + 3); } else if (strcmp(argv[2], "del") == 0) { if (argc < 4) { _del_usage(argv[0]); return 1; } return _netif_del((kernel_pid_t)dev, argv[3]); } else if (strcmp(argv[2], "mtu") == 0) { if (argc < 4) { _mtu_usage(argv[0]); return 1; } return _netif_mtu((kernel_pid_t)dev, argv[3]); } #ifdef MODULE_GNRC_IPV6_NETIF else if (strcmp(argv[2], "hl") == 0) { if (argc < 4) { _hl_usage(argv[0]); return 1; } int hl; gnrc_ipv6_netif_t *entry; if (((hl = atoi(argv[3])) < 0) || (hl > UINT8_MAX)) { printf("error: Hop limit must be between %" PRIu16 " and %" PRIu16 "\n", (uint16_t)0, (uint16_t)UINT16_MAX); return 1; } if ((entry = gnrc_ipv6_netif_get(dev)) == NULL) { puts("error: unable to set hop limit."); return 1; } entry->cur_hl = hl; printf("success: set hop limit %u interface %" PRIkernel_pid "\n", hl, dev); return 0; } #endif else { return _netif_flag(argv[0], dev, argv[2]); } } else { puts("error: invalid interface given"); return 1; } } printf("usage: %s [<if_id>]\n", argv[0]); _set_usage(argv[0]); _mtu_usage(argv[0]); _hl_usage(argv[0]); _flag_usage(argv[0]); _add_usage(argv[0]); _del_usage(argv[0]); return 1; }
int _netif_config(int argc, char **argv) { if (argc < 2) { kernel_pid_t ifs[GNRC_NETIF_NUMOF]; size_t numof = gnrc_netif_get(ifs); for (size_t i = 0; i < numof && i < GNRC_NETIF_NUMOF; i++) { _netif_list(ifs[i]); } return 0; } else if (_is_number(argv[1])) { kernel_pid_t dev = atoi(argv[1]); if (_is_iface(dev)) { if (argc < 3) { _netif_list(dev); return 0; } else if (strcmp(argv[2], "set") == 0) { if (argc < 5) { _set_usage(argv[0]); return 1; } return _netif_set(argv[0], dev, argv[3], argv[4]); } else if (strcmp(argv[2], "add") == 0) { if (argc < 4) { _add_usage(argv[0]); return 1; } return _netif_add(argv[0], (kernel_pid_t)dev, argc - 3, argv + 3); } else if (strcmp(argv[2], "del") == 0) { if (argc < 4) { _del_usage(argv[0]); return 1; } return _netif_del((kernel_pid_t)dev, argv[3]); } else if (strcmp(argv[2], "mtu") == 0) { if (argc < 4) { _mtu_usage(argv[0]); return 1; } return _netif_mtu((kernel_pid_t)dev, argv[3]); } #ifdef MODULE_L2FILTER else if (strcmp(argv[2], "l2filter") == 0) { if (argc < 5) { _l2filter_usage(argv[2]); } else if (strcmp(argv[3], "add") == 0) { return _netif_addrm_l2filter(dev, argv[4], true); } else if (strcmp(argv[3], "del") == 0) { return _netif_addrm_l2filter(dev, argv[4], false); } else { _l2filter_usage(argv[2]); } return 1; } #endif #ifdef MODULE_NETSTATS else if (strcmp(argv[2], "stats") == 0) { uint8_t module; bool reset = false; /* check for requested module */ if ((argc == 3) || (strcmp(argv[3], "all") == 0)) { module = NETSTATS_ALL; } else if (strcmp(argv[3], "l2") == 0) { module = NETSTATS_LAYER2; } else if (strcmp(argv[3], "ipv6") == 0) { module = NETSTATS_IPV6; } else { printf("Module %s doesn't exist or does not provide statistics.\n", argv[3]); return 0; } /* check if reset flag was given */ if ((argc > 4) && (strncmp(argv[4], "reset", 5) == 0)) { reset = true; } if (module & NETSTATS_LAYER2) { _netif_stats((kernel_pid_t) dev, NETSTATS_LAYER2, reset); } if (module & NETSTATS_IPV6) { _netif_stats((kernel_pid_t) dev, NETSTATS_IPV6, reset); } return 1; } #endif #ifdef MODULE_GNRC_IPV6_NETIF else if (strcmp(argv[2], "hl") == 0) { if (argc < 4) { _hl_usage(argv[0]); return 1; } int hl; gnrc_ipv6_netif_t *entry; if (((hl = atoi(argv[3])) < 0) || (hl > UINT8_MAX)) { printf("error: Hop limit must be between %" PRIu16 " and %" PRIu16 "\n", (uint16_t)0, (uint16_t)UINT16_MAX); return 1; } if ((entry = gnrc_ipv6_netif_get(dev)) == NULL) { puts("error: unable to set hop limit."); return 1; } entry->cur_hl = hl; printf("success: set hop limit %u interface %" PRIkernel_pid "\n", hl, dev); return 0; } #endif else { return _netif_flag(argv[0], dev, argv[2]); } } else { puts("error: invalid interface given"); return 1; } } printf("usage: %s [<if_id>]\n", argv[0]); _set_usage(argv[0]); _mtu_usage(argv[0]); #ifdef MODULE_GNRC_IPV6_NETIF _hl_usage(argv[0]); #endif _flag_usage(argv[0]); _add_usage(argv[0]); _del_usage(argv[0]); #ifdef MODULE_L2FILTER _l2filter_usage(argv[0]); #endif #ifdef MODULE_NETSTATS _stats_usage(argv[0]); #endif return 1; }
Error Expression::_get_token(Token &r_token) { while (true) { #define GET_CHAR() (str_ofs >= expression.length() ? 0 : expression[str_ofs++]) CharType cchar = GET_CHAR(); if (cchar == 0) { r_token.type = TK_EOF; return OK; } switch (cchar) { case 0: { r_token.type = TK_EOF; return OK; } break; case '{': { r_token.type = TK_CURLY_BRACKET_OPEN; return OK; }; case '}': { r_token.type = TK_CURLY_BRACKET_CLOSE; return OK; }; case '[': { r_token.type = TK_BRACKET_OPEN; return OK; }; case ']': { r_token.type = TK_BRACKET_CLOSE; return OK; }; case '(': { r_token.type = TK_PARENTHESIS_OPEN; return OK; }; case ')': { r_token.type = TK_PARENTHESIS_CLOSE; return OK; }; case ',': { r_token.type = TK_COMMA; return OK; }; case ':': { r_token.type = TK_COLON; return OK; }; case '$': { r_token.type = TK_INPUT; int index = 0; do { if (!_is_number(expression[str_ofs])) { _set_error("Expected number after '$'"); r_token.type = TK_ERROR; return ERR_PARSE_ERROR; } index *= 10; index += expression[str_ofs] - '0'; str_ofs++; } while (_is_number(expression[str_ofs])); r_token.value = index; return OK; }; case '=': { cchar = GET_CHAR(); if (cchar == '=') { r_token.type = TK_OP_EQUAL; } else { _set_error("Expected '='"); r_token.type = TK_ERROR; return ERR_PARSE_ERROR; } return OK; }; case '!': { if (expression[str_ofs] == '=') { r_token.type = TK_OP_NOT_EQUAL; str_ofs++; } else { r_token.type = TK_OP_NOT; } return OK; }; case '>': { if (expression[str_ofs] == '=') { r_token.type = TK_OP_GREATER_EQUAL; str_ofs++; } else if (expression[str_ofs] == '>') { r_token.type = TK_OP_SHIFT_RIGHT; str_ofs++; } else { r_token.type = TK_OP_GREATER; } return OK; }; case '<': { if (expression[str_ofs] == '=') { r_token.type = TK_OP_LESS_EQUAL; str_ofs++; } else if (expression[str_ofs] == '<') { r_token.type = TK_OP_SHIFT_LEFT; str_ofs++; } else { r_token.type = TK_OP_LESS; } return OK; }; case '+': { r_token.type = TK_OP_ADD; return OK; }; case '-': { r_token.type = TK_OP_SUB; return OK; }; case '/': { r_token.type = TK_OP_DIV; return OK; }; case '*': { r_token.type = TK_OP_MUL; return OK; }; case '%': { r_token.type = TK_OP_MOD; return OK; }; case '&': { if (expression[str_ofs] == '&') { r_token.type = TK_OP_AND; str_ofs++; } else { r_token.type = TK_OP_BIT_AND; } return OK; }; case '|': { if (expression[str_ofs] == '|') { r_token.type = TK_OP_OR; str_ofs++; } else { r_token.type = TK_OP_BIT_OR; } return OK; }; case '^': { r_token.type = TK_OP_BIT_XOR; return OK; }; case '~': { r_token.type = TK_OP_BIT_INVERT; return OK; }; case '"': { String str; while (true) { CharType ch = GET_CHAR(); if (ch == 0) { _set_error("Unterminated String"); r_token.type = TK_ERROR; return ERR_PARSE_ERROR; } else if (ch == '"') { break; } else if (ch == '\\') { //escaped characters... CharType next = GET_CHAR(); if (next == 0) { _set_error("Unterminated String"); r_token.type = TK_ERROR; return ERR_PARSE_ERROR; } CharType res = 0; switch (next) { case 'b': res = 8; break; case 't': res = 9; break; case 'n': res = 10; break; case 'f': res = 12; break; case 'r': res = 13; break; case 'u': { //hexnumbarh - oct is deprecated for (int j = 0; j < 4; j++) { CharType c = GET_CHAR(); if (c == 0) { _set_error("Unterminated String"); r_token.type = TK_ERROR; return ERR_PARSE_ERROR; } if (!(_is_number(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) { _set_error("Malformed hex constant in string"); r_token.type = TK_ERROR; return ERR_PARSE_ERROR; } CharType v; if (_is_number(c)) { v = c - '0'; } else if (c >= 'a' && c <= 'f') { v = c - 'a'; v += 10; } else if (c >= 'A' && c <= 'F') { v = c - 'A'; v += 10; } else { ERR_PRINT("BUG"); v = 0; } res <<= 4; res |= v; } } break; //case '\"': res='\"'; break; //case '\\': res='\\'; break; //case '/': res='/'; break; default: { res = next; //r_err_str="Invalid escape sequence"; //return ERR_PARSE_ERROR; } break; } str += res; } else { str += ch; } } r_token.type = TK_CONSTANT; r_token.value = str; return OK; } break; default: { if (cchar <= 32) { break; } CharType next_char = (str_ofs >= expression.length()) ? 0 : expression[str_ofs]; if (_is_number(cchar) || (cchar == '.' && _is_number(next_char))) { //a number String num; #define READING_SIGN 0 #define READING_INT 1 #define READING_DEC 2 #define READING_EXP 3 #define READING_DONE 4 int reading = READING_INT; CharType c = cchar; bool exp_sign = false; bool exp_beg = false; bool is_float = false; while (true) { switch (reading) { case READING_INT: { if (_is_number(c)) { //pass } else if (c == '.') { reading = READING_DEC; is_float = true; } else if (c == 'e') { reading = READING_EXP; } else { reading = READING_DONE; } } break; case READING_DEC: { if (_is_number(c)) { } else if (c == 'e') { reading = READING_EXP; } else { reading = READING_DONE; } } break; case READING_EXP: { if (_is_number(c)) { exp_beg = true; } else if ((c == '-' || c == '+') && !exp_sign && !exp_beg) { if (c == '-') is_float = true; exp_sign = true; } else { reading = READING_DONE; } } break; } if (reading == READING_DONE) break; num += String::chr(c); c = GET_CHAR(); } str_ofs--; r_token.type = TK_CONSTANT; if (is_float) r_token.value = num.to_double(); else r_token.value = num.to_int(); return OK; } else if ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_') { String id; bool first = true; while ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_' || (!first && _is_number(cchar))) { id += String::chr(cchar); cchar = GET_CHAR(); first = false; } str_ofs--; //go back one if (id == "in") { r_token.type = TK_OP_IN; } else if (id == "null") { r_token.type = TK_CONSTANT; r_token.value = Variant(); } else if (id == "true") { r_token.type = TK_CONSTANT; r_token.value = true; } else if (id == "false") { r_token.type = TK_CONSTANT; r_token.value = false; } else if (id == "PI") { r_token.type = TK_CONSTANT; r_token.value = Math_PI; } else if (id == "TAU") { r_token.type = TK_CONSTANT; r_token.value = Math_TAU; } else if (id == "INF") { r_token.type = TK_CONSTANT; r_token.value = Math_INF; } else if (id == "NAN") { r_token.type = TK_CONSTANT; r_token.value = Math_NAN; } else if (id == "not") { r_token.type = TK_OP_NOT; } else if (id == "or") { r_token.type = TK_OP_OR; } else if (id == "and") { r_token.type = TK_OP_AND; } else if (id == "self") { r_token.type = TK_SELF; } else { for (int i = 0; i < Variant::VARIANT_MAX; i++) { if (id == Variant::get_type_name(Variant::Type(i))) { r_token.type = TK_BASIC_TYPE; r_token.value = i; return OK; } } BuiltinFunc bifunc = find_function(id); if (bifunc != FUNC_MAX) { r_token.type = TK_BUILTIN_FUNC; r_token.value = bifunc; return OK; } r_token.type = TK_IDENTIFIER; r_token.value = id; } return OK; } else if (cchar == '.') { // Handled down there as we support '.[0-9]' as numbers above r_token.type = TK_PERIOD; return OK; } else { _set_error("Unexpected character."); r_token.type = TK_ERROR; return ERR_PARSE_ERROR; } } } #undef GET_CHAR } r_token.type = TK_ERROR; return ERR_PARSE_ERROR; }
int _gnrc_netif_config(int argc, char **argv) { if (argc < 2) { gnrc_netif_t *netif = NULL; while ((netif = gnrc_netif_iter(netif))) { _netif_list(netif->pid); } return 0; } else if (_is_number(argv[1])) { kernel_pid_t iface = atoi(argv[1]); if (_is_iface(iface)) { if (argc < 3) { _netif_list(iface); return 0; } else if (strcmp(argv[2], "set") == 0) { if (argc < 5) { _set_usage(argv[0]); return 1; } return _netif_set(argv[0], iface, argv[3], argv[4]); } else if (strcmp(argv[2], "add") == 0) { if (argc < 4) { _add_usage(argv[0]); return 1; } return _netif_add(argv[0], (kernel_pid_t)iface, argc - 3, argv + 3); } else if (strcmp(argv[2], "del") == 0) { if (argc < 4) { _del_usage(argv[0]); return 1; } return _netif_del((kernel_pid_t)iface, argv[3]); } #ifdef MODULE_L2FILTER else if (strcmp(argv[2], "l2filter") == 0) { if (argc < 5) { _l2filter_usage(argv[2]); } else if (strcmp(argv[3], "add") == 0) { return _netif_addrm_l2filter(iface, argv[4], true); } else if (strcmp(argv[3], "del") == 0) { return _netif_addrm_l2filter(iface, argv[4], false); } else { _l2filter_usage(argv[2]); } return 1; } #endif #ifdef MODULE_NETSTATS else if (strcmp(argv[2], "stats") == 0) { uint8_t module; bool reset = false; /* check for requested module */ if ((argc == 3) || (strcmp(argv[3], "all") == 0)) { module = NETSTATS_ALL; } else if (strcmp(argv[3], "l2") == 0) { module = NETSTATS_LAYER2; } else if (strcmp(argv[3], "ipv6") == 0) { module = NETSTATS_IPV6; } else { printf("Module %s doesn't exist or does not provide statistics.\n", argv[3]); return 0; } /* check if reset flag was given */ if ((argc > 4) && (strncmp(argv[4], "reset", 5) == 0)) { reset = true; } if (module & NETSTATS_LAYER2) { _netif_stats((kernel_pid_t) iface, NETSTATS_LAYER2, reset); } if (module & NETSTATS_IPV6) { _netif_stats((kernel_pid_t) iface, NETSTATS_IPV6, reset); } return 1; } #endif else if (strcmp(argv[2], "help") == 0) { _usage(argv[0]); return 0; } else { return _netif_flag(argv[0], iface, argv[2]); } } else { puts("error: invalid interface given"); return 1; } } _usage(argv[0]); return 1; }