自学教程：C++ strim函数代码示例

struct sint sadd(const struct sint *a, const struct sint *b) {  struct sint r, acp = *a, bcp = *b;  strim(&acp);  strim(&bcp);  for (int i = 0; i < MAX_DIGITS; i++)    r.digits[i] = '0';  r.digits[MAX_DIGITS] = '/0';    int lena = strlen(acp.digits);  int lenb = strlen(bcp.digits);  int carry = 0;  for (int i = 0; i < MAX_DIGITS; ++i) {    int cur = 0;    if (i < lena)      cur += acp.digits[lena - 1 - i] - '0';    if (i < lenb)      cur += bcp.digits[lenb - 1 - i] - '0';    cur += carry;    carry = cur / 10;    cur %= 10;    r.digits[MAX_DIGITS - 1 - i] = '0' + cur;  }    strim(&r);  return r;}

static int bcm47xx_get_invariants(struct ssb_bus *bus,				  struct ssb_init_invariants *iv){	char buf[20];	int len, err;	/* Fill boardinfo structure */	memset(&iv->boardinfo, 0 , sizeof(struct ssb_boardinfo));	len = bcm47xx_nvram_getenv("boardvendor", buf, sizeof(buf));	if (len > 0) {		err = kstrtou16(strim(buf), 0, &iv->boardinfo.vendor);		if (err)			pr_warn("Couldn't parse nvram board vendor entry with value /"%s/"/n",				buf);	}	if (!iv->boardinfo.vendor)		iv->boardinfo.vendor = SSB_BOARDVENDOR_BCM;	len = bcm47xx_nvram_getenv("boardtype", buf, sizeof(buf));	if (len > 0) {		err = kstrtou16(strim(buf), 0, &iv->boardinfo.type);		if (err)			pr_warn("Couldn't parse nvram board type entry with value /"%s/"/n",				buf);	}	memset(&iv->sprom, 0, sizeof(struct ssb_sprom));	bcm47xx_fill_sprom(&iv->sprom, NULL, false);	if (bcm47xx_nvram_getenv("cardbus", buf, sizeof(buf)) >= 0)		iv->has_cardbus_slot = !!simple_strtoul(buf, NULL, 10);	return 0;}

/* * read_file_line - read a line from a file * * Used to compose a filename from a printf format and to read a line from this * file. All leading and trailing whitespaces (including line endings) are * removed. The returned buffer must be freed with free(). This function is * supposed for reading variable like content into a buffer, so files > 1024 * bytes are ignored. */char *read_file_line(const char *fmt, ...){	va_list args;	char *filename;	char *buf, *line = NULL;	size_t size;	int ret;	struct stat s;	va_start(args, fmt);	filename = bvasprintf(fmt, args);	va_end(args);	ret = stat(filename, &s);	if (ret)		goto out;	if (s.st_size > 1024)		goto out;	buf = read_file(filename, &size);	if (!buf)		goto out;	line = strim(buf);	line = xstrdup(line);	free(buf);out:	free(filename);	return line;}

/*    Test if the version is acceptable based on the supplied critera.    The acceptable formats for criteria are:    VER                             Allows prereleases    1.2.[*xX]                       Wild card version portion. (allows prereleases).    ~VER                            Compatible with VER at the least significant level.                                    ~1.2.3 == (>=1.2.3 <1.3.0) Compatible at the patch level                                    ~1.2 == 1.2.x   Compatible at the minor level                                    ~1 == 1.x   Compatible at the major level    ^VER                            Compatible with VER at the most significant level.                                    ^0.2.3 == 0.2.3 <= VER < 0.3.0                                    ^1.2.3 == 1.2.3 <= VER < 2.0.0    [>, >=, <, <=, ==, !=]VER       Create range relative to given version    EXPR1 - EXPR2                   <=EXPR1 <=EXPR2    EXPR1 || EXPR2 ...              EXPR1 OR EXPR2    EXPR1 && EXPR2 ...              EXPR1 AND EXPR2    EXPR1 EXPR2 ...                 EXPR1 AND EXPR2    Pre-release versions will only match if the criteria contains a "-.*" prerelease suffix*/PUBLIC bool mprIsVersionObjAcceptable(MprVersion *vp, cchar *criteria){    char        *expr, *exprTok, *range, *rangeTok, *low, *high;    bool        allMatched;    if (!vp->ok) {        return 0;    }    if (!criteria || *criteria == '/0') {        return 1;    }    criteria = cleanVersion(criteria);    for (range = (char*) criteria; stok(range, "||", &rangeTok) != 0; range = rangeTok) {        range = strim(range, " /t", 0);        allMatched = 1;        for (expr = (char*) range; sptok(expr, "&&", &exprTok) != 0; expr = exprTok) {            if (scontains(expr, " - ")) {                low = sptok(expr, " - ", &high);                return inRange(vp, sjoin(">=", low, NULL)) && inRange(vp, sjoin("<=", high, NULL));            }            if (!inRange(vp, expr)) {                allMatched = 0;                break;            }        }        if (allMatched) {            return 1;        }    }    return 0;}

static ssize_t table_write(struct file *file,	const char __user *userbuf, size_t count, loff_t *ppos){	char buf[80];	int table_idx;	unsigned int cpu_freq;	int core_cap_level;	if (sizeof(buf) <= count)		return -EINVAL;	if (copy_from_user(buf, userbuf, count))		return -EFAULT;	/* terminate buffer and trim - white spaces may be appended	 *  at the end when invoked from shell command line */	buf[count] = '/0';	strim(buf);	if (sscanf(buf, "[%d] = %u %d",		   &table_idx, &cpu_freq, &core_cap_level) != 3)		return -1;	if ((table_idx < 0) || (table_idx >= ARRAY_SIZE(throttle_table)))		return -EINVAL;	/* round new settings before updating table */	throttle_table[table_idx].cpu_freq = clip_to_table(cpu_freq);	throttle_table[table_idx].core_cap_level = (core_cap_level / 50) * 50;	return count;}

/*    Check if the layout has changed. Returns false if the layout does not exist. */static bool layoutIsStale(EspRoute *eroute, cchar *source, cchar *module){    char    *data, *lpath, *quote;    cchar   *layout, *layoutsDir;    ssize   len;    bool    stale;    int     recompile;    stale = 0;    layoutsDir = httpGetDir(eroute->route, "LAYOUTS");    if ((data = mprReadPathContents(source, &len)) != 0) {        if ((lpath = scontains(data, "@ layout /"")) != 0) {            lpath = strim(&lpath[10], " ", MPR_TRIM_BOTH);            if ((quote = schr(lpath, '"')) != 0) {                *quote = '/0';            }            layout = (layoutsDir && *lpath) ? mprJoinPath(layoutsDir, lpath) : 0;        } else {            layout = (layoutsDir) ? mprJoinPath(layoutsDir, "default.esp") : 0;        }        if (layout) {            stale = espModuleIsStale(layout, module, &recompile);            if (stale) {                mprLog("info esp", 4, "esp layout %s is newer than module %s", layout, module);            }        }    }    return stale;}

static ssize_t consumer_unregister_store(const char *s, size_t count){	char name[SYSEDP_NAME_LEN];	size_t n;	struct sysedp_consumer *consumer;	n = count > SYSEDP_NAME_LEN - 1 ? SYSEDP_NAME_LEN - 1 : count;	strncpy(name, s, n);	name[n] = 0;	consumer = sysedp_get_consumer(strim(name));	if (!consumer)		return -EINVAL;	if (!consumer->removable)		return -EINVAL;	sysedp_unregister_consumer(consumer);	kfree(consumer->states);	kfree(consumer->ocpeaks);	kfree(consumer);	return count;}

/* Special entry to just crash directly. Available without KPROBEs */static ssize_t direct_entry(struct file *f, const char __user *user_buf,		size_t count, loff_t *off){	enum ctype type;	char *buf;	if (count >= PAGE_SIZE)		return -EINVAL;	if (count < 1)		return -EINVAL;	buf = (char *)__get_free_page(GFP_KERNEL);	if (!buf)		return -ENOMEM;	if (copy_from_user(buf, user_buf, count)) {		free_page((unsigned long) buf);		return -EFAULT;	}	/* NULL-terminate and remove enter */	buf[count] = '/0';	strim(buf);	type = parse_cp_type(buf, count);	free_page((unsigned long) buf);	if (type == CT_NONE)		return -EINVAL;	pr_info("Performing direct entry %s/n", cp_type_to_str(type));	lkdtm_do_action(type);	*off += count;	return count;}

static ssize_t do_register_entry(enum cname which, struct file *f,		const char __user *user_buf, size_t count, loff_t *off){	char *buf;	int err;	if (count >= PAGE_SIZE)		return -EINVAL;	buf = (char *)__get_free_page(GFP_KERNEL);	if (!buf)		return -ENOMEM;	if (copy_from_user(buf, user_buf, count)) {		free_page((unsigned long) buf);		return -EFAULT;	}	/* NULL-terminate and remove enter */	buf[count] = '/0';	strim(buf);	cptype = parse_cp_type(buf, count);	free_page((unsigned long) buf);	if (cptype == CT_NONE)		return -EINVAL;	err = lkdtm_register_cpoint(which);	if (err < 0)		return err;	*off += count;	return count;}

static ssize_tset_otg_mode(struct device *dev, struct device_attribute *attr,				const char *buf, size_t count){	struct mv_otg *mvotg = dev_get_drvdata(dev);	char *usage = "Usage: $echo host/client to switch otg mode";	char buff[16], *b;	BUG_ON(mvotg != the_transceiver);	strncpy(buff, buf, sizeof(buff));	b = strim(buff);	pr_info("OTG state is %s/n", state_string[mvotg->otg.state]);	if (!strcmp(b, "host")) {		if (mvotg->otg.state == OTG_STATE_B_PERIPHERAL) {			pr_err("Failed to swich mode, pls don't connect to PC!/n");			return count;		}		otg_force_host_mode = 1;	} else if (!strcmp(b, "client")) {		otg_force_host_mode = 0;	} else {		pr_err("%s/n", usage);		return count;	}	mv_otg_run_state_machine(mvotg, 0);	return count;}

static int diag224_idx2name(int index, char *name){	memcpy(name, diag224_cpu_names + ((index + 1) * DIAG204_CPU_NAME_LEN),	       DIAG204_CPU_NAME_LEN);	name[DIAG204_CPU_NAME_LEN] = 0;	strim(name);	return 0;}

int AGITool_Init(AGI_TOOLS *tool){	char buffer[1024], *field, *value;		// open stdin	tool->in = stdin;		// open stdout	tool->out = stdout;		/*    * Often contains any/all of the following:    *   agi_network - value is yes if this is a fastagi    *   agi_network_script - name of the script to execute    *   agi_request - name of agi script    *   agi_channel - current channel    *   agi_language - current language    *   agi_type - channel type (SIP, ZAP, IAX, ...)    *   agi_uniqueid - unique id based on unix time    *   agi_callerid - callerID string    *   agi_dnid - dialed number id    *   agi_rdnis - referring DNIS number    *   agi_context - current context    *   agi_extension - extension dialed    *   agi_priority - current priority    *   agi_enhanced - value is 1.0 if started as an EAGI script    *   agi_accountcode - set by SetAccount in the dialplan    */		// read the request	tool->agi_vars=tool->settings=NULL;		if ( fgets(buffer,sizeof(buffer),stdin) ) {		while(strcmp(buffer, "/n") != 0) {			field=buffer;			value=strchr(buffer,':');			if (value) {				value[0]=0;				value+=2;				strim(value);				tool->agi_vars = AGITool_ListAddItem(tool->agi_vars, field,value);			}				if ( !fgets(buffer,sizeof(buffer),stdin) ) {				// if failed, may have lost pipe, but sigpipe is blocked.				break;			}		}	}		// These could be configured in an ini...	tool->settings = AGITool_ListAddItem(tool->settings, "tmpdir","/tmp/");	tool->settings = AGITool_ListAddItem(tool->settings, "festival_text2wave","text2wave");	tool->settings = AGITool_ListAddItem(tool->settings, "cepstral_swift","swift");	return 0;}

/** * hname_tail - find the last component of an hname * @name: hname to find the base profile name component of  (NOT NULL) * * Returns: the tail (base profile name) name component of an hname */static const char *hname_tail(const char *hname){	char *split;	hname = strim((char *)hname);	for (split = strstr(hname, "//"); split; split = strstr(hname, "//"))		hname = split + 2;	return hname;}

PUBLIC bool websProcessUploadData(Webs *wp){    char    *line, *nextTok;    ssize   len, nbytes;    bool    canProceed;    line = 0;    canProceed = 1;     while (canProceed && !wp->finalized && wp->uploadState != UPLOAD_CONTENT_END) {        if  (wp->uploadState == UPLOAD_BOUNDARY || wp->uploadState == UPLOAD_CONTENT_HEADER) {            /*                Parse the next input line             */            line = wp->input.servp;            if ((nextTok = memchr(line, '/n', bufLen(&wp->input))) == 0) {                /* Incomplete line */                canProceed = 0;                break;            }            *nextTok++ = '/0';            nbytes = nextTok - line;            websConsumeInput(wp, nbytes);            strim(line, "/r", WEBS_TRIM_END);            len = strlen(line);            if (line[len - 1] == '/r') {                line[len - 1] = '/0';            }        }        switch (wp->uploadState) {        case 0:            initUpload(wp);            break;        case UPLOAD_BOUNDARY:            processContentBoundary(wp, line);            break;        case UPLOAD_CONTENT_HEADER:            processUploadHeader(wp, line);            break;        case UPLOAD_CONTENT_DATA:            canProceed = processContentData(wp);            if (bufLen(&wp->input) < wp->boundaryLen) {                /*  Incomplete boundary - return to get more data */                canProceed = 0;            }            break;        case UPLOAD_CONTENT_END:            break;        }    }    bufCompact(&wp->input);    return canProceed;}

int main(void) {	char in = 0;	int digit = 0;	struct sint current;	struct sint max;	max.digits[0]=0;	struct sint min;	for (int i=0; i<51; i++){		min.digits[i]='9';	}	struct sint acc;	acc.digits[0]=0;		while (scanf("%c", &in)!=EOF){		if (in > '9' || in < '0'){			current.digits[digit] = 0;			acc = sadd(&current, &acc);			if (scomp(&current, &max)==1) {				max = current;			}			if (scomp(&min, &current)==1) {				min = current;			}			digit = 0;			for (int i=0; i<51; i++){				current.digits[i]=0;			}		}		else {			current.digits[digit] = in;			digit++;		}	}	strim(&min);	strim(&max);	strim(&acc);	printf("min:%s/n", min.digits);	printf("max:%s/n", max.digits);	printf("sum:%s/n", acc.digits);}

static inline void part_hdr__part_name(enum diag204_format type, void *hdr,				       char *name){	if (type == DIAG204_INFO_SIMPLE)		memcpy(name, ((struct diag204_part_hdr *)hdr)->part_name,		       DIAG204_LPAR_NAME_LEN);	else /* DIAG204_INFO_EXT */		memcpy(name, ((struct diag204_x_part_hdr *)hdr)->part_name,		       DIAG204_LPAR_NAME_LEN);	EBCASC(name, DIAG204_LPAR_NAME_LEN);	name[DIAG204_LPAR_NAME_LEN] = 0;	strim(name);}

static char *cleanVersion(cchar *version) {    char    *cp;    cp = strim(version, " /tv=", 0);    if (schr(cp, 'X')) {        cp = sreplace(cp, "X", "x");    }    if (schr(cp, '*')) {        cp = sreplace(cp, "*", "x");    }    return cp;}

static int edp_reg_override_write(struct file *file,	const char __user *userbuf, size_t count, loff_t *ppos){	char buf[32], *end;	unsigned int edp_reg_override_mA_temp;	unsigned int edp_reg_override_mA_prev = edp_reg_override_mA;	if (sizeof(buf) <= count)		goto override_err;	if (copy_from_user(buf, userbuf, count))		goto override_err;	/* terminate buffer and trim - white spaces may be appended	 *  at the end when invoked from shell command line */	buf[count]='/0';	strim(buf);	edp_reg_override_mA_temp = simple_strtoul(buf, &end, 10);	if (*end != '/0')		goto override_err;	if (edp_reg_override_mA_temp >= regulator_cur)		goto override_err;	if (edp_reg_override_mA == edp_reg_override_mA_temp)		return count;	edp_reg_override_mA = edp_reg_override_mA_temp;	if (init_cpu_edp_limits_calculated()) {		/* Revert to previous override value if new value fails */		edp_reg_override_mA = edp_reg_override_mA_prev;		goto override_err;	}	if (tegra_cpu_set_speed_cap(NULL)) {		pr_err("FAILED: Set CPU freq cap with new VDD_CPU EDP table/n");		goto override_out;	}	pr_info("Reinitialized VDD_CPU EDP table with regulator current limit"			" %u mA/n", regulator_cur - edp_reg_override_mA);	return count;override_err:	pr_err("FAILED: Reinitialize VDD_CPU EDP table with override /"%s/"",	       buf);override_out:	return -EINVAL;}

static ssize_t mc96fr1196c_ir_send_store(struct device *dev,		struct device_attribute *attr, const char *buf, size_t size){	struct mc96fr116c_data *data = dev_get_drvdata(dev);	unsigned int value;	char *string, *pstring;	int signal_length = 2; /* By default, 2 bytes for data length */	int ir_sum = 0;	int number_freq = 0;	int ret;	if (data->mode != MC96FR116C_USER_IR_MODE) {		dev_err(&data->client->dev, "%s: Not user IR mode./n",				__func__);		return -EINVAL;	}	if (!mutex_trylock(&data->signal_mutex))		return -EBUSY;	string = (char*)kmalloc(size + 1, GFP_KERNEL);	strlcpy(string, buf, size);	pstring = strim(string);	while (pstring) {		char *curr_string;		curr_string = strsep(&pstring, " ,");		if (*curr_string == '/0')			continue;		ret = kstrtouint(curr_string, 0, &value);		if (!value)			break;		if (ret < 0) {			dev_err(dev, "Error: Invalid argument. Could not convert./n");			goto out;		}		if (signal_length == 2) {			data->carrier_freq = value;			data->signal[2] = (value >> 16) & 0xFF;			data->signal[3] = (value >> 8) & 0xFF;			data->signal[4] = value & 0xFF;			signal_length += 3;		} else {

/*    Match a keyword in the content returned from the last request    Format is:        KEYWORD = value */bool match(MprTestGroup *gp, char *key, char *value){    char    *vp, *trim;    vp = lookupValue(gp, key);    if (vp == 0 && value == 0) {        return 1;    }    trim = strim(vp, "/"", MPR_TRIM_BOTH);    if (vp == 0 || value == 0 || scmp(trim, value) != 0) {        mprLog("appweb test match", 0, "Match %s failed. Got /"%s/" expected /"%s/"", key, vp, value);        mprLog("appweb test match", 0, "Content %s", gp->content);        return 0;    }    return 1;}

static void int_to_ext_kekl(struct tape3592_kekl *in,			    struct tape390_kekl *out){	memset(out, 0, sizeof(*out));	if(in->flags & 0x40)		out->type = TAPE390_KEKL_TYPE_HASH;	else		out->type = TAPE390_KEKL_TYPE_LABEL;	if(in->flags & 0x80)		out->type_on_tape = TAPE390_KEKL_TYPE_HASH;	else		out->type_on_tape = TAPE390_KEKL_TYPE_LABEL;	memcpy(out->label, in->label, sizeof(in->label));	EBCASC(out->label, sizeof(in->label));	strim(out->label);}

static inline bool __split_insert_one_part(char *subject, char *begin, int32_t len, split_node_t *split_node, bool need_strim){    bool insert_ok = false;    /* begin, len */    split_node->part_len = len;    if (likely(need_strim)) {        begin = strim(begin, &(split_node->part_len));    }    if (PTR_NOT_NULL(begin) && split_node->part_len > 0) {        split_node->begin_offset = begin - subject;        insert_ok = true;    }    return insert_ok;}

static ssize_t __alt_name_store(struct device *dev, const char *buf,		const size_t len){	char *input, *pos, *alt_name, **ns_altname;	ssize_t rc;	if (is_namespace_pmem(dev)) {		struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);		ns_altname = &nspm->alt_name;	} else if (is_namespace_blk(dev)) {		struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev);		ns_altname = &nsblk->alt_name;	} else		return -ENXIO;	if (dev->driver || to_ndns(dev)->claim)		return -EBUSY;	input = kmemdup(buf, len + 1, GFP_KERNEL);	if (!input)		return -ENOMEM;	input[len] = '/0';	pos = strim(input);	if (strlen(pos) + 1 > NSLABEL_NAME_LEN) {		rc = -EINVAL;		goto out;	}	alt_name = kzalloc(NSLABEL_NAME_LEN, GFP_KERNEL);	if (!alt_name) {		rc = -ENOMEM;		goto out;	}	kfree(*ns_altname);	*ns_altname = alt_name;	sprintf(*ns_altname, "%s", pos);	rc = len;out:	kfree(input);	return rc;}

static int do_readf(int argc, char *argv[]){	unsigned char *buf = NULL, *val;	char *variable, *filename;	struct stat s;	size_t size;	int ret, i;	if (argc != 3)		return COMMAND_ERROR_USAGE;	filename = argv[1];	variable = argv[2];	ret = stat(filename, &s);	if (ret)		goto out;	if (s.st_size > 1024) {		ret = -EFBIG;		goto out;	}	buf = read_file(filename, &size);	if (!buf)		goto out;	for (i = 0; i < size; i++) {		if (!isprint(buf[i])) {			buf[i] = '/0';			break;		}	}	val = strim(buf);	ret = setenv(variable, val);out:	free(buf);	return ret;}

ssize_t read_string_list(const char *buf, const char * const list[]){	size_t i;	char *s, *d = strdup(buf);	if (!d)		return -ENOMEM;	s = strim(d);	for (i = 0; list[i]; i++)		if (!strcmp(list[i], s))			break;	free(d);	if (!list[i])		return -EINVAL;	return i;}

/*    Match a keyword an ignore case for windows */bool matchAnyCase(MprTestGroup *gp, char *key, char *value){    char    *vp, *trim;    vp = lookupValue(gp, key);    if (vp == 0 && value == 0) {        return 1;    }    trim = strim(vp, "/"", MPR_TRIM_BOTH);#if BIT_WIN_LIKE    if (vp == 0 || scaselesscmp(trim, value) != 0)#else    if (vp == 0 || value == 0 || scmp(trim, value) != 0)#endif    {        mprLog("appweb test match", 0, "Match %s failed. Got %s expected %s", key, vp, value);        return 0;    }    return 1;}

/** * aa_split_fqname - split a fqname into a profile and namespace name * @fqname: a full qualified name in namespace profile format (NOT NULL) * @ns_name: pointer to portion of the string containing the ns name (NOT NULL) * * Returns: profile name or NULL if one is not specified * * Split a namespace name from a profile name (see policy.c for naming * description).  If a portion of the name is missing it returns NULL for * that portion. * * NOTE: may modify the @fqname string.  The pointers returned point *       into the @fqname string. */char *aa_split_fqname(char *fqname, char **ns_name){	char *name = strim(fqname);	*ns_name = NULL;	if (name[0] == ':') {		char *split = strchr(&name[1], ':');		*ns_name = skip_spaces(&name[1]);		if (split) {			/* overwrite ':' with /0 */			*split = 0;			name = skip_spaces(split + 1);		} else			/* a ns name without a following profile is allowed */			name = NULL;	}	if (name && *name == 0)		name = NULL;	return name;}

static ssize_t iso_res_realize_store(struct device *dev,		struct device_attribute *attr, const char *buf, size_t size){	unsigned int bw;	unsigned int ult = 4;	char buff[50];	char *val, *s;	int ret;	struct tegra_bbc_proxy *bbc = dev_get_drvdata(dev);	strlcpy(buff, buf, sizeof(buff));	s = strim(buff);	/* first param is bw */	val = strsep(&s, ",");	ret = kstrtouint(val, 10, &bw);	if (ret) {		pr_err("invalid bw setting/n");		return -EINVAL;	}	/* second param is latency */	if (s) {		ret = kstrtouint(s, 10, &ult);		if (ret) {			pr_err("invalid latency setting/n");			return -EINVAL;		}	}	mutex_lock(&bbc->iso_lock);	bbc->last_bw = bw;	bbc->last_ult = ult;	ret = bbc_bw_request_unlocked(dev, 0, bw, ult, bbc->margin);	mutex_unlock(&bbc->iso_lock);	return ret ? ret : size;}

/*      Read input from the console (stdin) */static int consoleGets(EcStream *stream){    char    prompt[MPR_MAX_STRING], *line, *cp;    int     level;    if (stream->flags & EC_STREAM_EOL) {        return 0;    }    level = stream->compiler->state ? stream->compiler->state->blockNestCount : 0;    fmt(prompt, sizeof(prompt), "%s-%d> ", EJS_NAME, level);    mprYield(MPR_YIELD_STICKY);    line = readline(prompt);    mprResetYield();    if (line == NULL) {        stream->eof = 1;        mprPrintf("/n");        return -1;    }    cp = strim(line, "/r/n", MPR_TRIM_BOTH);    ecSetStreamBuf(stream, cp, slen(cp));    stream->flags |= EC_STREAM_EOL;    return (int) slen(cp);}

static int __init init_fssuper(void) {	struct super_block *sb;	struct block_device *bdev = NULL;		printk(KERN_INFO "Start module from here/t");	if(dev == NULL) {		printk(KERN_ERR "Device not specified");		return 0;	} 		bdev = lookup_bdev(strim(dev));		if(IS_ERR(bdev)) {			if(bdev == ERR_PTR(-EBUSY)) 			printk(KERN_ERR "Device busy/t");			printk(KERN_ERR "Couldn't lock device <%ld>", PTR_ERR(bdev));		return 0;	}		sb = get_super(bdev);	bdput(bdev);		if(IS_ERR(sb)) {		printk(KERN_ERR "Can't load sb <%ld>", PTR_ERR(sb));		return 0;	}		printk(KERN_INFO "Sucessfuly loaded sb, uuid %x /t", *(sb->s_uuid));	printk(KERN_INFO "File system : %s /t", sb->s_type->name);	printk(KERN_INFO "Device: %x, super %x", bdev, sb);	return 0;}