void printMutex(){ char buf[100] = "Lock = ;"; char buf2[100] = "Bolt = ;"; convert_num(m.lock, buf+7); convert_num(m.bolt, buf2+7); writeScrPM(buf, 12, 0); writeScrPM(buf2, 12, 9); }
/* * Parse a sequence of numbers separated by the token specified in separator. * Exactly max numbers are expected. */ int parse_numeric_aggregate(FILE *cfile, unsigned char *buf, int max, int separator, int base) { char *val; int token, count; if (buf == NULL || max == 0) error("no space for numeric aggregate"); for (count = 0; count < max; count++, buf++) { if (count && (peek_token(&val, cfile) == separator)) token = next_token(&val, cfile); token = next_token(&val, cfile); if (token == TOK_NUMBER || (base == 16 && token == TOK_NUMBER_OR_NAME)) /* XXX Need to check if conversion was successful. */ convert_num(buf, val, base, 8); else break; } if (count < max) { parse_warn("numeric aggregate too short."); return (0); } return (1); }
/* * lease-time :== NUMBER SEMI */ void parse_lease_time(FILE *cfile, time_t *timep) { char *val; int token; token = next_token(&val, cfile); if (token != NUMBER) { parse_warn("Expecting numeric lease time"); skip_to_semi(cfile); return; } convert_num((unsigned char *)timep, val, 10, 32); /* Unswap the number - convert_num returns stuff in NBO. */ *timep = ntohl(*timep); /* XXX */ parse_semi(cfile); }
int parse_X(FILE *cfile, u_int8_t *buf, int max) { int token; char *val; int len; token = peek_token(&val, cfile); if (token == TOK_NUMBER_OR_NAME || token == TOK_NUMBER) { len = 0; do { token = next_token(&val, cfile); if (token != TOK_NUMBER && token != TOK_NUMBER_OR_NAME) { parse_warn("expecting hexadecimal constant."); skip_to_semi(cfile); return (0); } convert_num(&buf[len], val, 16, 8); if (len++ > max) { parse_warn("hexadecimal constant too long."); skip_to_semi(cfile); return (0); } token = peek_token(&val, cfile); if (token == ':') token = next_token(&val, cfile); } while (token == ':'); val = (char *)buf; } else if (token == TOK_STRING) { token = next_token(&val, cfile); len = strlen(val); if (len + 1 > max) { parse_warn("string constant too long."); skip_to_semi(cfile); return (0); } memcpy(buf, val, len + 1); } else { parse_warn("expecting string or hexadecimal data"); skip_to_semi(cfile); return (0); } return (len); }
void printIDM(){ asm("cli"); if(m.q == null) { writeScrPM("NULL ", 18, 0); asm("sti"); return; } pcb_t* p = m.q; writeScrPM(" ", 18, 0); int i = 0; while(p){ char buf[100] = " "; convert_num(p->id, buf+1); writeScrPM(buf, 18, i); i = i+3; p = p->next; } asm("sti"); }
void printIDH(){ asm("cli");/* if(head == null) { writeScrPM("NULL ", 17, 0); asm("sti"); return; }//*/ pcb_t* p = head; writeScrPM(" ", 17, 0); int i = 0; while(p){ char buf[100] = " "; convert_num(p->id, buf+1); writeScrPM(buf, 17, i); i = i+3; p = p->next; } asm("sti"); }
/* * No BNF for numeric aggregates - that's defined by the caller. What * this function does is to parse a sequence of numbers separated by the * token specified in separator. If max is zero, any number of numbers * will be parsed; otherwise, exactly max numbers are expected. Base * and size tell us how to internalize the numbers once they've been * tokenized. */ unsigned char * parse_numeric_aggregate(FILE *cfile, unsigned char *buf, int *max, int separator, int base, int size) { unsigned char *bufp = buf, *s = NULL; int token, count = 0; char *val, *t; size_t valsize; pair c = NULL; if (!bufp && *max) { bufp = malloc(*max * size / 8); if (!bufp) error("can't allocate space for numeric aggregate"); } else s = bufp; do { if (count) { token = peek_token(&val, cfile); if (token != separator) { if (!*max) break; if (token != RBRACE && token != LBRACE) token = next_token(&val, cfile); parse_warn("too few numbers."); if (token != SEMI) skip_to_semi(cfile); return (NULL); } token = next_token(&val, cfile); } token = next_token(&val, cfile); if (token == EOF) { parse_warn("unexpected end of file"); break; } /* Allow NUMBER_OR_NAME if base is 16. */ if (token != NUMBER && (base != 16 || token != NUMBER_OR_NAME)) { parse_warn("expecting numeric value."); skip_to_semi(cfile); return (NULL); } /* * If we can, convert the number now; otherwise, build a * linked list of all the numbers. */ if (s) { convert_num(s, val, base, size); s += size / 8; } else { valsize = strlen(val) + 1; t = malloc(valsize); if (!t) error("no temp space for number."); memcpy(t, val, valsize); c = cons(t, c); } } while (++count != *max); /* If we had to cons up a list, convert it now. */ if (c) { bufp = malloc(count * size / 8); if (!bufp) error("can't allocate space for numeric aggregate."); s = bufp + count - size / 8; *max = count; } while (c) { pair cdr = c->cdr; convert_num(s, (char *)c->car, base, size); s -= size / 8; /* Free up temp space. */ free(c->car); free(c); c = cdr; } return (bufp); }
int parse_option_decl(FILE *cfile, struct option_data *options) { char *val; int token; u_int8_t buf[4]; u_int8_t hunkbuf[1024]; int hunkix = 0; char *fmt; struct iaddr ip_addr; u_int8_t *dp; int len, code; int nul_term = 0; token = next_token(&val, cfile); if (!is_identifier(token)) { parse_warn("expecting identifier after option keyword."); if (token != ';') skip_to_semi(cfile); return (-1); } /* Look up the actual option info. */ fmt = NULL; for (code = 0; code < 256; code++) if (strcmp(dhcp_options[code].name, val) == 0) break; if (code > 255) { parse_warn("no option named %s", val); skip_to_semi(cfile); return (-1); } /* Parse the option data... */ do { for (fmt = dhcp_options[code].format; *fmt; fmt++) { if (*fmt == 'A') break; switch (*fmt) { case 'X': len = parse_X(cfile, &hunkbuf[hunkix], sizeof(hunkbuf) - hunkix); hunkix += len; break; case 't': /* Text string... */ token = next_token(&val, cfile); if (token != TOK_STRING) { parse_warn("expecting string."); skip_to_semi(cfile); return (-1); } len = strlen(val); if (hunkix + len + 1 > sizeof(hunkbuf)) { parse_warn("option data buffer %s", "overflow"); skip_to_semi(cfile); return (-1); } memcpy(&hunkbuf[hunkix], val, len + 1); nul_term = 1; hunkix += len; break; case 'I': /* IP address. */ if (!parse_ip_addr(cfile, &ip_addr)) return (-1); len = ip_addr.len; dp = ip_addr.iabuf; alloc: if (hunkix + len > sizeof(hunkbuf)) { parse_warn("option data buffer " "overflow"); skip_to_semi(cfile); return (-1); } memcpy(&hunkbuf[hunkix], dp, len); hunkix += len; break; case 'L': /* Unsigned 32-bit integer... */ case 'l': /* Signed 32-bit integer... */ token = next_token(&val, cfile); if (token != TOK_NUMBER) { need_number: parse_warn("expecting number."); if (token != ';') skip_to_semi(cfile); return (-1); } convert_num(buf, val, 0, 32); len = 4; dp = buf; goto alloc; case 's': /* Signed 16-bit integer. */ case 'S': /* Unsigned 16-bit integer. */ token = next_token(&val, cfile); if (token != TOK_NUMBER) goto need_number; convert_num(buf, val, 0, 16); len = 2; dp = buf; goto alloc; case 'b': /* Signed 8-bit integer. */ case 'B': /* Unsigned 8-bit integer. */ token = next_token(&val, cfile); if (token != TOK_NUMBER) goto need_number; convert_num(buf, val, 0, 8); len = 1; dp = buf; goto alloc; case 'f': /* Boolean flag. */ token = next_token(&val, cfile); if (!is_identifier(token)) { parse_warn("expecting identifier."); bad_flag: if (token != ';') skip_to_semi(cfile); return (-1); } if (!strcasecmp(val, "true") || !strcasecmp(val, "on")) buf[0] = 1; else if (!strcasecmp(val, "false") || !strcasecmp(val, "off")) buf[0] = 0; else { parse_warn("expecting boolean."); goto bad_flag; } len = 1; dp = buf; goto alloc; default: warning("Bad format %c in parse_option_param.", *fmt); skip_to_semi(cfile); return (-1); } } token = next_token(&val, cfile); } while (*fmt == 'A' && token == ','); if (token != ';') { parse_warn("semicolon expected."); skip_to_semi(cfile); return (-1); } options[code].data = malloc(hunkix + nul_term); if (!options[code].data) error("out of memory allocating option data."); memcpy(options[code].data, hunkbuf, hunkix + nul_term); options[code].len = hunkix; return (code); }
struct option * parse_option_decl(FILE *cfile, struct option_data *options) { char *val; int token; u_int8_t buf[4]; u_int8_t hunkbuf[1024]; int hunkix = 0; char *vendor; char *fmt; struct universe *universe; struct option *option; struct iaddr ip_addr; u_int8_t *dp; int len; int nul_term = 0; token = next_token(&val, cfile); if (!is_identifier(token)) { parse_warn("expecting identifier after option keyword."); if (token != SEMI) skip_to_semi(cfile); return (NULL); } if ((vendor = strdup(val)) == NULL) error("no memory for vendor information."); token = peek_token(&val, cfile); if (token == DOT) { /* Go ahead and take the DOT token... */ token = next_token(&val, cfile); /* The next token should be an identifier... */ token = next_token(&val, cfile); if (!is_identifier(token)) { parse_warn("expecting identifier after '.'"); if (token != SEMI) skip_to_semi(cfile); return (NULL); } /* Look up the option name hash table for the specified vendor. */ universe = ((struct universe *)hash_lookup(&universe_hash, (unsigned char *)vendor, 0)); /* If it's not there, we can't parse the rest of the declaration. */ if (!universe) { parse_warn("no vendor named %s.", vendor); skip_to_semi(cfile); return (NULL); } } else { /* Use the default hash table, which contains all the standard dhcp option names. */ val = vendor; universe = &dhcp_universe; } /* Look up the actual option info... */ option = (struct option *)hash_lookup(universe->hash, (unsigned char *)val, 0); /* If we didn't get an option structure, it's an undefined option. */ if (!option) { if (val == vendor) parse_warn("no option named %s", val); else parse_warn("no option named %s for vendor %s", val, vendor); skip_to_semi(cfile); return (NULL); } /* Free the initial identifier token. */ free(vendor); /* Parse the option data... */ do { for (fmt = option->format; *fmt; fmt++) { if (*fmt == 'A') break; switch (*fmt) { case 'X': len = parse_X(cfile, &hunkbuf[hunkix], sizeof(hunkbuf) - hunkix); hunkix += len; break; case 't': /* Text string... */ token = next_token(&val, cfile); if (token != STRING) { parse_warn("expecting string."); skip_to_semi(cfile); return (NULL); } len = strlen(val); if (hunkix + len + 1 > sizeof(hunkbuf)) { parse_warn("option data buffer %s", "overflow"); skip_to_semi(cfile); return (NULL); } memcpy(&hunkbuf[hunkix], val, len + 1); nul_term = 1; hunkix += len; break; case 'I': /* IP address. */ if (!parse_ip_addr(cfile, &ip_addr)) return (NULL); len = ip_addr.len; dp = ip_addr.iabuf; alloc: if (hunkix + len > sizeof(hunkbuf)) { parse_warn("option data buffer " "overflow"); skip_to_semi(cfile); return (NULL); } memcpy(&hunkbuf[hunkix], dp, len); hunkix += len; break; case 'L': /* Unsigned 32-bit integer... */ case 'l': /* Signed 32-bit integer... */ token = next_token(&val, cfile); if (token != NUMBER) { need_number: parse_warn("expecting number."); if (token != SEMI) skip_to_semi(cfile); return (NULL); } convert_num(buf, val, 0, 32); len = 4; dp = buf; goto alloc; case 's': /* Signed 16-bit integer. */ case 'S': /* Unsigned 16-bit integer. */ token = next_token(&val, cfile); if (token != NUMBER) goto need_number; convert_num(buf, val, 0, 16); len = 2; dp = buf; goto alloc; case 'b': /* Signed 8-bit integer. */ case 'B': /* Unsigned 8-bit integer. */ token = next_token(&val, cfile); if (token != NUMBER) goto need_number; convert_num(buf, val, 0, 8); len = 1; dp = buf; goto alloc; case 'f': /* Boolean flag. */ token = next_token(&val, cfile); if (!is_identifier(token)) { parse_warn("expecting identifier."); bad_flag: if (token != SEMI) skip_to_semi(cfile); return (NULL); } if (!strcasecmp(val, "true") || !strcasecmp(val, "on")) buf[0] = 1; else if (!strcasecmp(val, "false") || !strcasecmp(val, "off")) buf[0] = 0; else { parse_warn("expecting boolean."); goto bad_flag; } len = 1; dp = buf; goto alloc; default: warning("Bad format %c in parse_option_param.", *fmt); skip_to_semi(cfile); return (NULL); } } token = next_token(&val, cfile); } while (*fmt == 'A' && token == COMMA); if (token != SEMI) { parse_warn("semicolon expected."); skip_to_semi(cfile); return (NULL); } options[option->code].data = malloc(hunkix + nul_term); if (!options[option->code].data) error("out of memory allocating option data."); memcpy(options[option->code].data, hunkbuf, hunkix + nul_term); options[option->code].len = hunkix; return (option); }