version 2.3.0_beta

optimize PIChunkStream::readAll()
optimize PIEvaluator

CMakeLists.txt

@@ -2,9 +2,9 @@ cmake_minimum_required(VERSION 3.0)
 cmake_policy(SET CMP0017 NEW) # need include() with .cmake
 project(pip)
 set(_PIP_MAJOR    2)
-set(_PIP_MINOR    2)
+set(_PIP_MINOR    3)
-set(_PIP_REVISION 2)
+set(_PIP_REVISION 0)
-set(_PIP_SUFFIX   _alpha)
+set(_PIP_SUFFIX   _beta)
 set(_PIP_COMPANY  SHS)
 set(_PIP_DOMAIN   org.SHS)
 

libs/main/core/pichunkstream.cpp

@@ -80,11 +80,36 @@ int PIChunkStream::read() {
 }
 
 
+int PIChunkStream::peekVInt(Version version_, PIByteArray * data_, int pos, PIByteArray & hdr, uint & ret) {
+	switch (version_) {
+	case Version_1:
+		memcpy(&ret, data_->data(pos), 4);
+		return 4;
+	case Version_2: {
+		hdr.resize(4);
+		hdr.fill(uchar(0));
+		memcpy(hdr.data(), data_->data(pos), piMini(4, data_->size_s() - pos));
+		uchar hsz = 0;
+		ret = readVInt(hdr, &hsz);
+		return hsz;
+		}
+	default: break;
+	}
+	return 0;
+}
+
+
 void PIChunkStream::readAll() {
 	data_map.clear();
-	while (!atEnd()) {
+	if (!data_) return;
-		read();
+	int pos = 0, sz = data_->size_s();
-		data_map[last_id] = last_data;
+	uint csz = 0, cid = 0;
+	PIByteArray hdr;
+	while (pos < sz) {
+		pos += peekVInt((Version)version_, data_, pos, hdr, cid);
+		pos += peekVInt((Version)version_, data_, pos, hdr, csz);
+		data_map[cid] = PIPair<int, int>(pos, csz);
+		pos += csz;
 	}
 }
 
@@ -111,7 +136,7 @@ void PIChunkStream::_init() {
 }
 
 
-uint PIChunkStream::readVInt(PIByteArray & s) {
+uint PIChunkStream::readVInt(PIByteArray & s, uchar * bytes_cnt) {
 	if (s.isEmpty()) return 0;
 	uchar bytes[4]; s >> bytes[0];
 	uchar abc = 0;
@@ -122,6 +147,7 @@ uint PIChunkStream::readVInt(PIByteArray & s) {
 			s >> bytes[abc + 1];
 		} else break;
 	}
+	if (bytes_cnt) *bytes_cnt = (abc + 1);
 	uint ret = 0;
 	for (int i = 0; i <= abc; ++i) {
 		ret += (bytes[i] << (8 * ((int)abc - i)));

libs/main/core/pichunkstream.h

@@ -83,7 +83,7 @@ public:
 	//! Read one chunk from stream and returns its ID
 	int read();
 
-	//! Read all chunks from stream
+	//! Read all chunks from stream. This function just index input data
 	void readAll();
 	
 	//! Returns last readed chunk ID
@@ -100,7 +100,9 @@ public:
 	//! Place value of chunk with id \"id\" into \"v\". You should call \a readAll() before using this function!
 	template <typename T>
 	const PIChunkStream & get(int id, T & v) const {
-		PIByteArray ba = data_map.value(id);
+		PIPair<int, int> pos = data_map.value(id);
+		if (pos.first < 0 || pos.second == 0) return *this;
+		PIByteArray ba(data_->data(pos.first), pos.second);
 		if (!ba.isEmpty())
 			ba >> v;
 		return *this;
@@ -109,13 +111,14 @@ public:
 private:
 	void _init();
 	
-	static uint readVInt(PIByteArray & s);
+	static uint readVInt(PIByteArray & s, uchar * bytes = 0);
 	static void writeVInt(PIByteArray & s, uint val);
+	static int peekVInt(Version version_, PIByteArray * data_, int pos, PIByteArray & hdr, uint & ret);
 
 	int last_id;
 	uchar version_;
 	PIByteArray * data_, last_data, tmp_data;
-	PIMap<int, PIByteArray> data_map;
+	PIMap<int, PIPair<int, int>> data_map;
 	
 	template <typename T> friend PIChunkStream & operator <<(PIChunkStream & s, const PIChunkStream::Chunk<T> & c);
 	template <typename T> friend PIChunkStream & operator <<(PIChunkStream & s, const PIChunkStream::ChunkConst<T> & c);

libs/main/math/pievaluator.cpp

@@ -122,49 +122,49 @@ using namespace PIEvaluatorTypes;
 
 
 PIEvaluatorContent::PIEvaluatorContent() {
-	addFunction("arcsin", 1);
+	addFunction(PIStringAscii("arcsin" ), 1);
-	addFunction("arccos", 1);
+	addFunction(PIStringAscii("arccos" ), 1);
-	addFunction("arctg", 1);
+	addFunction(PIStringAscii("arctg"  ), 1);
-	addFunction("arcctg", 1);
+	addFunction(PIStringAscii("arcctg" ), 1);
-	addFunction("random", 2);
+	addFunction(PIStringAscii("random" ), 2);
-	addFunction("randomn", 2);
+	addFunction(PIStringAscii("randomn"), 2);
-	addFunction("sin", 1);
+	addFunction(PIStringAscii("sin"    ), 1);
-	addFunction("cos", 1);
+	addFunction(PIStringAscii("cos"    ), 1);
-	addFunction("ctg", 1);
+	addFunction(PIStringAscii("ctg"    ), 1);
-	addFunction("tg", 1);
+	addFunction(PIStringAscii("tg"     ), 1);
-	addFunction("exp", 1);
+	addFunction(PIStringAscii("exp"    ), 1);
-	addFunction("cth", 1);
+	addFunction(PIStringAscii("cth"    ), 1);
-	addFunction("sh", 1);
+	addFunction(PIStringAscii("sh"     ), 1);
-	addFunction("ch", 1);
+	addFunction(PIStringAscii("ch"     ), 1);
-	addFunction("th", 1);
+	addFunction(PIStringAscii("th"     ), 1);
-	addFunction("sqrt", 1);
+	addFunction(PIStringAscii("sqrt"   ), 1);
-	addFunction("sqr", 1);
+	addFunction(PIStringAscii("sqr"    ), 1);
-	addFunction("pow", 2);
+	addFunction(PIStringAscii("pow"    ), 2);
-	addFunction("abs", 1);
+	addFunction(PIStringAscii("abs"    ), 1);
-	addFunction("ln", 1);
+	addFunction(PIStringAscii("ln"     ), 1);
-	addFunction("lg", 1);
+	addFunction(PIStringAscii("lg"     ), 1);
-	addFunction("log", 2);
+	addFunction(PIStringAscii("log"    ), 2);
-	addFunction("im", 1);
+	addFunction(PIStringAscii("im"     ), 1);
-	addFunction("re", 1);
+	addFunction(PIStringAscii("re"     ), 1);
-	addFunction("arg", 1);
+	addFunction(PIStringAscii("arg"    ), 1);
-	addFunction("len", 1);
+	addFunction(PIStringAscii("len"    ), 1);
-	addFunction("conj", 1);
+	addFunction(PIStringAscii("conj"   ), 1);
-	addFunction("sign", 1);
+	addFunction(PIStringAscii("sign"   ), 1);
-	addFunction("rad", 1);
+	addFunction(PIStringAscii("rad"    ), 1);
-	addFunction("deg", 1);
+	addFunction(PIStringAscii("deg"    ), 1);
-	addFunction("j0", 1);
+	addFunction(PIStringAscii("j0"     ), 1);
-	addFunction("j1", 1);
+	addFunction(PIStringAscii("j1"     ), 1);
-	addFunction("jn", 2);
+	addFunction(PIStringAscii("jn"     ), 2);
-	addFunction("y0", 1);
+	addFunction(PIStringAscii("y0"     ), 1);
-	addFunction("y1", 1);
+	addFunction(PIStringAscii("y1"     ), 1);
-	addFunction("yn", 2);
+	addFunction(PIStringAscii("yn"     ), 2);
-	addFunction("min", -2); // (x0,x1,...)
+	addFunction(PIStringAscii("min"    ), -2); // (x0,x1,...)
-	addFunction("max", -2); // (x0,x1,...)
+	addFunction(PIStringAscii("max"    ), -2); // (x0,x1,...)
-	addFunction("clamp", 3); // (x,a,b) =  x < a ? a : (x > b ? b : x)
+	addFunction(PIStringAscii("clamp"  ), 3); // (x,a,b) =  x < a ? a : (x > b ? b : x)
-	addFunction("step", 2); // (x,s) =     x >= s ? 1. : 0.  (1 if 'x' >= 's', else 0)
+	addFunction(PIStringAscii("step"   ), 2); // (x,s) =     x >= s ? 1. : 0.  (1 if 'x' >= 's', else 0)
-	addFunction("mix", 3); // (x,a,b) =    a*(1.-x) + b*x    (interpolate between 'a' and 'b' linear for 'x')
+	addFunction(PIStringAscii("mix"    ), 3); // (x,a,b) =    a*(1.-x) + b*x    (interpolate between 'a' and 'b' linear for 'x')
-	addFunction("defined", 1);
+	addFunction(PIStringAscii("defined"), 1);
-	addFunction("round", 1);
+	addFunction(PIStringAscii("round"  ), 1);
 	clearCustomVariables();
 }
 
@@ -185,9 +185,9 @@ bool PIEvaluatorContent::setVariableName(int index, const PIString & new_name) {
 
 void PIEvaluatorContent::clearCustomVariables() {
 	variables.clear();
-	addVariable("i", complexd_i);
+	addVariable(PIStringAscii("i" ), complexd_i);
-	addVariable("pi", atan(1.) * 4.);
+	addVariable(PIStringAscii("pi"), atan(1.) * 4.);
-	addVariable("e", exp(1.));
+	addVariable(PIStringAscii("e" ), exp(1.));
 	cv_count = variables.size();
 }
 
@@ -203,56 +203,56 @@ void PIEvaluatorContent::sortVariables() {
 
 
 BaseFunctions PIEvaluatorContent::getBaseFunction(const PIString & name) {
-	if (name == "sin") return bfSin;
+	if (name == PIStringAscii("sin"    )) return bfSin;
-	if (name == "cos") return bfCos;
+	if (name == PIStringAscii("cos"    )) return bfCos;
-	if (name == "tg") return bfTg;
+	if (name == PIStringAscii("tg"     )) return bfTg;
-	if (name == "ctg") return bfCtg;
+	if (name == PIStringAscii("ctg"    )) return bfCtg;
-	if (name == "arcsin") return bfArcsin;
+	if (name == PIStringAscii("arcsin" )) return bfArcsin;
-	if (name == "arccos") return bfArccos;
+	if (name == PIStringAscii("arccos" )) return bfArccos;
-	if (name == "arctg") return bfArctg;
+	if (name == PIStringAscii("arctg"  )) return bfArctg;
-	if (name == "arcctg") return bfArcctg;
+	if (name == PIStringAscii("arcctg" )) return bfArcctg;
-	if (name == "exp") return bfExp;
+	if (name == PIStringAscii("exp"    )) return bfExp;
-	if (name == "random") return bfRandom;
+	if (name == PIStringAscii("random" )) return bfRandom;
-	if (name == "randomn") return bfRandomn;
+	if (name == PIStringAscii("randomn")) return bfRandomn;
-	if (name == "sh") return bfSh;
+	if (name == PIStringAscii("sh"     )) return bfSh;
-	if (name == "ch") return bfCh;
+	if (name == PIStringAscii("ch"     )) return bfCh;
-	if (name == "th") return bfTh;
+	if (name == PIStringAscii("th"     )) return bfTh;
-	if (name == "cth") return bfCth;
+	if (name == PIStringAscii("cth"    )) return bfCth;
-	if (name == "sqrt") return bfSqrt;
+	if (name == PIStringAscii("sqrt"   )) return bfSqrt;
-	if (name == "sqr") return bfSqr;
+	if (name == PIStringAscii("sqr"    )) return bfSqr;
-	if (name == "pow") return bfPow;
+	if (name == PIStringAscii("pow"    )) return bfPow;
-	if (name == "abs") return bfAbs;
+	if (name == PIStringAscii("abs"    )) return bfAbs;
-	if (name == "ln") return bfLn;
+	if (name == PIStringAscii("ln"     )) return bfLn;
-	if (name == "lg") return bfLg;
+	if (name == PIStringAscii("lg"     )) return bfLg;
-	if (name == "log") return bfLog;
+	if (name == PIStringAscii("log"    )) return bfLog;
-	if (name == "im") return bfIm;
+	if (name == PIStringAscii("im"     )) return bfIm;
-	if (name == "re") return bfRe;
+	if (name == PIStringAscii("re"     )) return bfRe;
-	if (name == "arg") return bfArg;
+	if (name == PIStringAscii("arg"    )) return bfArg;
-	if (name == "len") return bfLen;
+	if (name == PIStringAscii("len"    )) return bfLen;
-	if (name == "conj") return bfConj;
+	if (name == PIStringAscii("conj"   )) return bfConj;
-	if (name == "sign") return bfSign;
+	if (name == PIStringAscii("sign"   )) return bfSign;
-	if (name == "rad") return bfRad;
+	if (name == PIStringAscii("rad"    )) return bfRad;
-	if (name == "deg") return bfDeg;
+	if (name == PIStringAscii("deg"    )) return bfDeg;
-	if (name == "j0") return bfJ0;
+	if (name == PIStringAscii("j0"     )) return bfJ0;
-	if (name == "j1") return bfJ1;
+	if (name == PIStringAscii("j1"     )) return bfJ1;
-	if (name == "jn") return bfJN;
+	if (name == PIStringAscii("jn"     )) return bfJN;
-	if (name == "y0") return bfY0;
+	if (name == PIStringAscii("y0"     )) return bfY0;
-	if (name == "y1") return bfY1;
+	if (name == PIStringAscii("y1"     )) return bfY1;
-	if (name == "yn") return bfYN;
+	if (name == PIStringAscii("yn"     )) return bfYN;
-	if (name == "min") return bfMin;
+	if (name == PIStringAscii("min"    )) return bfMin;
-	if (name == "max") return bfMax;
+	if (name == PIStringAscii("max"    )) return bfMax;
-	if (name == "clamp") return bfClamp;
+	if (name == PIStringAscii("clamp"  )) return bfClamp;
-	if (name == "step") return bfStep;
+	if (name == PIStringAscii("step"   )) return bfStep;
-	if (name == "mix") return bfMix;
+	if (name == PIStringAscii("mix"    )) return bfMix;
-	if (name == "defined") return bfDefined;
+	if (name == PIStringAscii("defined")) return bfDefined;
-	if (name == "round") return bfRound;
+	if (name == PIStringAscii("round"  )) return bfRound;
 	return bfUnknown;
 }
 
 
 const PIString & PIEvaluator::prepare(const PIString & string) {
 	currentString = string.trimmed();
-	if (currentString.isEmpty()) currentString = "0";
+	if (currentString.isEmpty()) currentString = PIStringAscii("0");
 	replaceOperators();
 	removeSpaces();
 	checkBrackets();
@@ -281,7 +281,8 @@ void PIEvaluator::removeJunk() {
 	bool junk = true;
 	int bcnt;
 	while (junk) {
-		if (currentString.left(1) != "(" || currentString.right(1) != ")") return;
+		if (currentString.isEmpty()) return;
+		if (currentString.front() != '(' || currentString.back() != ')') return;
 		bcnt = 1;
 		junk = false;
 		for (int i = 1; i < currentString.length(); i++) {
@@ -303,26 +304,26 @@ void PIEvaluator::removeJunk() {
 
 
 void PIEvaluator::replaceOperators() {
-	currentString.replaceAll("==", "=");
+	currentString.replaceAll(PIStringAscii("=="), '=');
-	currentString.replaceAll("!=", ":");
+	currentString.replaceAll(PIStringAscii("!="), ':');
-	currentString.replaceAll(">=", "}");
+	currentString.replaceAll(PIStringAscii(">="), '}');
-	currentString.replaceAll("<=", "{");
+	currentString.replaceAll(PIStringAscii("<="), '{');
-	currentString.replaceAll("&&", "&");
+	currentString.replaceAll(PIStringAscii("&&"), '&');
-	currentString.replaceAll("||", "|");
+	currentString.replaceAll(PIStringAscii("||"), '|');
-	currentString.replaceAll(PIString::fromUTF8("≠"), ":");
+	currentString.replaceAll(PIString::fromUTF8("≠"), ':');
-	currentString.replaceAll(PIString::fromUTF8("≥"), "}");
+	currentString.replaceAll(PIString::fromUTF8("≥"), '}');
-	currentString.replaceAll(PIString::fromUTF8("≤"), "{");
+	currentString.replaceAll(PIString::fromUTF8("≤"), '{');
-	currentString.replaceAll(PIString::fromUTF8("⋀"), "&");
+	currentString.replaceAll(PIString::fromUTF8("⋀"), '&');
-	currentString.replaceAll(PIString::fromUTF8("⋁"), "|");
+	currentString.replaceAll(PIString::fromUTF8("⋁"), '|');
 }
 
 
 void PIEvaluator::makeOutput(PIString & string) {
-	string.replaceAll(":", PIString::fromUTF8("≠"));
+	string.replaceAll(PIStringAscii(":"), PIString::fromUTF8("≠"));
-	string.replaceAll("}", PIString::fromUTF8("≥"));
+	string.replaceAll(PIStringAscii("}"), PIString::fromUTF8("≥"));
-	string.replaceAll("{", PIString::fromUTF8("≤"));
+	string.replaceAll(PIStringAscii("{"), PIString::fromUTF8("≤"));
-	string.replaceAll("&", PIString::fromUTF8("⋀"));
+	string.replaceAll(PIStringAscii("&"), PIString::fromUTF8("⋀"));
-	string.replaceAll("|", PIString::fromUTF8("⋁"));
+	string.replaceAll(PIStringAscii("|"), PIString::fromUTF8("⋁"));
 }
 
 
@@ -334,7 +335,7 @@ void PIEvaluator::findUnknownVariables() {
 		else {
 			if (cvar.length() == 0) continue;
 			unknownVars << cvar;
-			cvar = "";
+			cvar.clear();
 		}
 	}
 	if (cvar.length() > 0) unknownVars << cvar;
@@ -343,16 +344,13 @@ void PIEvaluator::findUnknownVariables() {
 
 
 bool PIEvaluator::isSign(const PIChar & ch) {
-	return ch == '+' || ch == '-' ||
+	static PIString signs = PIStringAscii("+-*/%^=:><}{&|");
-		   ch == '*' || ch == '/' ||
+	if (!ch.isAscii()) return false;
-		   ch == '%' || ch == '^' ||
+	return signs.contains(ch.toAscii());
-		   ch == '=' || ch == ':' ||
-		   ch == '>' || ch == '<' ||
-		   ch == '}' || ch == '{' ||
-		   ch == '&' || ch == '|';
 }
 
 
+
 void PIEvaluator::checkBrackets() {
 	PIString tmps = currentString;
 	PIChar fc, sc;
@@ -365,7 +363,7 @@ void PIEvaluator::checkBrackets() {
 		}
 		if (tmps[i] == ')') {
 			if (bcnt == 0) {
-				currentString.insert(bpos + inserted, "(");
+				currentString.insert(bpos + inserted, '(');
 				inserted++;
 			} else bcnt--;
 		}
@@ -428,7 +426,7 @@ bool PIEvaluator::fillElements() {
 			cnum++;
 		}
 	}
-	curfind = "";
+	curfind.clear();
 	cnum = 1;
 	for (int i = 0; i < tmps.length(); i++) {
 		cc = tmps[i];
@@ -496,19 +494,19 @@ bool PIEvaluator::fillElements() {
 			break;
 		}
 		if (numFound) {
-			currentVariables.push_back(Variable("tmp" + PIString::fromNumber(cnum), curfind.toDouble()));
+			currentVariables.push_back(Variable(PIStringAscii("tmp") + PIString::fromNumber(cnum), curfind.toDouble()));
 			for (int j = i - curfind.length(); j < i; j++) {
 				elements[j].set(etNumber, cnum, -cnum);
 				tmps.replace(j, 1, fc);
 			}
-			curfind = "";
+			curfind.clear();
 			cnum++;
 			cpart = 0;
 			numFound = false;
 		}
 	}
 	if (cpart > 0) {
-		currentVariables.push_back(Variable("tmp" + PIString::fromNumber(cnum), curfind.toDouble()));
+		currentVariables.push_back(Variable(PIStringAscii("tmp") + PIString::fromNumber(cnum), curfind.toDouble()));
 		for (int j = tmps.length() - curfind.length(); j < tmps.length(); j++) {
 			elements[j].set(etNumber, cnum, -cnum);
 			tmps.replace(j, 1, fc);
@@ -584,11 +582,11 @@ bool PIEvaluator::setSignes() {
 		if (elements[pi].type == etOperator && (elements[ni].type == etFunction || elements[ni].type == etVariable) && fc == '-') needInsert = 3;
 		switch (needInsert) {
 		case 1:
-			currentString.insert(ni + inserted, "*");
+			currentString.insert(ni + inserted, '*');
 			elements.insert(ni + inserted, Element(etOperator, -1));
 			return true;
 		case 3:
-			currentString.insert(ni + inserted, "1*");
+			currentString.insert(ni + inserted, PIStringAscii("1*"));
 			elements.insert(ni + inserted, Element(etOperator, -1));
 			return true;
 		}
@@ -609,7 +607,7 @@ void PIEvaluator::convert() {
 			if (ce != pe) break;
 			j++;
 		}
-		currentString.replace(i, j - i, " ");
+		currentString.replace(i, j - i, ' ');
 		for (int k = i + 1; k < j; k++) elements.remove(i);
 	}
 	for (int i = 0; i < currentString.length(); i++) {
@@ -621,7 +619,7 @@ void PIEvaluator::convert() {
 			if (ce != pe) break;
 			j++;
 		}
-		currentString.replace(i, j - i, " ");
+		currentString.replace(i, j - i, ' ');
 		for (int k = i + 1; k < j; k++) elements.remove(i);
 	}
 	for (int i = 0; i < currentString.length(); i++) {
@@ -633,7 +631,7 @@ void PIEvaluator::convert() {
 			if (ce != pe) break;
 			j++;
 		}
-		currentString.replace(i, j - i, " ");
+		currentString.replace(i, j - i, ' ');
 		for (int k = i + 1; k < j; k++) elements.remove(i);
 	}
 	/*cout << " ";
@@ -707,7 +705,7 @@ int PIEvaluator::parse(const PIString & string, int offset) {
 			cfunc = content.function(ce.var_num);
 			atmp.clear();
 			bcnt = farg = 1;
-			carg = "";
+			carg.clear();
 			k = i + 1;
 			while (bcnt > 0) {
 				cc = string[k];
@@ -719,7 +717,7 @@ int PIEvaluator::parse(const PIString & string, int offset) {
 						///qDebug() << "arument: " << carg;
 						atmp.push_back(parse(carg, k + offset - carg.length()));
 						k++;
-						carg = "";
+						carg.clear();
 						if (atmp.size_s() > 0) if (atmp.back() < 0 && farg > 0) farg = atmp.back();
 						continue;
 					}
@@ -729,7 +727,7 @@ int PIEvaluator::parse(const PIString & string, int offset) {
 						///qDebug() << "arument: " << carg;
 						atmp.push_back(parse(carg, k + offset - carg.length()));
 						k++;
-						carg = "";
+						carg.clear();
 						if (atmp.size_s() > 0) if (atmp.back() < 0 && farg > 0) farg = atmp.back();
 						continue;
 					}
@@ -818,7 +816,7 @@ bool PIEvaluator::check() {
 	Instruction ci;
 	bool error;
 	if (unknownVars.size_s() > 0) {
-		lastError = "Unknown variables: \"" + unknownVars.join("\", \"") + "\"";
+		lastError = PIStringAscii("Unknown variables: \"") + unknownVars.join("\", \"") + PIStringAscii("\"");
 		return false;
 	}
 	for (int i = 0; i < instructions.size_s(); i++) {
@@ -840,25 +838,25 @@ bool PIEvaluator::check() {
 			}
 			if (fac > 0) {
 				if (gac != fac) {
-					lastError = "Invalid arguments count for function \"" + cf.identifier +
+					lastError = PIStringAscii("Invalid arguments count for function \"") + cf.identifier +
-								"\", expected " + PIString::fromNumber(fac) + " but " +
+								PIStringAscii("\", expected ") + PIString::fromNumber(fac) + PIStringAscii(" but ") +
-								PIString::fromNumber(gac) + " given";
+								PIString::fromNumber(gac) + PIStringAscii(" given");
 					return false;
 				}
 				if (error) {
-					lastError = "Invalid at least one of function \"" + cf.identifier + "\" argument";
+					lastError = PIStringAscii("Invalid at least one of function \"") + cf.identifier + PIStringAscii("\" argument");
 					return false;
 				}
 			}
 			if (fac < 0) {
 				if (gac < -fac) {
-					lastError = "Invalid arguments count for function \"" + cf.identifier +
+					lastError = PIStringAscii("Invalid arguments count for function \"") + cf.identifier +
-								"\", expected at least " + PIString::fromNumber(-fac) + " but " +
+								PIStringAscii("\", expected at least ") + PIString::fromNumber(-fac) + PIStringAscii(" but ") +
-								PIString::fromNumber(gac) + " given";
+								PIString::fromNumber(gac) + PIStringAscii(" given");
 					return false;
 				}
 				if (error) {
-					lastError = "Invalid at least one of function \"" + cf.identifier + "\" argument";
+					lastError = PIStringAscii("Invalid at least one of function \"") + cf.identifier + PIStringAscii("\" argument");
 					return false;
 				}
 			}
@@ -866,18 +864,18 @@ bool PIEvaluator::check() {
 		default:
 			if (ci.operators[0] == -666 || ci.operators[1] == -666) error = true;
 			if (ci.operators.size_s() != 2 || error) {
-				lastError = "Invalid arguments count for operation \" " + operationChar(ci.operation) + " \"";
+				lastError = PIStringAscii("Invalid arguments count for operation \" ") + operationChar(ci.operation) + PIStringAscii(" \"");
 				return false;
 			}
 			break;
 		}
 		if (ci.out < -variables.size_s()) {
-			lastError = "Invalid variable index \"" + PIString::fromNumber(ci.out) + "\"";
+			lastError = PIStringAscii("Invalid variable index \"") + PIString::fromNumber(ci.out) + PIStringAscii("\"");
 			return false;
 		}
 		for (int j = 0; j < ci.operators.size_s(); j++) {
 			if (ci.operators[j] < -variables.size_s() || ci.operators[j] >= kvars->size_s()) {
-				lastError = "Invalid variable index \"" + PIString::fromNumber(ci.operators[j]) + "\"";
+				lastError = PIStringAscii("Invalid variable index \"") + PIString::fromNumber(ci.operators[j]) + PIStringAscii("\"");
 				return false;
 			}
 		}
@@ -903,22 +901,23 @@ PIString PIEvaluator::inBrackets(const PIString & string) {
 
 PIString PIEvaluator::operationChar(const Operation & operation) {
 	switch (operation) {
-	case oAdd: return "+";
+	case oAdd         : return PIStringAscii("+");
-	case oSubtract: return "-";
+	case oSubtract    : return PIStringAscii("-");
-	case oMultiply: return "*";
+	case oMultiply    : return PIStringAscii("*");
-	case oDivide: return "/";
+	case oDivide      : return PIStringAscii("/");
-	case oPower: return "^";
+	case oPower       : return PIStringAscii("^");
-	case oResidue: return "%";
+	case oResidue     : return PIStringAscii("%");
-	case oEqual: return "=";
+	case oEqual       : return PIStringAscii("=");
 	case oNotEqual    : return PIString::fromUTF8("≠");
 	case oGreaterEqual: return PIString::fromUTF8("≥");
 	case oSmallerEqual: return PIString::fromUTF8("≤");
-	case oGreater: return ">";
+	case oGreater     : return PIStringAscii(">");
-	case oSmaller: return "<";
+	case oSmaller     : return PIStringAscii("<");
 	case oAnd         : return PIString::fromUTF8("⋀");
 	case oOr          : return PIString::fromUTF8("⋁");
-	default: return "???";
+	default: break;
 	}
+	return PIStringAscii("???");
 }
 
 
@@ -1182,7 +1181,7 @@ bool PIEvaluator::check(const PIString & string) {
 		instructions.clear();
 		return false;
 	}
-	lastError = "Correct";
+	lastError = PIStringAscii("Correct");
 	return true;
 }