/* Scan a line of the specified /proc/devices FILE buffer and advance the * current file position pointer respectively. If the current line matches * the correct pattern, fill in the corresponding data into ENTRY and return 0. * Return non-zero otherwise. */ static int scan_dev_entry(struct file_buffer* file, struct proc_dev_entry* entry, int blockdev) { int rc; size_t dev_major; char* name; /* Scan for: (\s*)(\d+)(\s+)(\S+)(\.*)$ */ skip_whitespaces(file); rc = scan_number(file, &dev_major); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_name(file, &name); if (rc) return rc; skip_line(file); entry->device = makedev(dev_major, 0); entry->name = name; entry->blockdev = blockdev; return 0; }
void do_forget (void) { char name[16]; header *hd; int r; if (udfon) { output("Cannot forget functions in a function!\n"); error=720; return; } while (1) { scan_space(); scan_name(name); r=xor(name); hd=(header *)ramstart; while ((char *)hd<udfend) { if (r==hd->xor && !strcmp(hd->name,name)) break; hd=nextof(hd); } if ((char *)hd>=udfend) { output1("Function %s not found!\n",name); error=160; return; } kill_udf(name); scan_space(); if (*next!=',') break; else next++; } }
void do_do (void) { int udfold; char name[16]; char *oldnext=next,*udflineold; header *var; scan_space(); scan_name(name); if (error) return; var=searchudf(name); if (!var || var->type!=s_udf) { output("Need a udf!\n"); error=220; return; } udflineold=udfline; udfline=next=udfof(var); udfold=udfon; udfon=1; while (!error && udfon==1) { command(); if (udfon==2) break; if (test_key()==escape) { output("User interrupted!\n"); error=58; break; } } if (error) output1("Error in function %s\n",var->name); if (udfon==0) { output1("Return missing in %s!\n",var->name); error=55; } udfon=udfold; udfline=udflineold; if (udfon) next=oldnext; else { next=input_line; *next=0; } }
/* * Scan a variable */ void CTcLibParser::scan_var(const char *name, const char *val) { /* call the appropriate routine based on the variable name */ if (stricmp(name, "name") == 0) scan_name(val); else if (stricmp(name, "source") == 0) scan_source(val); else if (stricmp(name, "library") == 0) scan_library(val); else if (stricmp(name, "resource") == 0) scan_resource(val); else if (stricmp(name, "needmacro") == 0) scan_needmacro(val); else err_unknown_var(name, val); }
void do_trace(void) /**** do_trace toggles tracing or sets the trace bit of a udf. ****/ { header *f; char name[64]; scan_space(); if (!strncmp(next,"off",3)) { trace=0; next+=3; } else if (!strncmp(next,"alloff",6)) { next+=6; f=(header *)ramstart; while ((char *)f<udfend && f->type==s_udf) { f->flags&=~1; f=nextof(f); } trace=0; } else if (!strncmp(next,"on",2)) { trace=1; next+=2; } else if (*next==';' || *next==',' || *next==0) trace=!trace; else { if (*next=='"') next++; scan_name(name); if (error) return; if (*next=='"') next++; f=searchudf(name); if (!f || f->type!=s_udf) { output("Function not found!\n"); error=11021; return; } f->flags^=1; if (f->flags&1) output1("Tracing %s\n",name); else output1("No longer tracing %s\n",name); scan_space(); } if (*next==';' || *next==',') next++; }
/* Scan a line of the specified /proc/partitions FILE buffer and advance the * current file position pointer respectively. If the current line matches * the correct pattern, fill in the corresponding data into ENTRY and return 0. * Return non-zero otherwise. */ static int scan_part_entry(struct file_buffer* file, struct proc_part_entry* entry) { int rc; size_t dev_major; size_t dev_minor; size_t blockcount; char* name; /* Scan for: (\s*)(\d+)(\s+)(\d+)(\s+)(\d+)(\s+)(\S+)(\.*)$ */ skip_whitespaces(file); rc = scan_number(file, &dev_major); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_number(file, &dev_minor); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_number(file, &blockcount); if (rc) return rc; rc = skip_whitespaces(file); if (rc) return rc; rc = scan_name(file, &name); if (rc) return rc; skip_line(file); entry->device = makedev(dev_major, dev_minor); entry->blockcount = blockcount; entry->name = name; return 0; }
void do_global (void) { char name[16]; int r; header *hd; while (1) { scan_space(); scan_name(name); r=xor(name); hd=(header *)udfend; if (hd==(header *)startlocal) break; while ((char *)hd<startlocal) { if (r==hd->xor && !strcmp(hd->name,name)) break; hd=nextof(hd); } if ((char *)hd>=startlocal) { output1("Variable %s not found!\n",name); error=160; return; } newram=endlocal; hd=new_reference(hd,name); newram=endlocal=(char *)nextof(hd); scan_space(); if (*next!=',') break; else next++; } }
void do_hexdump (void) { char name[16]; unsigned char *p,*end; int i=0,j; ULONG count=0; header *hd; scan_space(); scan_name(name); if (error) return; hd=searchvar(name); if (!hd) hd=searchudf(name); if (error || hd==0) return; p=(unsigned char *)hd; end=p+hd->size; output1("\n%5lx ",count); while (p<end) { hex_out(*p++); i++; count++; if (i>=16) { i=0; string_out(p-16); output1("\n%5lx ",count); if (test_key()==escape) break; } } for (j=i; j<16; j++) output(" "); string_out(p-i); output("\n"); }
static _TKN_TYPE_ scan_Ltr(_NIL_TYPE_) { scan_name(); return _NAM_TOKEN_; }
/*= * private: * * what: parse a hierarchical option argument * arg: + char const * + pzTxt + the text to scan + * arg: + char const * + pzName + the name for the text + * arg: + size_t + nm_len + the length of "name" + * * ret_type: tOptionValue * * ret_desc: An allocated, compound value structure * * doc: * A block of text represents a series of values. It may be an * entire configuration file, or it may be an argument to an * option that takes a hierarchical value. * * If NULL is returned, errno will be set: * @itemize @bullet * @item * @code{EINVAL} the input text was NULL. * @item * @code{ENOMEM} the storage structures could not be allocated * @item * @code{ENOMSG} no configuration values were found * @end itemize =*/ LOCAL tOptionValue * optionLoadNested(char const * text, char const * name, size_t nm_len) { tOptionValue * res_val; /* * Make sure we have some data and we have space to put what we find. */ if (text == NULL) { errno = EINVAL; return NULL; } text = SPN_WHITESPACE_CHARS(text); if (*text == NUL) { errno = ENOMSG; return NULL; } res_val = AGALOC(sizeof(*res_val) + nm_len + 1, "nest args"); res_val->valType = OPARG_TYPE_HIERARCHY; res_val->pzName = (char *)(res_val + 1); memcpy(res_val->pzName, name, nm_len); res_val->pzName[nm_len] = NUL; { tArgList * arg_list = AGALOC(sizeof(*arg_list), "nest arg l"); res_val->v.nestVal = arg_list; arg_list->useCt = 0; arg_list->allocCt = MIN_ARG_ALLOC_CT; } /* * Scan until we hit a NUL. */ do { text = SPN_WHITESPACE_CHARS(text); if (IS_VAR_FIRST_CHAR(*text)) text = scan_name(text, res_val); else switch (*text) { case NUL: goto scan_done; case '<': text = scan_xml(text, res_val); if (text == NULL) goto woops; if (*text == ',') text++; break; case '#': text = strchr(text, NL); break; default: goto woops; } } while (text != NULL); scan_done:; { tArgList * al = res_val->v.nestVal; if (al->useCt == 0) { errno = ENOMSG; goto woops; } if (al->useCt > 1) sort_list(al); } return res_val; woops: AGFREE(res_val->v.nestVal); AGFREE(res_val); return NULL; }
void do_for (void) /***** do_for do a for command in a UDF. for i=value to value step value; .... ; end *****/ { int h,signum; char name[16],*jump; header *hd,*init,*end,*step; double vend,vstep; struct { header hd; double value; } rv; if (!udfon) { output("For only allowed in functions!\n"); error=57; return; } rv.hd.type=s_real; *rv.hd.name=0; rv.hd.size=sizeof(header)+sizeof(double); rv.value=0.0; scan_space(); scan_name(name); if (error) return; kill_local(name); newram=endlocal; hd=new_reference(&rv.hd,name); if (error) return; endlocal=newram=(char *)hd+hd->size; scan_space(); if (*next!='=') { output("Syntax error in for.\n"); error=71; goto end; } next++; init=scan(); if (error) goto end; init=getvalue(init); if (error) goto end; if (init->type!=s_real) { output("Startvalue must be real!\n"); error=72; goto end; } rv.value=*realof(init); scan_space(); if (strncmp(next,"to",2)) { output("Endvalue missing in for!\n"); error=73; goto end; } next+=2; end=scan(); if (error) goto end; end=getvalue(end); if (error) goto end; if (end->type!=s_real) { output("Endvalue must be real!\n"); error=73; goto end; } vend=*realof(end); scan_space(); if (!strncmp(next,"step",4)) { next+=4; step=scan(); if (error) goto end; step=getvalue(step); if (error) goto end; if (step->type!=s_real) { output("Stepvalue must be real!\n"); error=73; goto end; } vstep=*realof(step); } else vstep=1.0; signum=(vstep>=0)?1:-1; vend=vend+signum*epsilon; if (signum>0 && rv.value>vend) { scan_end(); goto end; } else if (signum<0 && rv.value<vend) { scan_end(); goto end; } newram=endlocal; scan_space(); if (*next==';' || *next==',') next++; jump=next; while (!error) { if (*next==1) { output("End missing!\n"); error=401; goto end; } h=command(); if (udfon!=1 || h==c_return) break; if (h==c_break) { scan_end(); break; } if (h==c_end) { rv.value+=vstep; if (signum>0 && rv.value>vend) break; else if (signum<0 && rv.value<vend) break; else next=jump; if (test_key()==escape) { output("User interrupted!\n"); error=1; break; } } } end : kill_local(name); }