C++ Signal::IsSignalled方法代码示例

void SimpleStream::Dump(Signal &sig, const void *buff, size_t bytes, bool upperFlag)
{
	int iCol = 0;
	String strHex, strASCII;
	const UChar *p = reinterpret_cast<const UChar *>(buff);
	for (size_t i = 0; i < bytes; i++, p++) {
		UChar ch = *p;
		char buff[8];
		if (upperFlag) {
			::sprintf(buff, (iCol > 0)? " %02X" : "%02X", ch);
		} else {
			::sprintf(buff, (iCol > 0)? " %02x" : "%02x", ch);
		}
		strHex += buff;
		strASCII += (0x20 <= ch && ch < 0x7f)? ch : '.';
		iCol++;
		if (iCol == 16) {
			String strLine = strHex;
			strLine += "  ";
			strLine += strASCII;
			Println(sig, strLine.c_str());
			if (sig.IsSignalled()) return;
			strHex.clear();
			strASCII.clear();
			iCol = 0;
		}
	}
	if (iCol > 0) {
		String strLine = strHex;
		for ( ; iCol < 16; iCol++) strLine += "   ";
		strLine += "  ";
		strLine += strASCII;
		Println(sig, strLine.c_str());
	}
}

bool DiffLine::FeedIterator(Environment &env, Signal &sig, size_t iSeq, Iterator *pIterator)
{
    Sequence &seq = GetSequence(iSeq);
    Value value;
    while (pIterator->Next(env, value)) {
        seq.push_back(value.ToString());
    }
    return !sig.IsSignalled();
}

bool SimpleStream::ReadLines(Signal &sig, StringList &strList, bool includeEOLFlag)
{
	for (;;) {
		String str;
		if (!ReadLine(sig, str, includeEOLFlag)) break;
		strList.push_back(str);
	}
	return !sig.IsSignalled();
}

void SimpleStream::Printf(Signal &sig, const char *format, ...)
{
	va_list ap;
	va_start(ap, format);
	String str = Formatter::FormatV(sig, format, ap);
	va_end(ap);
	if (sig.IsSignalled()) return;
	Print(sig, str.c_str());
}

bool DiffLine::FeedStream(Signal &sig, size_t iSeq, Stream &src)
{
    Sequence &seq = GetSequence(iSeq);
    bool includeEOLFlag = false;
    for (;;) {
        String str;
        if (!src.ReadLine(sig, str, includeEOLFlag)) break;
        seq.push_back(str);
    }
    return !sig.IsSignalled();
}

bool SimpleStream::ReadLine(Signal &sig, String &str, bool includeEOLFlag)
{
	int ch = GetChar(sig);
	if (ch < 0) return false;
	for ( ; ch >= 0; ch = GetChar(sig)) {
		if (ch == '\n') {
			if (includeEOLFlag) str += ch;
			break;
		}
		str += ch;
	}
	return !sig.IsSignalled();
}

size_t Stream::Peek(Signal &sig, void *buff, size_t len)
{
	if (len == 0) return 0;
	if (_peek.buff == nullptr) {
		_peek.buff = new char [len];
		_peek.bytes = DoRead(sig, _peek.buff, len);
		_peek.offsetRead = 0;
		if (sig.IsSignalled()) return 0;
	} else if (_peek.bytes < len) {
		char *buffNew = new char [len];
		::memcpy(buffNew, _peek.buff, _peek.bytes);
		size_t bytesAdd = DoRead(sig, buffNew + _peek.bytes, len - _peek.bytes);
		if (sig.IsSignalled()) return 0;
		delete[] _peek.buff;
		_peek.buff = buffNew;
		_peek.bytes += bytesAdd;
		_peek.offsetRead = 0;
	}
	size_t bytesToPeek = ChooseMin(_peek.bytes, len);
	::memcpy(buff, _peek.buff, bytesToPeek);
	return bytesToPeek;
}

bool DiffLine::PrintHunk(Signal &sig, SimpleStream &stream, const Hunk &hunk) const
{
    const EditList &edits = GetEditList();
    EditList::const_iterator pEdit = edits.begin() + hunk.idxEditBegin;
    EditList::const_iterator pEditEnd = edits.begin() + hunk.idxEditEnd;
    if (hunk.format == FORMAT_Normal) {
        stream.Printf(sig, "%s\n", hunk.TextizeRange_Normal().c_str());
        for ( ; pEdit != pEditEnd; pEdit++) {
            stream.Println(sig, TextizeEdit_Normal(*pEdit).c_str());
            if (sig.IsSignalled()) return false;
        }
    } else if (hunk.format == FORMAT_Context) {

    } else if (hunk.format == FORMAT_Unified) {
        stream.Printf(sig, "@@ %s @@\n", hunk.TextizeRange_Unified().c_str());
        if (sig.IsSignalled()) return false;
        for ( ; pEdit != pEditEnd; pEdit++) {
            stream.Println(sig, TextizeEdit_Unified(*pEdit).c_str());
            if (sig.IsSignalled()) return false;
        }
    }
    return true;
}

bool Stream::Compare(Signal &sig, Stream &stream)
{
	if (!CheckReadable(sig) || !stream.CheckReadable(sig)) return false;
	const size_t bytesBuff = 1024 * 16;
	AutoPtr<Memory> pMemory(new MemoryHeap(bytesBuff * 2));
	void *buff1 = pMemory->GetPointer(0);
	void *buff2 = pMemory->GetPointer(bytesBuff);
	bool sameFlag = false;
	for (;;) {
		size_t bytesRead1 = Read(sig, buff1, bytesBuff);
		if (sig.IsSignalled()) return false;
		size_t bytesRead2 = stream.Read(sig, buff2, bytesBuff);
		if (sig.IsSignalled()) return false;
		if (bytesRead1 != bytesRead2) {
			break;
		} else if (bytesRead1 == 0) {
			sameFlag = true;
			break;
		} else if (::memcmp(buff1, buff2, bytesRead1) != 0) {
			break;
		}
	}
	return sameFlag;
}

Value Object_interp::ConvFromTclObj(Environment &env, Signal &sig, Tcl_Obj *objPtr)
{
	Tcl_ObjType *typePtr = objPtr->typePtr;
	if (typePtr == nullptr) {
		return Value(objPtr->bytes, objPtr->length);
	} else if (typePtr == ObjType_boolean) {
		int value;
		::Tcl_GetBooleanFromObj(_interp, objPtr, &value);
		return Value(value? true : false);
	} else if (typePtr == ObjType_bytearray) {
		int length;
		unsigned char *binary = ::Tcl_GetByteArrayFromObj(objPtr, &length);
		return Value(new Object_binary(env, Binary(reinterpret_cast<char *>(binary), length), true));
	} else if (typePtr == ObjType_double) {
		double value;
		::Tcl_GetDoubleFromObj(_interp, objPtr, &value);
		return Value(value);
	} else if (typePtr == ObjType_int) {
		int value;
		::Tcl_GetIntFromObj(_interp, objPtr, &value);
		return Value(value);
	} else if (typePtr == ObjType_list) {
		int length;
		::Tcl_ListObjLength(_interp, objPtr, &length);
		Value result;
		Object_list *pObjList = result.InitAsList(env);
		pObjList->Reserve(length);
		for (int i = 0; i < length; i++) {
			Tcl_Obj *objElemPtr;
			::Tcl_ListObjIndex(_interp, objPtr, i, &objElemPtr);
			pObjList->Add(ConvFromTclObj(env, sig, objElemPtr));
			if (sig.IsSignalled()) return Value::Nil;
		}
		return result;
	} else if (typePtr == ObjType_string) {
		int length;
		char *value = ::Tcl_GetStringFromObj(objPtr, &length);
		return Value(value);
	}
	return Value(objPtr->bytes, objPtr->length);
}

//-----------------------------------------------------------------------------
// utilities
//-----------------------------------------------------------------------------
bool DoGLSection(Environment &env, Signal &sig, Argument &arg, Image *pImage)
{
#if GURA_USE_MSWIN_DIB
	PIXELFORMATDESCRIPTOR pfd = { 
		sizeof(PIXELFORMATDESCRIPTOR), 1,
		PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL, PFD_TYPE_RGBA,
		static_cast<BYTE>(pImage->GetBitsPerPixel()), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		32, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
	}; 
	HDC hdc = ::CreateCompatibleDC(nullptr);
	HBITMAP hBmp = pImage->GetHBITMAP();
	HBITMAP hBmpOld = reinterpret_cast<HBITMAP>(::SelectObject(hdc, hBmp));
	int iPixelFormat = ::ChoosePixelFormat(hdc, &pfd);
	::SetPixelFormat(hdc, iPixelFormat, &pfd);
	HGLRC hglrc = ::wglCreateContext(hdc);
	::wglMakeCurrent(hdc, hglrc);
	const Expr_Block *pExprBlock = arg.GetBlockCooked(env);
	if (!sig.IsSignalled()) {
		pExprBlock->Exec(env);
	}
	::wglMakeCurrent(nullptr, nullptr);
	::wglDeleteContext(hglrc);
	::SelectObject(hdc, hBmpOld);
	::DeleteDC(hdc);
	return true;
#elif defined(GURA_ON_DARWIN)
	//*****************
	// not working yet.
	//*****************
	GLsizei width = static_cast<GLsizei>(pImage->GetWidth());
	GLsizei height = static_cast<GLsizei>(pImage->GetHeight());
    CGLError errCode = kCGLNoError;
	GLuint texOut = 0;
	CGLContextObj ctx = nullptr;
	CGLContextObj ctxOrg = CGLGetCurrentContext();
	CGLPixelFormatAttribute attributes[4] = {
		kCGLPFAAccelerated,
		kCGLPFAOpenGLProfile,
		(CGLPixelFormatAttribute)kCGLOGLPVersion_3_2_Core,
		(CGLPixelFormatAttribute)0
	};
	CGLPixelFormatObj pixelFormat = nullptr;
	GLint numPixelFormats = 0;
	errCode = CGLChoosePixelFormat(attributes, &pixelFormat, &numPixelFormats);
	errCode = CGLCreateContext(pixelFormat, nullptr, &ctx);
	errCode = CGLSetCurrentContext(ctx);
	glGenTextures(1, &texOut);
	glBindTexture(GL_TEXTURE_2D, texOut);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
	GLuint frameBuffer = 0;
	glGenFramebuffers(1, &frameBuffer);
	glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texOut, 0);
	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
	if (status == GL_FRAMEBUFFER_COMPLETE) {
		const Expr_Block *pExprBlock = arg.GetBlockCooked(env);
		if (!sig.IsSignalled()) {
			pExprBlock->Exec(env);
		}
	}
	do {
		GLenum format = GetImageFormat(env, pImage);
		if (sig.IsSignalled()) return false;
		glBindTexture(GL_TEXTURE_2D, texOut);
		glGetTexImage(GL_TEXTURE_2D, 0, format, GL_UNSIGNED_BYTE, pImage->GetBuffer());
	} while (0);
	glDeleteTextures(1, &texOut);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	CGLSetCurrentContext(ctxOrg);
	CGLDestroyContext(ctx);
	return true;
#else
#if 0
	int width = static_cast<int>(pImage->GetWidth());
	int height = static_cast<int>(pImage->GetHeight());
	GLXFBConfig config;
	Pixmap pixmap = ::XCreatePixmap(nullptr, d, width, height, 32);
	GLXPixmap xid = ::glXCreatePixmap(nullptr, config, pixmap, nullptr);
	GLXContext ctx;
	::glXMakeCurrent(nullptr, xid, ctx);
	const Expr_Block *pExprBlock = arg.GetBlockCooked(env);
	if (!sig.IsSignalled()) {
		pExprBlock->Exec(env);
	}
	::glReadPixels(0, 0, width, height, GL_BGRA_EXT,
									GL_UNSIGNED_BYTE, pImage->GetBuffer());
#endif
#endif
	return true;
}

void SimpleStream::PrintFmt(Signal &sig, const char *format, const ValueList &valList)
{
	String str = Formatter::FormatValueList(sig, format, valList);
	if (sig.IsSignalled()) return;
	Print(sig, str.c_str());
}

//.........这里部分代码省略.........
				stat = STAT_PrecisionPre;
			} else if (ch == 'l') {
				// just ignore it
			} else if (ch == 'd' || ch == 'i') {
				Value value = source.GetInt();
				if (!value.GetClass()->Format_d(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'u') {
				Value value = source.GetInt();
				if (!value.GetClass()->Format_u(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'b') {
				Value value = source.GetInt();
				if (!value.GetClass()->Format_b(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'o') {
				Value value = source.GetInt();
				if (!value.GetClass()->Format_o(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'x' || ch == 'X') {
				Value value = source.GetInt();
				flags.upperCaseFlag = (ch == 'X');
				if (!value.GetClass()->Format_x(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'e' || ch == 'E') {
				Value value = source.GetDouble();
				flags.upperCaseFlag = (ch == 'E');
				if (!value.GetClass()->Format_e(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'f' || ch == 'F') {
				Value value = source.GetDouble();
				if (!value.GetClass()->Format_f(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'g' || ch == 'G') {
				Value value = source.GetDouble();
				flags.upperCaseFlag = (ch == 'G');
				if (!value.GetClass()->Format_g(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 's') {
				Value value = source.GetString();
				if (!value.GetClass()->Format_s(this, flags, value)) break;
				stat = STAT_Start;
			} else if (ch == 'c') {
				Value value = source.GetInt();
				if (!value.GetClass()->Format_c(this, flags, value)) break;
				stat = STAT_Start;
			} else {
				SetError_WrongFormat(sig);
				break;
			}
		} else if (stat == STAT_FlagsAfterWhite) {
			if (ch == ' ') {
				SetError_WrongFormat(sig);
				break;
			} else {
				eatNextFlag = false;
				stat = STAT_Flags;
			}
		} else if (stat == STAT_Padding) {
			if ('0' <= ch && ch <= '9') {
				flags.fieldMinWidth = flags.fieldMinWidth * 10 + (ch - '0');
			} else {
				eatNextFlag = false;
				stat = STAT_Flags;
			}
		} else if (stat == STAT_PrecisionPre) {
			if (ch == '*') {
				Value value = source.GetInt();
				if (!value.Is_number()) {
					sig.SetError(ERR_ValueError, "number is expected for * specifier");
					break;
				}
				flags.precision = static_cast<int>(value.GetNumber());
				if (flags.precision < 0) flags.precision = PREC_Default;
				if (source.IsEnd()) {
					SetError_NotEnoughArguments(sig);
					break;
				}
				stat = STAT_Flags;
			} else if ('0' <= ch && ch <= '9') {
				flags.precision = 0;
				eatNextFlag = false;
				stat = STAT_Precision;
			} else {
				flags.precision = PREC_Null;
				eatNextFlag = false;
				stat = STAT_Flags;
			}
		} else if (stat == STAT_Precision) {
			if ('0' <= ch && ch <= '9') {
				flags.precision = flags.precision * 10 + (ch - '0');
			} else {
				eatNextFlag = false;
				stat = STAT_Flags;
			}
		}
		if (eatNextFlag) formatp++;
	}
	return !sig.IsSignalled();
}