static int parse_section (section_t **section,scan_t *sc,char **lookahead) { int result = OK; if (lookahead != NULL) { result = parse_assignment (section,sc,lookahead,SECTION_START); while (result == OK) { SCAN(); if (result == '}') return (OK); if (result != TOK_KEYWORD) { parse_error (sc,"'}', or TOK_KEYWORD",result); return (ERR); } result = parse_assignment (section,sc,&sc->token.keyword,SECTION_END); if (result == FIN) { parse_error (sc,"'}'",result); return (ERR); } } } else while (result == OK) result = parse_assignment (section,sc,NULL,0); return (result); }
instruction_ptr Parser::parse_instruction() { if (!ErrorHandler::is_ok()) return instruction_ptr(); save(); instruction_ptr result = parse_assignment(); if (!result) { restore(); result = parse_expression(); } if (!result) result = parse_if_block(); if (!result) result = parse_while_block(); if (!result) result = parse_return(); if (!result) result = parse_print(); if (!result) result = parse_read(); if (result) next_line(); return result; }
void StatusMessageList::LoadFile(TLineReader &reader) { int ms; // Found ms for delay const TCHAR **location; // Where to put the data bool some_data; // Did we find some in the last loop... // Init first entry _init_Status(StatusMessageData_Size); some_data = false; /* Read from the file */ TCHAR *buffer; const TCHAR *key, *value; while ((StatusMessageData_Size < MAXSTATUSMESSAGECACHE) && (buffer = reader.read()) != NULL) { // Check valid line? If not valid, assume next record (primative, but works ok!) if (*buffer == _T('#') || !parse_assignment(buffer, key, value)) { // Global counter (only if the last entry had some data) if (some_data) { StatusMessageData_Size++; some_data = false; _init_Status(StatusMessageData_Size); } } else { location = NULL; if (_tcscmp(key, _T("key")) == 0) { some_data = true; // Success, we have a real entry location = &StatusMessageData[StatusMessageData_Size].key; } else if (_tcscmp(key, _T("sound")) == 0) { StatusMessageData[StatusMessageData_Size].doSound = true; location = &StatusMessageData[StatusMessageData_Size].sound; } else if (_tcscmp(key, _T("delay")) == 0) { TCHAR *endptr; ms = _tcstol(value, &endptr, 10); if (endptr > value) StatusMessageData[StatusMessageData_Size].delay_ms = ms; } else if (_tcscmp(key, _T("hide")) == 0) { if (_tcscmp(value, _T("yes")) == 0) StatusMessageData[StatusMessageData_Size].doStatus = false; } // Do we have somewhere to put this && // is it currently empty ? (prevent lost at startup) if (location && (_tcscmp(*location, _T("")) == 0)) { // TODO code: this picks up memory lost from no entry, but not duplicates - fix. if (*location) { // JMW fix memory leak free((void*)*location); } *location = StringMallocParse(value); } } } // How many we really got (blank next just in case) StatusMessageData_Size++; _init_Status(StatusMessageData_Size); }
/*----------------------------------------------------------------------*/ static ast_statement_t *parse_statement(parse_state_t *p) { token_t *token; token = peek_token(p); if (token == NULL) { return NULL; } else if (test_token(token, TK_ELSE) || test_token(token, TK_END)) { return NULL; } else if (test_token(token, TK_VAR)) { return parse_declare_var(p); } else if (test_token(token, TK_FUNCTION)) { return parse_define_function(p); } else if (test_token(token, TK_RETURN)) { return parse_return(p); } else if (test_token(token, TK_IF)) { return parse_if(p); } else if (test_token(token, TK_FOR)) { return parse_for(p); } else if (test_token(token, TK_IDENTIFIER)) { return parse_assignment(p); } next_token(p); error(p, "statement expected"); return NULL; /* unreachable */ }
int scan(FILE *target) { hash_t *var_map = malloc(sizeof(hash_t)); hash_init(var_map, 1024); write_header(target); int ret = 0; while(next() == true){ if(is_alpha() == false){ printf("An instruction can only start with a function call or assignment\n"); return 1; } char *current_token = get_token(); char *temp; strcpy(temp, current_token); if(next() == false){ printf("Incomplete instruction\n"); return 1; } if(is_left()){ ret = parse_call(target, temp, var_map); /* It is a call */ } else if(is_assignment()){ ret = parse_assignment(target, temp, var_map); /* It is an assignment */ } else { printf("Not a valid instruction\n"); return 1; } if(ret == 1 ){ printf("Syntax error\n"); return 1; } } write_end(target); free(var_map); return ret; }
/**************************************************************************** * op_cmos_set_one_param * * -w NAME=VALUE * * Set parameter NAME to VALUE. ****************************************************************************/ static void op_cmos_set_one_param(void) { const char *name, *value; get_cmos_layout(); /* Separate 'NAME=VALUE' syntax into two strings representing NAME and * VALUE. */ parse_assignment(nvramtool_op.param, &name, &value); set_one_param(name, value); }
void Parser::scan_line() { if (current_char == NEWLINE) return; std::string line = ""; line += current_char; while (scan_char() && current_char != NEWLINE) line += current_char; getSection()->lines.push_back( parse_assignment(line)); };
// declaration = "var" identifier [ "=" expression ] [ "," { i [ "=" e ] } ] static enum v7_err parse_declaration(struct v7 *v7) { int sp = v7_sp(v7); do { inc_stack(v7, sp - v7_sp(v7)); // Clean up the stack after prev decl TRY(parse_identifier(v7)); if (*v7->cursor == '=') { if (!v7->no_exec) v7_make_and_push(v7, V7_UNDEF); TRY(parse_assignment(v7, &v7->scopes[v7->current_scope])); } } while (test_and_skip_char(v7, ',')); return V7_OK; }
std::vector<reaver::despayre::assignment> reaver::despayre::_v1::parse(std::vector<reaver::despayre::token> tokens) { std::vector<assignment> assignments; context ctx; ctx.begin = std::begin(tokens); ctx.end = std::end(tokens); while (ctx.begin != ctx.end) { assignments.push_back(parse_assignment(ctx)); } return assignments; }
// expression = term { add_op term } | // expression "?" expression ":" expression // expression logical_op expression // variable "=" expression // add_op = "+" | "-" static enum v7_err parse_expression(struct v7 *v7) { #ifdef V7_DEBUG const char *stmt_str = v7->cursor; #endif int op; v7->cur_obj = &v7->scopes[v7->current_scope]; TRY(parse_term(v7)); while (*v7->cursor == '-' || *v7->cursor == '+') { int ch = *v7->cursor; TRY(match(v7, ch)); TRY(parse_term(v7)); TRY(do_arithmetic_op(v7, ch)); } if ((op = is_logical_op(v7->cursor)) > OP_XX) { v7->cursor += op == OP_LT || op == OP_GT ? 1 : 2; skip_whitespaces_and_comments(v7); TRY(parse_expression(v7)); TRY(do_logical_op(v7, op)); } // Parse assignment if (*v7->cursor == '=') { //printf("=> cur_obj: %p\n", cur_obj); TRY(parse_assignment(v7, v7->cur_obj)); } // Parse ternary operator if (*v7->cursor == '?') { int condition_true = v7_is_true(v7_top(v7)[-1]); int old_no_exec = v7->no_exec; TRY(match(v7, '?')); v7->no_exec = old_no_exec || !condition_true; TRY(parse_expression(v7)); TRY(match(v7, ':')); v7->no_exec = old_no_exec || condition_true; TRY(parse_expression(v7)); v7->no_exec = old_no_exec; } return V7_OK; }
void StatusMessageList::LoadFile(TLineReader &reader) { // Init first entry StatusMessage current; current.Clear(); /* Read from the file */ TCHAR *buffer; const TCHAR *key, *value; while ((buffer = reader.ReadLine()) != NULL) { // Check valid line? If not valid, assume next record (primative, but works ok!) if (*buffer == _T('#') || !parse_assignment(buffer, key, value)) { // Global counter (only if the last entry had some data) if (!current.IsEmpty()) { list.append(current); current.Clear(); if (list.full()) break; } } else { if (_tcscmp(key, _T("key")) == 0) { if (current.key == NULL) current.key = UnescapeBackslash(value); } else if (_tcscmp(key, _T("sound")) == 0) { if (current.sound == NULL) current.sound = UnescapeBackslash(value); } else if (_tcscmp(key, _T("delay")) == 0) { TCHAR *endptr; unsigned ms = ParseUnsigned(value, &endptr); if (endptr > value) current.delay_ms = ms; } else if (_tcscmp(key, _T("hide")) == 0) { if (_tcscmp(value, _T("yes")) == 0) current.visible = false; } } } if (!current.IsEmpty()) list.append(current); }
int main( int argc, char *argv[] ) { char *filename = NULL; char *msg = NULL; if ( argc == 2 ) { filename = argv[ 1 ]; switch ( utils_validate_filename( filename ) ) { case FILE_OK: printf( "Input File: %s\n", filename ); parse_init( filename ); parse_assignment(); fclose( g_fptr ); break; case BAD_EXTENSION: msg = "Expected a file in the format of '< filename >.xwell'"; utils_error( msg, strlen( msg ) ); break; default: msg = "Unknown FILECHECK_t Error"; utils_error( msg, strlen( msg ) ); } } else { char msgbf[ 100 ] = "\0"; size_t n = sprintf( msgbf, "Usage - %s %s", argv[ 0 ], "< filename >.xwell" ); utils_error( msgbf, n ); } msg = NULL; filename = NULL; exit( EXIT_SUCCESS ); }
struct instruction *parse_for(void) { int decreasing = 0; eat(FOR); struct expr *lhs = parse_expression(); struct assignment *a = parse_assignment(lhs); if (current_lang == LANG_EN && lookahead[0]->type == DECREASING) { decreasing = 1; eat(DECREASING); } else eat(UNTIL); struct expr *until = parse_expression(); if (current_lang == LANG_FR && lookahead[0]->type == DECREASING) { decreasing = 1; eat(DECREASING); } eat(DO); eat(EOL); instructionlist_t block = parse_block(); eat(END); eat(FOR); eat(EOL); return forblock(a, until, decreasing, block); }
void StatusMessageList::LoadFile(TLineReader &reader) { int ms; // Found ms for delay const TCHAR **location; // Where to put the data bool some_data; // Did we find some in the last loop... // Init first entry StatusMessageSTRUCT current; _init_Status(current); some_data = false; /* Read from the file */ TCHAR *buffer; const TCHAR *key, *value; while ((buffer = reader.read()) != NULL) { // Check valid line? If not valid, assume next record (primative, but works ok!) if (*buffer == _T('#') || !parse_assignment(buffer, key, value)) { // Global counter (only if the last entry had some data) if (some_data) { StatusMessageData.append(current); some_data = false; _init_Status(current); if (StatusMessageData.full()) break; } } else { location = NULL; if (_tcscmp(key, _T("key")) == 0) { some_data = true; // Success, we have a real entry location = ¤t.key; } else if (_tcscmp(key, _T("sound")) == 0) { current.doSound = true; location = ¤t.sound; } else if (_tcscmp(key, _T("delay")) == 0) { TCHAR *endptr; ms = _tcstol(value, &endptr, 10); if (endptr > value) current.delay_ms = ms; } else if (_tcscmp(key, _T("hide")) == 0) { if (_tcscmp(value, _T("yes")) == 0) current.doStatus = false; } // Do we have somewhere to put this && // is it currently empty ? (prevent lost at startup) if (location && (_tcscmp(*location, _T("")) == 0)) { // TODO code: this picks up memory lost from no entry, but not duplicates - fix. if (*location) { // JMW fix memory leak free((void*)const_cast<TCHAR *>(*location)); } *location = UnescapeBackslash(value); } } } if (some_data) StatusMessageData.append(current); }
/*------------------------------------------------------------------------- * Function: parse_expr * * Purpose: Parses an expression. * * Return: Success: The expression. * * Failure: &ErrorCell * * Programmer: Robb Matzke * [email protected] * Dec 4 1996 * * Modifications: * *------------------------------------------------------------------------- */ static obj_t parse_expr (lex_t *f, int skipnl) { return parse_assignment (f, skipnl); }
void ParseInputFile(InputConfig &config, TLineReader &reader) { // TODO code - Safer sizes, strings etc - use C++ (can scanf restrict length?) TCHAR *new_label = NULL; // Init first entry // Did we find some in the last loop... bool some_data = false; // Multiple modes (so large string) TCHAR d_mode[1024] = _T(""); TCHAR d_type[256] = _T(""); TCHAR d_data[256] = _T(""); unsigned event_id = 0; TCHAR d_label[256] = _T(""); int d_location = 0; TCHAR d_event[256] = _T(""); TCHAR d_misc[256] = _T(""); int line = 0; // Read from the file // TODO code: What about \r - as in \r\n ? // TODO code: Note that ^# does not allow # in key - might be required (probably not) // Better way is to separate the check for # and the scanf TCHAR *buffer; while ((buffer = reader.read()) != NULL) { TrimRight(buffer); line++; const TCHAR *key, *value; // experimental: if the first line is "#CLEAR" then the whole default config is cleared // and can be overwritten by file if (line == 1 && _tcscmp(buffer, _T("#CLEAR")) == 0) { config.clear_all_events(); } else if (buffer[0] == _T('\0')) { // Check valid line? If not valid, assume next record (primative, but works ok!) // General checks before continue... if (some_data && (d_mode != NULL) && (_tcscmp(d_mode, _T("")) != 0)) { TCHAR *token; // For each mode token = _tcstok(d_mode, _T(" ")); // General errors - these should be true assert(d_location >= 0); assert(d_location < 1024); // Scott arbitrary limit assert(d_mode != NULL); assert(d_type != NULL); assert(d_label != NULL); // These could indicate bad data - thus not an ASSERT (debug only) // assert(_tcslen(d_mode) < 1024); // assert(_tcslen(d_type) < 1024); // assert(_tcslen(d_label) < 1024); while (token != NULL) { // All modes are valid at this point int mode_id = config.make_mode(token); assert(mode_id >= 0); // Make label event // TODO code: Consider Reuse existing entries... if (d_location > 0) { // Only copy this once per object - save string space if (!new_label) { new_label = StringMallocParse(d_label); } config.append_menu(mode_id, new_label, d_location, event_id); } // Make key (Keyboard input) // key - Hardware key or keyboard if (_tcscmp(d_type, _T("key")) == 0) { // Get the int key (eg: APP1 vs 'a') unsigned key = InputEvents::findKey(d_data); if (key > 0) config.Key2Event[mode_id][key] = event_id; else LogStartUp(_T("Invalid key data: %s at %i"), d_data, line); // Make gce (Glide Computer Event) // GCE - Glide Computer Event } else if (_tcscmp(d_type, _T("gce")) == 0) { // Get the int key (eg: APP1 vs 'a') int key = InputEvents::findGCE(d_data); if (key >= 0) config.GC2Event[mode_id][key] = event_id; else LogStartUp(_T("Invalid GCE data: %s at %i"), d_data, line); // Make ne (NMEA Event) // NE - NMEA Event } else if (_tcscmp(d_type, _T("ne")) == 0) { // Get the int key (eg: APP1 vs 'a') int key = InputEvents::findNE(d_data); if (key >= 0) config.N2Event[mode_id][key] = event_id; else LogStartUp(_T("Invalid GCE data: %s at %i"), d_data, line); // label only - no key associated (label can still be touch screen) } else if (_tcscmp(d_type, _T("label")) == 0) { // Nothing to do here... } else { LogStartUp(_T("Invalid type: %s at %i"), d_type, line); } token = _tcstok(NULL, _T(" ")); } } // Clear all data. some_data = false; _tcscpy(d_mode, _T("")); _tcscpy(d_type, _T("")); _tcscpy(d_data, _T("")); event_id = 0; _tcscpy(d_label, _T("")); d_location = 0; new_label = NULL; } else if (string_is_empty(buffer) || buffer[0] == _T('#')) { // Do nothing - we probably just have a comment line // JG removed "void;" - causes warning (void is declaration and needs variable) // NOTE: Do NOT display buffer to user as it may contain an invalid stirng ! } else if (parse_assignment(buffer, key, value)) { if (_tcscmp(key, _T("mode")) == 0) { if (_tcslen(value) < 1024) { some_data = true; // Success, we have a real entry _tcscpy(d_mode, value); } } else if (_tcscmp(key, _T("type")) == 0) { if (_tcslen(value) < 256) _tcscpy(d_type, value); } else if (_tcscmp(key, _T("data")) == 0) { if (_tcslen(value) < 256) _tcscpy(d_data, value); } else if (_tcscmp(key, _T("event")) == 0) { if (_tcslen(value) < 256) { _tcscpy(d_event, _T("")); _tcscpy(d_misc, _T("")); int ef; #if defined(__BORLANDC__) memset(d_event, 0, sizeof(d_event)); memset(d_misc, 0, sizeof(d_event)); if (_tcschr(value, ' ') == NULL) { _tcscpy(d_event, value); } else { #endif ef = _stscanf(value, _T("%[^ ] %[A-Za-z0-9 \\/().,]"), d_event, d_misc); #if defined(__BORLANDC__) } #endif // TODO code: Can't use token here - breaks // other token - damn C - how about // C++ String class ? // TCHAR *eventtoken; // eventtoken = _tcstok(value, _T(" ")); // d_event = token; // eventtoken = _tcstok(value, _T(" ")); if ((ef == 1) || (ef == 2)) { // TODO code: Consider reusing existing identical events pt2Event event = InputEvents::findEvent(d_event); if (event) { TCHAR *allocated = StringMallocParse(d_misc); event_id = config.append_event(event, allocated, event_id); /* not freeing the string, because InputConfig::append_event() stores the string point without duplicating it; strictly speaking, this is a memory leak, but the input file is only loaded once at startup, so this is acceptable; in return, we don't have to duplicate the hard-coded defaults, which saves some memory */ //free(allocated); } else { LogStartUp(_T("Invalid event type: %s at %i"), d_event, line); } } else { LogStartUp(_T("Invalid event type at %i"), line); } } } else if (_tcscmp(key, _T("label")) == 0) { _tcscpy(d_label, value); } else if (_tcscmp(key, _T("location")) == 0) { d_location = _ttoi(value); } else { LogStartUp(_T("Invalid key/value pair %s=%s at %i"), key, value, line); } } else { LogStartUp(_T("Invalid line at %i"), line); } } // end while }
void ParseInputFile(InputConfig &config, TLineReader &reader) { // TODO code - Safer sizes, strings etc - use C++ (can scanf restrict length?) // Multiple modes (so large string) EventBuilder current; current.clear(); int line = 0; // Read from the file TCHAR *buffer; while ((buffer = reader.ReadLine()) != NULL) { TrimRight(buffer); line++; const TCHAR *key, *value; // experimental: if the first line is "#CLEAR" then the whole default config is cleared // and can be overwritten by file if (line == 1 && StringIsEqual(buffer, _T("#CLEAR"))) { config.SetDefaults(); } else if (buffer[0] == _T('\0')) { // Check valid line? If not valid, assume next record (primative, but works ok!) // General checks before continue... current.commit(config, line); // Clear all data. current.clear(); } else if (StringIsEmpty(buffer) || buffer[0] == _T('#')) { // Do nothing - we probably just have a comment line // NOTE: Do NOT display buffer to user as it may contain an invalid stirng ! } else if (parse_assignment(buffer, key, value)) { if (StringIsEqual(key, _T("mode"))) { current.mode = value; } else if (StringIsEqual(key, _T("type"))) { current.type = value; } else if (StringIsEqual(key, _T("data"))) { current.data = value; } else if (StringIsEqual(key, _T("event"))) { if (_tcslen(value) < 256) { TCHAR d_event[256] = _T(""); TCHAR d_misc[256] = _T(""); int ef; #if defined(__BORLANDC__) memset(d_event, 0, sizeof(d_event)); memset(d_misc, 0, sizeof(d_event)); if (_tcschr(value, ' ') == NULL) { _tcscpy(d_event, value); } else { #endif ef = _stscanf(value, _T("%[^ ] %[A-Za-z0-9 \\/().,]"), d_event, d_misc); #if defined(__BORLANDC__) } #endif if ((ef == 1) || (ef == 2)) { // TODO code: Consider reusing existing identical events pt2Event event = InputEvents::findEvent(d_event); if (event) { TCHAR *allocated = UnescapeBackslash(d_misc); current.event_id = config.AppendEvent(event, allocated, current.event_id); /* not freeing the string, because InputConfig::AppendEvent() stores the string point without duplicating it; strictly speaking, this is a memory leak, but the input file is only loaded once at startup, so this is acceptable; in return, we don't have to duplicate the hard-coded defaults, which saves some memory */ //free(allocated); } else { LogStartUp(_T("Invalid event type: %s at %i"), d_event, line); } } else { LogFormat("Invalid event type at %i", line); } } } else if (StringIsEqual(key, _T("label"))) { current.label = value; } else if (StringIsEqual(key, _T("location"))) { current.location = ParseUnsigned(value); } else { LogStartUp(_T("Invalid key/value pair %s=%s at %i"), key, value, line); } } else { LogFormat("Invalid line at %i", line); } } current.commit(config, line); }
void handle_rr(struct session_info *s, struct gsm48_hdr *dtap, unsigned len, uint32_t fn) { struct gsm48_system_information_type_6 *si6; struct tlv_parsed tp; s->rat = RAT_GSM; assert(s->new_msg); if (!len) { return; } switch (dtap->msg_type) { case GSM48_MT_RR_SYSINFO_1: SET_MSG_INFO(s, "SYSTEM INFO 1"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_2: SET_MSG_INFO(s, "SYSTEM INFO 2"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_2bis: SET_MSG_INFO(s, "SYSTEM INFO 2bis"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_2ter: SET_MSG_INFO(s, "SYSTEM INFO 2ter"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_2quater: SET_MSG_INFO(s, "SYSTEM INFO 2quater"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_3: SET_MSG_INFO(s, "SYSTEM INFO 3"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_4: SET_MSG_INFO(s, "SYSTEM INFO 4"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_5: SET_MSG_INFO(s, "SYSTEM INFO 5"); rand_check((uint8_t *)dtap, 18, &s->si5, s->cipher); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_5bis: SET_MSG_INFO(s, "SYSTEM INFO 5bis"); rand_check((uint8_t *)dtap, 18, &s->si5bis, s->cipher); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_5ter: SET_MSG_INFO(s, "SYSTEM INFO 5ter"); rand_check((uint8_t *)dtap, 18, &s->si5ter, s->cipher); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_6: SET_MSG_INFO(s, "SYSTEM INFO 6"); rand_check((uint8_t *)dtap, 18, &s->si6, s->cipher); si6 = (struct gsm48_system_information_type_6 *) dtap; handle_lai(s, (uint8_t*)&si6->lai, htons(si6->cell_identity)); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_SYSINFO_13: SET_MSG_INFO(s, "SYSTEM INFO 13"); handle_sysinfo(s, dtap, len); break; case GSM48_MT_RR_CHAN_REL: SET_MSG_INFO(s, "CHANNEL RELEASE"); if (s->cipher && !s->fc.enc_rand) s->fc.predict++; s->release = 1; s->rr_cause = dtap->data[0]; if ((len > 3) && ((dtap->data[1] & 0xf0) == 0xc0)) s->have_gprs = 1; session_reset(&s[0], 0); if (auto_reset) { s[1].new_msg = NULL; } break; case GSM48_MT_RR_CLSM_ENQ: SET_MSG_INFO(s, "CLASSMARK ENQUIRY"); break; case GSM48_MT_RR_MEAS_REP: SET_MSG_INFO(s, "MEASUREMENT REPORT"); break; case GSM48_MT_RR_CLSM_CHG: SET_MSG_INFO(s, "CLASSMARK CHANGE"); handle_classmark(s, &dtap->data[1], 2); break; case GSM48_MT_RR_PAG_REQ_1: SET_MSG_INFO(s, "PAGING REQ 1"); handle_paging1(dtap, len); break; case GSM48_MT_RR_PAG_REQ_2: SET_MSG_INFO(s, "PAGING REQ 2"); handle_paging2(dtap, len); break; case GSM48_MT_RR_PAG_REQ_3: SET_MSG_INFO(s, "PAGING REQ 3"); handle_paging3(); break; case GSM48_MT_RR_IMM_ASS: SET_MSG_INFO(s, "IMM ASSIGNMENT"); break; case GSM48_MT_RR_IMM_ASS_EXT: SET_MSG_INFO(s, "IMM ASSIGNMENT EXT"); break; case GSM48_MT_RR_IMM_ASS_REJ: SET_MSG_INFO(s, "IMM ASSIGNMENT REJECT"); break; case GSM48_MT_RR_PAG_RESP: session_reset(s, 1); SET_MSG_INFO(s, "PAGING RESPONSE"); handle_pag_resp(s, dtap->data); break; case GSM48_MT_RR_HANDO_CMD: SET_MSG_INFO(s, "HANDOVER COMMAND"); parse_assignment(dtap, len, s->cell_arfcns, &s->ga); s->handover = 1; s->use_jump = 2; break; case GSM48_MT_RR_HANDO_COMPL: SET_MSG_INFO(s, "HANDOVER COMPLETE"); break; case GSM48_MT_RR_ASS_CMD: SET_MSG_INFO(s, "ASSIGNMENT COMMAND"); if ((s->fc.enc-s->fc.enc_null-s->fc.enc_si) == 1) s->forced_ho = 1; parse_assignment(dtap, len, s->cell_arfcns, &s->ga); s->assignment = 1; s->use_jump = 1; break; case GSM48_MT_RR_ASS_COMPL: SET_MSG_INFO(s, "ASSIGNMENT COMPLETE"); s->assign_complete = 1; break; case GSM48_MT_RR_CIPH_M_COMPL: SET_MSG_INFO(s, "CIPHER MODE COMPLETE"); if (s->cipher_missing < 0) { s->cipher_missing = 0; } else { s->cipher_missing = 1; } if (!s->cm_comp_first_fn) { if (fn) { s->cm_comp_first_fn = fn; } else { s->cm_comp_first_fn = GSM_MAX_FN; } } if (fn) { s->cm_comp_last_fn = fn; } else { s->cm_comp_last_fn = GSM_MAX_FN; } s->cm_comp_count++; if (dtap->data[0] == 0x2b) return; /* get IMEISV */ tlv_parse(&tp, &gsm48_rr_att_tlvdef, dtap->data, len-2, 0, 0); if (TLVP_PRESENT(&tp, GSM48_IE_MOBILE_ID)) { uint8_t *v = (uint8_t *) TLVP_VAL(&tp, GSM48_IE_MOBILE_ID); handle_mi(s, &v[1], v[0], 0); s->cmc_imeisv = 1; } break; case GSM48_MT_RR_GPRS_SUSP_REQ: SET_MSG_INFO(s, "GPRS SUSPEND"); s->have_gprs = 1; //tlli //rai (lai+rac) break; case GSM48_MT_RR_CIPH_M_CMD: if (!s->cm_cmd_fn) { if (fn) { s->cm_cmd_fn = fn; } else { s->cm_cmd_fn = GSM_MAX_FN; } } if (dtap->data[0] & 1) { s->cipher = 1 + ((dtap->data[0]>>1) & 7); if (!not_zero(s->key, 8)) s->decoded = 0; } SET_MSG_INFO(s, "CIPHER MODE COMMAND, A5/%u", s->cipher); if (dtap->data[0] & 0x10) { s->cmc_imeisv = 1; if (s->cipher && !s->fc.enc_rand) s->fc.predict++; } s->cipher_missing = -1; break; case 0x60: SET_MSG_INFO(s, "UTRAN CLASSMARK"); break; default: SET_MSG_INFO(s, "UNKNOWN RR (%02x)", dtap->msg_type); s->unknown = 1; }
struct instruction *parse_assignment_instr(struct expr *lhs) { struct assignment *a = parse_assignment(lhs); eat(EOL); return assigninstr(a); }