static Method *unpack_method(cBuf *buf, Long *buf_pos) { Int i, j, n; Method *method; Int name; /* Read in the name. If this is -1, it was a marker for a blank entry. */ name = read_ident(buf, buf_pos); if (name == NOT_AN_IDENT) return NULL; method = EMALLOC(Method, 1); method->name = name; method->m_access = read_long(buf, buf_pos); method->m_flags = read_long(buf, buf_pos); method->native = read_long(buf, buf_pos); method->refs = 1; method->num_args = read_long(buf, buf_pos); if (method->num_args) { method->argnames = TMALLOC(Int, method->num_args); for (i = 0; i < method->num_args; i++) { method->argnames[i] = read_long(buf, buf_pos); } } method->rest = read_long(buf, buf_pos); method->num_vars = read_long(buf, buf_pos); if (method->num_vars) { method->varnames = TMALLOC(Int, method->num_vars); for (i = 0; i < method->num_vars; i++) { method->varnames[i] = read_long(buf, buf_pos); } } method->num_opcodes = read_long(buf, buf_pos); method->opcodes = TMALLOC(Long, method->num_opcodes); for (i = 0; i < method->num_opcodes; i++) method->opcodes[i] = read_long(buf, buf_pos); method->num_error_lists = read_long(buf, buf_pos); if (method->num_error_lists) { method->error_lists = TMALLOC(Error_list, method->num_error_lists); for (i = 0; i < method->num_error_lists; i++) { n = read_long(buf, buf_pos); method->error_lists[i].num_errors = n; method->error_lists[i].error_ids = TMALLOC(Int, n); for (j = 0; j < n; j++) method->error_lists[i].error_ids[j] = read_ident(buf, buf_pos); } } return method; }
extern void do_set (void) { char *mac; char c; char temp[64]; mac = read_ident(); if (! mac) { err_head(); fprintf(stderr, "@set: missing/illegal macro name\n"); return ; } if (! in_false_if()) { char *cp; c = getnonspace(); if (c != '(') { err_head(); fprintf(stderr, "@set must have ()s\n"); Push(c); return ; } os_sprintf(temp, "%d", eval_expr(0, 1)); undef(mac); cp = copyofstr(temp); check_os_malloc(cp); define(mac, -1, (unsigned char *) cp, DEF_DEFINE); } os_free(mac); }
void unpack_object(cBuf *buf, Long *buf_pos, Obj *obj) { obj->parents = unpack_list(buf, buf_pos); obj->children = unpack_list(buf, buf_pos); unpack_vars(buf, buf_pos, obj); unpack_methods(buf, buf_pos, obj); obj->objname = read_ident(buf, buf_pos); }
void unpack_handled (cBuf *buf, Long *buf_pos, cData *d) { HandledFrob *h=TMALLOC(HandledFrob, 1); h->cclass = read_long(buf, buf_pos); unpack_data (buf, buf_pos, &h->rep); h->handler = read_ident(buf, buf_pos); d->u.instance = (void*) h; }
static void unpack_idents(cBuf *buf, Long *buf_pos, Obj *obj) { Int i; obj->methods->idents_size = read_long(buf, buf_pos); obj->methods->num_idents = read_long(buf, buf_pos); obj->methods->idents = EMALLOC(Ident_entry, obj->methods->idents_size); for (i = 0; i < obj->methods->num_idents; i++) { obj->methods->idents[i].id = read_ident(buf, buf_pos); if (obj->methods->idents[i].id != NOT_AN_IDENT) obj->methods->idents[i].refs = read_long(buf, buf_pos); } }
static void unpack_vars(cBuf *buf, Long *buf_pos, Obj *obj) { Int i; obj->vars.size = read_long(buf, buf_pos); obj->vars.blanks = read_long(buf, buf_pos); obj->vars.hashtab = EMALLOC(Int, obj->vars.size); obj->vars.tab = EMALLOC(Var, obj->vars.size); for (i = 0; i < obj->vars.size; i++) { obj->vars.hashtab[i] = read_long(buf, buf_pos); obj->vars.tab[i].name = read_ident(buf, buf_pos); if (obj->vars.tab[i].name != NOT_AN_IDENT) { obj->vars.tab[i].cclass = read_long(buf, buf_pos); unpack_data(buf, buf_pos, &obj->vars.tab[i].val); } obj->vars.tab[i].next = read_long(buf, buf_pos); } }
extern void do_undef (int sharp) { char *mac; if (! in_false_if()) { mac = read_ident(); if (! mac) { err_head(); fprintf(stderr, "missing/illegal macro name\n"); } else { undef (mac); } } if (sharp) { flush_sharp_line(); } }
void do_ifndef (int sharp) { char *w; #ifdef DEBUG_IF if (debugging) { outputc('<'); outputc(sharp ? '#' : '@'); outputs("ifndef: "); // fflush(outfile); } #endif if (in_false_if()) { n_skipped_ifs ++; #ifdef DEBUG_IF if (debugging) { outputs("in-false, skipped>"); // fflush(outfile); } #endif } else { w = read_ident(); if (! w) { #ifdef DEBUG_IF if (debugging) { outputs("no ident "); // fflush(outfile); } #endif iftrue(); } else { #ifdef DEBUG_IF if (debugging) { outputs(w); outputc(' '); // fflush(outfile); } #endif if (find_def(w)) { iffalse(); } else { iftrue(); } os_free(w); } #ifdef DEBUG_IF if (debugging) { outputc('>'); // fflush(outfile); } #endif } if (sharp) { flush_sharp_line(); } }
/* flags: only XML_IGNORE_CASE is handled */ void css_parse_style_sheet(CSSStyleSheet *s, CSSParseState *b) { char value[1024]; char tag[64]; char tag_id[64]; char *q; int ch, media, val, last_tree_op, i; CSSStyleSheetEntry *e, **first_eprops; CSSSimpleSelector ss2, *ss = &ss2, *last_ss, *ss1; CSSProperty *props; ch = bgetc(b); media = CSS_MEDIA_ALL; for (;;) { redo: first_eprops = s->plast_entry; bskip_spaces(b, &ch); if (ch == EOF) break; /* eat inserted HTML comments for compatible STYLE tag parsing */ if (ch == '<') { beat(b, &ch, "<!--"); goto redo; } else if (ch == '-') { beat(b, &ch, "-->"); goto redo; } /* handle '@media { ... }' */ if (ch == '@') { ch = bgetc(b); read_ident(b, &ch, tag, sizeof(tag)); switch (css_get_enum(tag, "media,page")) { case 0: /* @media */ media = 0; for (;;) { bskip_spaces(b, &ch); read_ident(b, &ch, tag, sizeof(tag)); val = css_get_enum(tag, "tty,screen,print,tv,speech,all"); if (val < 0 || val == 5) media = CSS_MEDIA_ALL; else media |= (1 << val); bskip_spaces(b, &ch); if (ch == ',') { ch = bgetc(b); } else if (ch == '{' || ch == EOF) { ch = bgetc(b); break; } } goto redo; case 1: /* @page */ bskip_spaces(b, &ch); if (ch != '{') { read_ident(b, &ch, tag_id, sizeof(tag_id)); bskip_spaces(b, &ch); } memset(ss, 0, sizeof(CSSSimpleSelector)); ss->tag = css_new_ident("@page"); if (tag_id[0] != '\0') ss->tag_id = css_new_ident(tag_id); add_style_entry(s, ss, media); goto parse_props; default: css_error1(b, "unrecognized css directive '@%s'", tag); break; } } else if (ch == '}') { /* XXX: end of media, should unstack */ ch = bgetc(b); goto redo; } /* parse a selector list */ for (;;) { /* parse simple selectors with operations */ last_ss = NULL; last_tree_op = CSS_TREE_OP_NONE; for (;;) { int tree_op; bskip_spaces(b, &ch); parse_simple_selector(ss, b, &ch); bskip_spaces(b, &ch); ss->tree_op = last_tree_op; ss->next = last_ss; if (ch == '+') { tree_op = CSS_TREE_OP_PRECEEDED; ch = bgetc(b); goto add_tree; } else if (ch == '>') { tree_op = CSS_TREE_OP_CHILD; ch = bgetc(b); goto add_tree; } else if (isalpha(ch)) { tree_op = CSS_TREE_OP_DESCENDANT; add_tree: ss1 = malloc(sizeof(CSSSimpleSelector)); if (ss1) { memcpy(ss1, ss, sizeof(CSSSimpleSelector)); last_ss = ss1; } last_tree_op = tree_op; } else { /* other char: exit */ break; } } add_style_entry(s, ss, media); /* get next selector, if present */ if (ch != ',') break; ch = bgetc(b); } parse_props: /* expect start of properties */ if (ch != '{') break; ch = bgetc(b); q = value; while (ch != '}' && ch != EOF) { if ((q - value) < (int)sizeof(value) - 1) *q++ = ch; ch = bgetc(b); } *q = '\0'; if (ch == '}') ch = bgetc(b); /* the properties are extracted, now add them to each tag */ /* XXX: should locate entries first, then add, to avoid adding duplicate entries */ /* XXX: should put font properties first to avoid em/ex units problems, but it would still not be sufficient. */ props = css_parse_properties(b, value); i = 0; for (e = *first_eprops; e != NULL; e = e->next) { if (i == 0) e->props = props; else e->props = dup_properties(props); i++; } } #ifdef DEBUG css_dump_style_sheet(s); #endif }
static void parse_simple_selector(CSSSimpleSelector *ss, CSSParseState *b, int *ch_ptr) { char value[1024]; char tag[64]; char tag_id[64]; char attribute[64]; int ch, pclass, val; CSSStyleSheetAttributeEntry *first_attr, **last_attr; ch = *ch_ptr; /* read the tag */ first_attr = NULL; last_attr = &first_attr; tag[0] = '\0'; tag_id[0] = '\0'; pclass = 0; read_ident(b, &ch, tag, sizeof(tag)); if (b->ignore_case) css_strtolower(tag, sizeof(tag)); /* read '.class', '[xxx]', ':pseudo-class' */ for (;;) { bskip_spaces(b, &ch); if (ch == '.') { /* read the class and add it as an attribute */ ch = bgetc(b); read_ident(b, &ch, value, sizeof(value)); add_attribute(&last_attr, CSS_ID_class, CSS_ATTR_OP_EQUAL, value); } else if (ch == '#') { /* read the id */ ch = bgetc(b); read_ident(b, &ch, tag_id, sizeof(tag_id)); } else if (ch == '[') { /* read the attribute */ int op; ch = bgetc(b); read_ident(b, &ch, attribute, sizeof(attribute)); if (b->ignore_case) css_strtolower(attribute, sizeof(attribute)); switch (ch) { case '~': op = CSS_ATTR_OP_IN_LIST; ch = bgetc(b); goto get_value; case '=': op = CSS_ATTR_OP_EQUAL; goto get_value; case '|': op = CSS_ATTR_OP_IN_HLIST; ch = bgetc(b); get_value: ch = bgetc(b); if (ch == '\"' || ch == '\'') { read_string(b, &ch, value, sizeof(value)); } else { read_ident(b, &ch, value, sizeof(value)); } break; case ']': op = CSS_ATTR_OP_SET; value[0] = '\0'; break; default: dprintf("op: incorrect char '%c'\n", ch); return; /* cannot do more */ } if (ch == ']') ch = bgetc(b); add_attribute(&last_attr, css_new_ident(attribute), op, value); } else if (ch == ':') { ch = bgetc(b); read_ident(b, &ch, value, sizeof(value)); val = css_get_enum(value, "first-child,link,visited,active,hover,focus,first-line,first-letter,before,after"); if (val >= 0) pclass |= 1 << val; } else { break; } } memset(ss, 0, sizeof(CSSSimpleSelector)); if (tag[0] == '\0') { ss->tag = CSS_ID_ALL; } else { ss->tag = css_new_ident(tag); } if (tag_id[0] != '\0') { /* XXX: not fully correct, but good enough for now */ add_attribute(&last_attr, CSS_ID_id, CSS_ATTR_OP_EQUAL, value); /* we also add the id, just in case we use it in the futur */ ss->tag_id = css_new_ident(tag_id); } ss->attrs = first_attr; ss->pclasses = pclass; *ch_ptr = ch; }
void unpack_data(cBuf *buf, Long *buf_pos, cData *data) { data->type = read_long(buf, buf_pos); switch (data->type) { case INTEGER: data->u.val = read_long(buf, buf_pos); break; case FLOAT: data->u.fval = read_float(buf, buf_pos); break; case STRING: data->u.str = string_unpack(buf, buf_pos); break; case OBJNUM: data->u.objnum = read_long(buf, buf_pos); break; case LIST: data->u.list = unpack_list(buf, buf_pos); break; case SYMBOL: data->u.symbol = read_ident(buf, buf_pos); break; case T_ERROR: data->u.error = read_ident(buf, buf_pos); break; case FROB: data->u.frob = TMALLOC(cFrob, 1); data->u.frob->cclass = read_long(buf, buf_pos); unpack_data(buf, buf_pos, &data->u.frob->rep); break; case DICT: data->u.dict = unpack_dict(buf, buf_pos); break; case BUFFER: { Int len; len = read_long(buf, buf_pos); data->u.buffer = buffer_new(len); data->u.buffer->len = len; MEMCPY(data->u.buffer->s, &(buf->s[*buf_pos]), len); (*buf_pos) += len; break; } #ifdef USE_PARENT_OBJS case OBJECT: break; #endif default: { INSTANCE_RECORD(data->type, r); r->unpack(buf, buf_pos, data); } } }
static Token *read_token_int(void) { int c = getc_nonspace(); switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': return read_number(c); case '"': return read_string(); case '\'': return read_char(); case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_': return read_ident(c); case '/': case '=': case '*': case '+': case '-': case '(': case ')': case ',': case ';': return make_punct(c); case EOF: return NULL; default: error("Unexpected character: '%c'", c); } }
static Token *read_token_int(void) { int c = getc_nonspace(); switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': return read_number(c); case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_': return read_ident(c); case '*': case '/': case '(': case ')': case ',': case ';': case '[': case ']': case '{': case '}': case '<': case '>': case '!': case '?': case ':': case '.': return make_punct(c); case '-': c = getc(stdin); if (c == '-') return make_punct(PUNCT_DEC); if (c == '>') return make_punct(PUNCT_ARROW); ungetc(c, stdin); return make_punct('-'); case '=': return read_rep('=', '=', PUNCT_EQ); case '+': return read_rep('+', '+', PUNCT_INC); case '&': return read_rep('&', '&', PUNCT_LOGAND); case '|': return read_rep('|', '|', PUNCT_LOGOR); case '"': return read_string(); case '\'': return read_char(); case EOF: return NULL; default: error("Unexpected character: '%c'", c); } }
static EORB_CPP_node *read_expr_10 (void) { char c; char *w; EORB_CPP_node *n; #ifdef DEBUG_EXPR if (debugging) { outputs("~E10:"); } #endif while (1) { c = getnhsexpand(); switch (c) { case '-': case '~': case '!': #ifdef DEBUG_EXPR if (debugging) { outputc(c); } #endif n = read_expr_10(); #ifdef DEBUG_EXPR if (debugging) { outputs("~"); } #endif return (newnode(0, c, n)); break; case 'd': Push(c); input_mark(); w = read_ident(); if (strcmp(w, "defined") == 0) { c = getnonspace(); if (c == '(') { char *id; id = read_ident(); if (id) { c = getnonspace(); if (c == ')') { input_unmark(); #ifdef DEBUG_EXPR if (debugging) { outputs("ifdef"); } #endif return (newname(id)); } } } else if (isbsymchar(c)) { char *id; Push(c); id = read_ident(); if (id) { input_unmark(); #ifdef DEBUG_EXPR if (debugging) { outputs("ifdef"); } #endif return (newname(id)); } } } input_recover(); n = read_expr_11(); #ifdef DEBUG_EXPR if (debugging) { outputs("~"); } #endif return (n); break; default: Push(c); n = read_expr_11(); #ifdef DEBUG_EXPR if (debugging) { outputs("~"); } #endif return (n); break; } } }
static EORB_CPP_node *read_expr_11 (void) { char c; #ifdef DEBUG_EXPR if (debugging) { outputs("~E11:"); } #endif while (1) { c = getnhsexpand(); if (c == '(') { EORB_CPP_node *n; #ifdef DEBUG_EXPR if (debugging) { outputs("()"); } #endif n = read_expr_(); c = getnhsexpand(); if (c != ')') { err_head(); fprintf(stderr, "expression syntax error -- missing ) supplied\n"); Push(c); } #ifdef DEBUG_EXPR if (debugging) { outputs("~"); } #endif return (n); } else if (isdigit((int) c)) { int base; static char digits[] = "0123456789abcdefABCDEF"; static char values[] = "\0\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\12\13\14\15\16\17"; char *d; int v; #ifdef DEBUG_EXPR if (debugging) { outputs("N"); } #endif base = 10; if (c == '0') { base = 8; c = Get(); if ((c == 'x') || (c == 'X')) { base = 16; c = Get(); } } v = 0; while (1) { d = strchr(digits, c); if (d == 0) { Push(c); #ifdef DEBUG_EXPR if (debugging) { outputd(v); outputs("~"); } #endif return (newleaf(v)); } else if (values[d -digits] >= base) { err_head(); fprintf(stderr, "warning: illegal %sdigit `%c'\n", (base == 16) ? "hex " : (base == 8) ? "octal " : "", c); } v = (v * base) + values[d - digits]; c = Get(); } } else if (c == '\'') { int i; int j; int n; i = 0; n = 0; while (1) { j = get_quote_char(); if (j < 0) { break; } i = (i << 8) | j; n ++; } if (n > 4) { err_head(); fprintf(stderr, "warning: too many characters in character constant\n"); } return (newleaf(i)); } else if ((c == '\n') && !sharp) {} else { char *id; if (complain) { err_head(); fprintf(stderr, "expression syntax error -- number expected\n"); } if (isbsymchar(c)) { Push(c); id = read_ident(); } else { id = 0; } #ifdef DEBUG_EXPR if (debugging) { outputs("0("); outputc(c); outputs(":"); outputs(id ? id : "(none)"); outputs(")~"); } #endif if (id) { os_free(id); } return (newleaf(0)); } } }