bool Builder::processFile(const String &filename) { // get file extension size_t n = filename.rfind("."); if (n == std::string::npos) { THROW_EXCEPT(Exception::ERR_FILE_NOT_FOUND, "Can't determine file extension " + filename, filename, 0); return false; } std::string ext = filename.substr(n + 1, std::string::npos); // try to find translator factory tTranslatorFactories::iterator it = mTranslatorFactories.find(ext); if (it == mTranslatorFactories.end()) { THROW_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "There are no translators, that support " + ext + " extension", filename, 0); return false; } iTranslator *translator = it->second->createInstance(mContext); assert(translator); TranslatorParams translateParams; translateParams.fileName = filename; translateParams.autoFormatInfo = mParams.autoFormatInfo; bool result = translator->translate(translateParams); delete translator; return result; }
CDirect3D9MeshPack::CDirect3D9MeshPack(IDirect3DDevice9Ex* device, const PMeshPack& meshPack) : m_meshes(CopyMeshes(meshPack)), m_vb(nullptr), m_ib(nullptr), m_device(device) { assert(m_device); assert(meshPack.bits); const uint NumVertexBytes = meshPack.firstIndexOffset; const uint NumIndexBytes = meshPack.bitsSize - NumVertexBytes; HRESULT hr; IDirect3DVertexBuffer9* pVb; hr = m_device->CreateVertexBuffer(NumVertexBytes, D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &pVb, NULL); if (FAILED(hr)) THROW_EXCEPT(graphics_device_exception, "Failed to create vertex buffer of size: " + string(DXGetErrorStringA(hr))); m_vb = make_directx_unique<IDirect3DVertexBuffer9>(pVb); // Copy vertex bits into buffer. VOID* bufferPtr; hr = m_vb->Lock(0, 0, reinterpret_cast<VOID**>(&bufferPtr), 0); if (FAILED(hr)) THROW_EXCEPT(graphics_device_exception, "Failed to lock vertex buffer: " + string(DXGetErrorStringA(hr))); memcpy(bufferPtr, meshPack.bits, NumVertexBytes); m_vb->Unlock(); IDirect3DIndexBuffer9* pIb; hr = m_device->CreateIndexBuffer(NumIndexBytes, D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &pIb, NULL); if (FAILED(hr)) THROW_EXCEPT(graphics_device_exception, "Failed to create vertex buffer of size: " + string(DXGetErrorStringA(hr))); m_ib = make_directx_unique<IDirect3DIndexBuffer9>(pIb); // Copy index bits into buffer. hr = m_ib->Lock(0, 0, reinterpret_cast<VOID**>(&bufferPtr), 0); if (FAILED(hr)) THROW_EXCEPT(graphics_device_exception, "Failed to lock index buffer: " + string(DXGetErrorStringA(hr))); memcpy(bufferPtr, meshPack.bits + NumVertexBytes, NumIndexBytes); m_ib->Unlock(); // Create vertex declaration. m_vdecls.reserve(meshPack.meshesSize); for (uint i=0; i<meshPack.meshesSize; ++i) { auto vertexDecl = MakeVertexDecl(GetPobStruct(&meshPack, meshes, i)); IDirect3DVertexDeclaration9* pVdecl; hr = m_device->CreateVertexDeclaration(&vertexDecl[0], &pVdecl); if (FAILED(hr)) THROW_EXCEPT(graphics_device_exception, "Failed to create vertex declaration: " + string(DXGetErrorStringA(hr))); m_vdecls.emplace_back(shared_ptr<IDirect3DVertexDeclaration9>(pVdecl, directx_deleter<IDirect3DVertexDeclaration9>())); } }
I2C::I2C(const std::string &name) : mFilename(name) { mLastSlaveAddr = 0x00; // Open device mFd = open(mFilename.c_str(), O_RDWR); if (mFd == -1) THROW_EXCEPT(I2CException, "Could not open " + name); // Set initial slave to 0; this is defined as a broadcast to all slaves on // the line. So mLastSlaveAddr is consistent with internal device driver // state. if (ioctl(mFd, I2C_SLAVE, mLastSlaveAddr) < 0) THROW_EXCEPT(I2CException, "Could not set I2C slave\n"); }
size_t I2C::read(uint8_t slaveaddr, void *buffer, size_t length) { if (slaveaddr != mLastSlaveAddr) { if (ioctl(mFd, I2C_SLAVE, slaveaddr) < 0) THROW_EXCEPT(I2CException, "Could not set I2C slave\n"); else mLastSlaveAddr = slaveaddr; } size_t bytes; if ((bytes = ::read(mFd, buffer, length)) == -1) THROW_EXCEPT(I2CException, "I2C read operation failed: " + std::string(strerror(errno))); return bytes; }
void parseError(const char* errorName, int line) { THROW_EXCEPT(Exception::ERR_PARSE, String(errorName), "", line); }
speed_t RadioLinux::baudToSpeed(int baudrate) { switch (baudrate) { case 1200: return B1200; case 1800: return B1800; case 2400: return B2400; case 4800: return B4800; case 9600: return B9600; case 19200: return B19200; case 38400: return B38400; case 57600: return B57600; case 115200: return B115200; case 230400: return B230400; default: THROW_EXCEPT(RadioException, "Unsupported baudrate (" + boost::lexical_cast<std::string>(baudrate)); } }
void SCsTranslator::processSentenceLevel1(pANTLR3_BASE_TREE node) { unsigned int nodesCount = node->getChildCount(node); assert(nodesCount == 3); pANTLR3_BASE_TREE node_obj = (pANTLR3_BASE_TREE)node->getChild(node, 0); pANTLR3_BASE_TREE node_pred = (pANTLR3_BASE_TREE)node->getChild(node, 1); pANTLR3_BASE_TREE node_subj = (pANTLR3_BASE_TREE)node->getChild(node, 2); pANTLR3_COMMON_TOKEN tok_pred = node_pred->getToken(node_pred); if (tok_pred->type != ID_SYSTEM) { THROW_EXCEPT(Exception::ERR_PARSE, String("Invalid predicate '") + ((const char*) node_pred->getText(node_pred)->chars) + "' in simple sentence", mParams.fileName, tok_pred->getLine(tok_pred)); } sElement *el_obj = parseElementTree(node_obj); sElement *el_subj = parseElementTree(node_subj); // determine arc type sc_type type = sc_type_edge_common; String pred = GET_NODE_TEXT(node_pred); size_t n = pred.find_first_of("#"); if (n != pred.npos) type = _getArcPreffixType(pred.substr(0, n)); _addEdge(el_obj, el_subj, type, false, pred); }
void SCsTranslator::processSentenceAssign(pANTLR3_BASE_TREE node) { unsigned int nodesCount = node->getChildCount(node); assert(nodesCount == 2); pANTLR3_BASE_TREE node_left = (pANTLR3_BASE_TREE)node->getChild(node, 0); pANTLR3_BASE_TREE node_right = (pANTLR3_BASE_TREE)node->getChild(node, 1); pANTLR3_COMMON_TOKEN tok_left = node_left->getToken(node_left); pANTLR3_COMMON_TOKEN tok_right = node_left->getToken(node_right); assert(tok_left && tok_right); if (tok_left->type != ID_SYSTEM) { THROW_EXCEPT(Exception::ERR_PARSE, "Unsupported type of tokens at the left side of assignment sentence", mParams.fileName, tok_left->getLine(tok_left)); } if (tok_right->type == ID_SYSTEM) { mAssignments[GET_NODE_TEXT(node_left)] = GET_NODE_TEXT(node_right); } else { String left_idtf = (GET_NODE_TEXT(node_left)); sElement *el = parseElementTree(node_right, &left_idtf); } }
int RadioLinux::readUBE32(uint32_t *i) { int bytes; uint32_t orig; if ((bytes = ::read(mFD, &orig, sizeof(orig))) == -1) THROW_EXCEPT(RadioException, "Failed to read from radio"); BEToHost(i, &orig, sizeof(orig)); return bytes; }
int RadioLinux::writeUBE32(uint32_t i) { int bytes; uint32_t swapped; hostToBE(&swapped, &i, sizeof(i)); if ((bytes = ::write(mFD, &swapped, sizeof(swapped))) == -1) THROW_EXCEPT(RadioException, "Failed to write to radio"); return bytes; }
tuple<byte_t*, uint> CDirect3D9DynamicTexture::Lock() { D3DLOCKED_RECT lock; HRESULT hr = m_texture->LockRect(0, &lock, NULL, D3DLOCK_DISCARD); if (FAILED(hr)) THROW_EXCEPT(graphics_device_exception, "Failed to lock surface: " + string(DXGetErrorDescriptionA(hr))); return make_tuple(static_cast<byte_t*>(lock.pBits), lock.Pitch); }
tuple<byte_t*, uint> CDirect3D9DynamicTexture::Lock(const rect_t& rectangle) { D3DLOCKED_RECT lock; const RECT rect = { rectangle.left, rectangle.top, rectangle.right, rectangle.bottom }; HRESULT hr = m_texture->LockRect(0, &lock, &rect, 0); if (FAILED(hr)) THROW_EXCEPT(graphics_device_exception, "Failed to lock surface: " + string(DXGetErrorDescriptionA(hr))); return make_tuple(static_cast<byte_t*>(lock.pBits), lock.Pitch); }
void I2C::write(uint8_t slaveaddr, const void *data, size_t length) { if (slaveaddr != mLastSlaveAddr) { if (ioctl(mFd, I2C_SLAVE, slaveaddr) < 0) THROW_EXCEPT(I2CException, "Could not set I2C slave\n"); else mLastSlaveAddr = slaveaddr; } int bytes; if ((bytes = ::write(mFd, data, length)) < length) { int err = errno; if (bytes >= 0) THROW_EXCEPT(I2CException, "I2C write could not write all bytes"); else THROW_EXCEPT(I2CException, "I2C write operation failed: " + std::string(strerror(err))); } }
Motor::Motor(PWM *pwm, int channel, float min_hightime, float max_hightime) { mPWM = pwm; mChannel = channel; mMinHighTime = min_hightime; mMaxHighTime = max_hightime; mSpeed = -1.0f; if (!pwm) THROW_EXCEPT(PWMException, "Provided PWM is not valid"); setSpeed(mSpeed); }
void displayLexerError(pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_UINT8 * tokenNames) { /// modified https://github.com/antlr/antlr3/blob/master/runtime/C/src/antlr3lexer.c pANTLR3_LEXER lexer; pANTLR3_EXCEPTION ex; pANTLR3_STRING ftext; lexer = (pANTLR3_LEXER)(recognizer->super); ex = lexer->rec->state->exception; // See if there is a 'filename' we can use String fname = "-unknown source-"; if (ex->name != NULL) { ftext = ex->streamName->to8(ex->streamName); fname = (const char*)ftext->chars; } int line = recognizer->state->exception->line; StringStream ss ; ss << "lexer error " << ex->type << " :\n\t" << (const char*)ex->message << " at offset " << ex->charPositionInLine + 1 << ", "; { ANTLR3_INT32 width; width = ANTLR3_UINT32_CAST(( (pANTLR3_UINT8)(lexer->input->data) + (lexer->input->size(lexer->input) )) - (pANTLR3_UINT8)(ex->index)); if (width >= 1) { if (isprint(ex->c)) ss << "near '" << ex->c << "' :\n"; else { StringStream hs; hs << std::hex << std::setfill('0'); hs << std::setw(2) << ex->c; ss << "near char(0x" << hs.str() << ") :\n"; } } else { std::cerr << "(end of input).\n\t This indicates a poorly specified lexer RULE\n\t or unterminated input element such as: \"STRING[\"]\n"; std::cerr << "\t The lexer was matching from line " << (ANTLR3_UINT32)(lexer->rec->state->tokenStartLine) << ", offset " << (ANTLR3_UINT32)(lexer->rec->state->tokenStartCharPositionInLine) << ", which\n\t "; } } THROW_EXCEPT(Exception::ERR_PARSE, ss.str(), fname, line); }
void I2C::sendTransaction() { if (mQueue.size() > 0) { struct i2c_rdwr_ioctl_data iodata; iodata.msgs = &mQueue[0]; iodata.nmsgs = mQueue.size(); int iostatus; if ((iostatus = ioctl(mFd, I2C_RDWR, &iodata)) < 0) THROW_EXCEPT(I2CException, "I2C ioctl() failed: " + std::string(strerror(errno))); mQueue.clear(); } }
bool SCsTranslator::processString(const String &data) { pANTLR3_INPUT_STREAM input; #if defined( __WIN32__ ) || defined( _WIN32 ) input = antlr3StringStreamNew((pANTLR3_UINT8)data.c_str(), ANTLR3_ENC_UTF8, (ANTLR3_UINT32)data.length(), (pANTLR3_UINT8)"scs"); #elif defined( __APPLE_CC__) input = antlr3StringStreamNew((pANTLR3_UINT8)data.c_str(), ANTLR3_ENC_UTF8, data.length(), (pANTLR3_UINT8)"scs"); #else input = antlr3NewAsciiStringCopyStream((pANTLR3_UINT8)data.c_str(), data.length(), (pANTLR3_UINT8)"scs"); #endif pscsLexer lex; pANTLR3_COMMON_TOKEN_STREAM tokens; pscsParser parser; lex = scsLexerNew(input); tokens = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lex)); parser = scsParserNew(tokens); scsParser_syntax_return r; pANTLR3_BASE_TREE tree; try { r = parser->syntax(parser); } catch (const Exception &e) { THROW_EXCEPT(Exception::ERR_PARSE, e.getDescription(), mParams.fileName, e.getLineNumber()); } tree = r.tree; //dumpDot(tree); // translate buildScText(tree); //dumpScs("test.scsd"); parser->free(parser); tokens->free(tokens); lex->free(lex); input->close(input); return true; }
void Controller::init(){ BB_InstanceContext context; initInstanceContext(context); _mainInstance = new MainInstance(context); try { _mainInstance->login(); } catch(BB_Exception excp) { delete _mainInstance; _mainInstance = NULL; THROW_EXCEPT(excp.GetInfo()); } }
void Drive::startTimer() { if (!mTimerEnabled) { mTimerEnabled = true; if (pthread_create(&mUpdateThread, NULL, updateThreadEntry, this) != 0) { mTimerEnabled = false; THROW_EXCEPT(DriveException, "Failed to start update thread"); } } /* // Establish signal handler mTimerAction.sa_sigaction = timerUpdate; mTimerAction.sa_flags = SA_SIGINFO; sigemptyset(&mTimerAction.sa_mask); if (sigaction(SIGALRM, &mTimerAction, NULL) != 0) THROW_EXCEPT(DriveException, "Could not set signal handler for update routine\n"); // Create timer that will send signal if (mTimerID == 0) { mTimerEvent.sigev_notify = SIGEV_THREAD_ID | SIGEV_SIGNAL; mTimerEvent.sigev_signo = SIGALRM; mTimerEvent.sigev_value.sival_ptr = this; mTimerEvent.sigev_notify_thread_id = gettid(); if (timer_create(CLOCK_REALTIME, &mTimerEvent, &mTimerID) != 0) THROW_EXCEPT(DriveException, "Could not create timer"); } // Set timer struct itimerspec time; time.it_interval.tv_sec = (mUpdateRate == 1 ? 1 : 0); time.it_interval.tv_nsec = (mUpdateRate == 1 ? 0 : 1000000000 / mUpdateRate); time.it_value.tv_sec = time.it_interval.tv_sec; time.it_value.tv_nsec = time.it_interval.tv_nsec; if (timer_settime(mTimerID, 0, &time, NULL) != 0) THROW_EXCEPT(DriveException, "Could not start timer"); */ }
RadioLinux::RadioLinux(const std::string &devfile, int baudrate, Parity p) { mBaudRate = baudrate; mParity = p; mFD = open(devfile.c_str(), O_RDWR | O_ASYNC); if (mFD == -1) THROW_EXCEPT(RadioException, "Could not open " + devfile); struct termios tprops; tcgetattr(mFD, &tprops); tprops.c_iflag = 0; if (mParity != PARITY_NONE) tprops.c_iflag |= INPCK; tprops.c_oflag = 0; tprops.c_cflag = CS8 | CREAD; if (mParity != PARITY_NONE) { tprops.c_cflag |= PARENB; if (mParity == PARITY_ODD) tprops.c_cflag |= PARODD; } tprops.c_lflag = 0; // Disable control characaters for (int cc = 0; cc < NCCS; ++cc) tprops.c_cc[cc] = _POSIX_VDISABLE; tprops.c_cc[VMIN] = 0; // No minimum number of characters for reads tprops.c_cc[VTIME] = 0; // No timeout (0 deciseconds) speed_t baudspeed = baudToSpeed(mBaudRate); cfsetospeed(&tprops, baudspeed); cfsetispeed(&tprops, baudspeed); tcsetattr(mFD, TCSAFLUSH, &tprops); tcflow(mFD, TCOON | TCION); tcflush(mFD, TCIOFLUSH); }
CDirect3D9CubeTexture::CDirect3D9CubeTexture(IDirect3DDevice9Ex* device, const PCubeMap& cubeMap) : m_device(device) { HRESULT hr; D3DFORMAT fmt; const int NumFaces = 6; const D3DCUBEMAP_FACES faces[NumFaces] = { D3DCUBEMAP_FACE_POSITIVE_X, D3DCUBEMAP_FACE_NEGATIVE_X, D3DCUBEMAP_FACE_POSITIVE_Z, D3DCUBEMAP_FACE_NEGATIVE_Z, D3DCUBEMAP_FACE_POSITIVE_Y, D3DCUBEMAP_FACE_NEGATIVE_Y }; vector<shared_ptr<PTexture>> cubeTexs(NumFaces); cubeTexs[0] = GPob->GetTypedPob<PTexture>(cubeMap.positiveX); cubeTexs[1] = GPob->GetTypedPob<PTexture>(cubeMap.negativeX); cubeTexs[2] = GPob->GetTypedPob<PTexture>(cubeMap.positiveZ); cubeTexs[3] = GPob->GetTypedPob<PTexture>(cubeMap.negativeZ); cubeTexs[4] = GPob->GetTypedPob<PTexture>(cubeMap.positiveY); // Optional bottom face. cubeTexs[5] = GPob->GetTypedPob<PTexture>(cubeMap.negativeY); if (!cubeTexs[0] || !cubeTexs[1] || !cubeTexs[2] || !cubeTexs[3] || !cubeTexs[4]) THROW_EXCEPT(graphics_device_exception, "Failed to get cubemap textures"); // Create the cube texture, using parameters from +X. fmt = PixelFormats[static_cast<uint>(cubeTexs[0]->pixelFormat)]; uint edgeLength = cubeTexs[0]->width; IDirect3DCubeTexture9* pCubeMap; hr = m_device->CreateCubeTexture(edgeLength, 0, 0, fmt, D3DPOOL_DEFAULT, &pCubeMap, NULL); if (FAILED(hr)) throw graphics_device_exception("Failed to create cube texture: " + string(DXGetErrorStringA(hr))); m_cubeMap = make_directx_unique<IDirect3DCubeTexture9>(pCubeMap); // Load bits into surface. for (int i=0; i < NumFaces; ++i) { shared_ptr<PTexture> texture(cubeTexs[i] ? cubeTexs[i] : cubeTexs[0]); auto surface = make_directx_unique<IDirect3DSurface9>(LoadTexture(m_device, *texture)); UpdateCubeMapSurface(faces[i], surface.get()); } }
int RadioLinux::read(std::string &buffer, size_t numbytes) { int bytes, totalbytes = 0, readbytes = 4096; char cbuf[4096]; std::string result; if (numbytes > 0) readbytes = numbytes; while ((bytes = ::read(mFD, cbuf, readbytes)) > 0 && (numbytes == 0 || numbytes > 0 && totalbytes < numbytes)) { if (bytes == -1) THROW_EXCEPT(RadioException, "Failed to read from radio"); else { result.append(cbuf, bytes); totalbytes += bytes; } } buffer.assign(result); return totalbytes; }
void Drive::loadCalibration(const std::string &filename) { std::ifstream file(filename.c_str(), std::ios_base::in); if (file.fail()) THROW_EXCEPT(CalibrationException, "Calibration file (" + filename + ") could not be loaded"); char key[20]; float value; while (!file.eof()) { file.getline(key, 20, '='); if (!file.fail()) { file >> value; file.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); if (strcmp(key, "AccelX") == 0) mAccelOffset.x = value; else if (strcmp(key, "AccelY") == 0) mAccelOffset.y = value; else if (strcmp(key, "AccelZ") == 0) mAccelOffset.z = value; else if (strcmp(key, "GyroX") == 0) mGyroOffset.x = value; else if (strcmp(key, "GyroY") == 0) mGyroOffset.y = value; else if (strcmp(key, "GyroZ") == 0) mGyroOffset.z = value; } }
bool GwfTranslator::processString(const String &data) { tinyxml2::XMLDocument doc; tinyxml2::XMLError error = doc.Parse(data.c_str()); if (error != tinyxml2::XML_SUCCESS) { THROW_EXCEPT(Exception::ERR_PARSE, doc.GetErrorStr2(), mParams.fileName, -1); } tinyxml2::XMLElement *root = doc.FirstChildElement("GWF"); if (!root) { THROW_EXCEPT(Exception::ERR_PARSE, "Can't find root element", mParams.fileName, -1); } root = root->FirstChildElement("staticSector"); if (!root) { THROW_EXCEPT(Exception::ERR_PARSE, "Cna't find static sector", mParams.fileName, -1); } // collect elements std::vector<tinyxml2::XMLElement*> nodes; std::vector<tinyxml2::XMLElement*> edges; std::vector<tinyxml2::XMLElement*> buses; std::vector<tinyxml2::XMLElement*> all; static std::string s_arc = "arc"; static std::string s_pair = "pair"; static std::string s_bus = "bus"; tinyxml2::XMLElement *el = root->FirstChildElement(); while (el) { all.push_back(el); if (el->Name() == s_arc || el->Name() == s_pair) edges.push_back(el); else if (el->Name() == s_bus) buses.push_back(el); else nodes.push_back(el); el = el->NextSiblingElement(); } static std::string s_node = "node"; static std::string s_contour = "contour"; tStringAddrMap id_map; tStringAddrMap::iterator itId; // create all nodes std::vector<tinyxml2::XMLElement*>::iterator it, itEnd = nodes.end(); for (it = nodes.begin(); it != itEnd; ++it) { el = *it; String idtf = el->Attribute("idtf"); String id = el->Attribute("id"); sc_addr addr; itId = id_map.find(id); if (itId != id_map.end()) continue; if (idtf.size() > 0) { if (getScAddr(idtf, addr)) { id_map[id] = addr; continue; // skip elements that already exists } } if (el->Name() == s_contour) { addr = sc_memory_node_new(sc_type_const | sc_type_node_struct); appendScAddr(addr, idtf); } else { tinyxml2::XMLElement *content = el->FirstChildElement("content"); if (!content) { THROW_EXCEPT(Exception::ERR_PARSE, "There are no child content for node with id=" + id, mParams.fileName, -1); } if (content->IntAttribute("type") == 0) { addr = sc_memory_node_new(convertType(el->Attribute("type"))); appendScAddr(addr, idtf); } else { // need to create link addr = sc_memory_link_new(); // setup content String data = content->GetText(); if (content->IntAttribute("type") == 4) data = base64_decode(data); sc_stream *stream = sc_stream_memory_new(data.c_str(), data.size(), SC_STREAM_READ, SC_FALSE); sc_memory_set_link_content(addr, stream); sc_stream_free(stream); if (mParams.autoFormatInfo) { String ext = StringUtil::getFileExtension(content->Attribute("file_name")); if (!ext.empty()) generateFormatInfo(addr, ext); } } } if (!idtf.empty()) sc_helper_set_system_identifier(addr, idtf.c_str(), idtf.size()); id_map[id] = addr; } // process buses itEnd = buses.end(); for (it = buses.begin(); it != itEnd; ++it) { el = *it; tStringAddrMap::iterator itOwner = id_map.find(el->Attribute("owner")); if (itOwner == id_map.end()) continue; id_map[el->Attribute("id")] = itOwner->second; } // now create edges bool created = true; while (created) { created = false; itEnd = edges.end(); for (it = edges.begin(); it != itEnd; ++it) { el = *it; sc_addr addr; String id = el->Attribute("id"); String idtf = el->Attribute("idtf"); if (id_map.find(id) != id_map.end()) continue; if (getScAddr(idtf, addr)) continue; // get begin and end elements tStringAddrMap::iterator itB = id_map.find(el->Attribute("id_b")); if (itB == id_map.end()) continue; tStringAddrMap::iterator itE = id_map.find(el->Attribute("id_e")); if (itE == id_map.end()) continue; // create arc created = true; addr = sc_memory_arc_new(convertType(el->Attribute("type")), itB->second, itE->second); appendScAddr(addr, idtf); id_map[id] = addr; if (!idtf.empty()) sc_helper_set_system_identifier(addr, idtf.c_str(), idtf.size()); } } // now append elemnts into contours itEnd = all.end(); for (it = all.begin(); it != itEnd; ++it) { el = *it; tStringAddrMap::iterator itSelf = id_map.find(el->Attribute("id")); if (itSelf == id_map.end()) continue; tStringAddrMap::iterator itP = id_map.find(el->Attribute("parent")); if (itP == id_map.end()) continue; sc_memory_arc_new(sc_type_arc_pos_const_perm, itP->second, itSelf->second); } return false; }
int RadioLinux::writeChar(char c) { int bytes; if ((bytes = ::write(mFD, &c, 1)) == -1) THROW_EXCEPT(RadioException, "Failed to write to radio"); return bytes; }
sElement* SCsTranslator::parseElementTree(pANTLR3_BASE_TREE tree, const String *assignIdtf) { pANTLR3_COMMON_TOKEN tok = tree->getToken(tree); assert(tok); sElement *res = 0; if (tok->type == ID_SYSTEM) res = _addNode(GET_NODE_TEXT(tree)); if (tok->type == SEP_LPAR) { assert(tree->getChildCount(tree) >= 3); pANTLR3_BASE_TREE node_obj = (pANTLR3_BASE_TREE)tree->getChild(tree, 0); pANTLR3_BASE_TREE node_pred = (pANTLR3_BASE_TREE)tree->getChild(tree, 1); pANTLR3_BASE_TREE node_subj = (pANTLR3_BASE_TREE)tree->getChild(tree, 2); String pred = GET_NODE_TEXT(node_pred); sElement *src = parseElementTree(node_obj); sElement *trg = parseElementTree(node_subj); assert(src && trg); res = _addEdge(src, trg, _getTypeByConnector(pred), _isConnectorReversed(pred), ""); } if (tok->type == LINK) { String data = GET_NODE_TEXT(tree); CHECK_LINK_DATA(data); res = _addLinkFile(assignIdtf ? *assignIdtf : "", data.substr(1, data.size() - 2)); } if (tok->type == CONTENT) { res = _addNode(assignIdtf ? *assignIdtf : "", sc_type_node_struct); String content = GET_NODE_TEXT(tree); content = content.substr(1, content.size() - 2); if (StringUtil::startsWith(content, "*", false) && StringUtil::endsWith(content, "*", false)) { // parse contour data String data = content.substr(1, content.size() - 2); bool autoFormatInfo = mParams.autoFormatInfo; String fileName = mParams.fileName; // check if link to file if (StringUtil::startsWith(data, "^\"", false)) { String name; bool result = false; if (_getAbsFilePath(trimContentData(data), name)) { fileName = name; std::ifstream ifs(name.c_str()); if (ifs.is_open()) { data = String((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>()); ifs.close(); result = true; } else { THROW_EXCEPT(Exception::ERR_PARSE, "Can't open file " << name, mParams.fileName, tok->getLine(tok)); } } } // parse data if (!data.empty()) { SCsTranslator translator(mContext); translator.mParams.autoFormatInfo = autoFormatInfo; translator.mParams.fileName = fileName; translator.processString(data); // now we need to get all created elements and create arcs to them tElementSet::iterator it, itEnd = translator.mElementSet.end(); for (it = translator.mElementSet.begin(); it != itEnd; ++it) { if ((*it)->ignore) continue; sElement *el = new sElement(); el->ignore = true; el->addr = (*it)->addr; mElementSet.insert(el); _addEdge(res, el, sc_type_arc_pos_const_perm, false, ""); } // merge identifiers map mSysIdtfAddrs.insert(translator.mSysIdtfAddrs.begin(), translator.mSysIdtfAddrs.end()); mLocalIdtfAddrs.insert(translator.mLocalIdtfAddrs.begin(), translator.mLocalIdtfAddrs.end()); } } else { if (StringUtil::startsWith(content, "^\"", false)) { String data = trimContentData(content); CHECK_LINK_DATA(data); sBuffer buffer; if (parseContentBinaryData(data, buffer)) { res = _addLink("", buffer); } else { res = _addLinkFile("", data); } } else { content = StringUtil::replaceAll(content, "\\[", "["); content = StringUtil::replaceAll(content, "\\]", "]"); CHECK_LINK_DATA(content); res = _addLinkString("", content); } } } if (tok->type == SEP_LTUPLE || tok->type == SEP_LSET) { res = _addNode("", sc_type_node_tuple); processAttrsIdtfList(false, tree, res, "->", tok->type == SEP_LTUPLE); } // now process internal sentences uint32 n = tree->getChildCount(tree); for (uint32 i = 0; i < n; ++i) { pANTLR3_BASE_TREE internal = (pANTLR3_BASE_TREE)tree->getChild(tree, i); pANTLR3_COMMON_TOKEN tok = internal->getToken(internal); if (tok->type != SEP_LINT) continue; // process internal sentences uint32 nc = internal->getChildCount(internal); for (uint32 j = 0; j < nc; ++j) { pANTLR3_BASE_TREE node_pred = (pANTLR3_BASE_TREE)internal->getChild(internal, j); String connector = GET_NODE_TEXT(node_pred); processAttrsIdtfList(false, node_pred, res, connector, false); } } return res; }
sc_addr SCsTranslator::createScAddr(sElement *el) { sc_addr addr; SC_ADDR_MAKE_EMPTY(addr); if (el->type & sc_type_node) addr = sc_memory_node_new(mContext, el->type); else if (el->type & sc_type_link) { addr = sc_memory_link_new(mContext); // setup link content if (el->link_is_file) { String file_path; if (_getAbsFilePath(el->file_path, file_path)) { sc_stream *stream = sc_stream_file_new(file_path.c_str(), SC_STREAM_FLAG_READ); if (stream) { sc_memory_set_link_content(mContext, addr, stream); sc_stream_free(stream); } else { THROW_EXCEPT(Exception::ERR_FILE_NOT_FOUND, "Can't open file " + el->file_path, mParams.fileName, -1); } } else { THROW_EXCEPT(Exception::ERR_INVALID_PARAMS, "Unsupported link type " + el->file_path, mParams.fileName, -1); } } else { sc_stream *stream = sc_stream_memory_new(el->link_data.data.data(), (sc_uint)el->link_data.data.size(), SC_STREAM_FLAG_READ, SC_FALSE); sc_memory_set_link_content(mContext, addr, stream); sc_stream_free(stream); } // generate format information if (mParams.autoFormatInfo) { if (el->link_is_file) { size_t n = el->file_path.find_last_of("."); if (n != String::npos) generateFormatInfo(addr, el->file_path.substr(n + 1)); } } } else { assert(el->arc_src && el->arc_trg); if (SC_ADDR_IS_EMPTY(el->arc_src->addr) || SC_ADDR_IS_EMPTY(el->arc_trg->addr)) return addr; addr = sc_memory_arc_new(mContext, el->type, el->arc_src->addr, el->arc_trg->addr); } el->addr = addr; return addr; }
int RadioLinux::readChar(char *c) { int bytes; if ((bytes = ::read(mFD, c, 1)) == -1) THROW_EXCEPT(RadioException, "Failed to read from radio"); return bytes; }
bool SCsTranslator::buildScText(pANTLR3_BASE_TREE tree) { int nodesCount = tree->getChildCount(tree); for (int i = 0; i < nodesCount; ++i) { pANTLR3_BASE_TREE sentenceNode = (pANTLR3_BASE_TREE)tree->getChild(tree, i); eSentenceType sentenceType = determineSentenceType(sentenceNode); switch (sentenceType) { case SentenceLevel1: processSentenceLevel1(sentenceNode); break; case SentenceLevel2_7: processSentenceLevel2_7(sentenceNode); break; case SentenceAssign: processSentenceAssign(sentenceNode); break; case SentenceEOF: break; default: THROW_EXCEPT(Exception::ERR_PARSE, "Unknown sentence type.", mParams.fileName, sentenceNode->getLine(sentenceNode)); break; } } // now generate sc-text in memory tElementSet::iterator it, itEnd = mElementSet.end(); for (it = mElementSet.begin(); it != itEnd; ++it) { sElement *el = *it; assert(el); if (el->type == sc_type_arc_pos_const_perm) { sc_type type = _getTypeBySetIdtf(el->arc_src->idtf); if (type != 0) { el->ignore = true; sc_type newType = el->arc_trg->type | type; // TODO check conflicts in sc-type if ((type & sc_type_constancy_mask) != 0) newType = (type & sc_type_constancy_mask) | (newType & ~sc_type_constancy_mask); el->arc_trg->type = newType; } } // arcs already have types if (!(el->type & sc_type_arc_mask)) determineElementType(el); } tElementSet arcs; for (it = mElementSet.begin(); it != itEnd; ++it) { sElement *el = *it; assert(el); // skip processed triples if (el->ignore) continue; sc_addr addr = resolveScAddr(el); if (SC_ADDR_IS_EMPTY(addr)) { assert(el->type & sc_type_arc_mask); arcs.insert(el); } } bool created = true; while (!arcs.empty() && created) { created = false; tElementSet createdSet; itEnd = arcs.end(); for (it = arcs.begin(); it != itEnd; ++it) { sElement *arc_el = *it; assert(arc_el->type & sc_type_arc_mask); sc_addr addr = resolveScAddr(arc_el); if (SC_ADDR_IS_EMPTY(addr)) continue; createdSet.insert(arc_el); } created = !createdSet.empty(); itEnd = createdSet.end(); for (it = createdSet.begin(); it != itEnd; ++it) arcs.erase(*it); } if (!arcs.empty()) { StringStream ss; ss << "Arcs not created: " << arcs.size(); THROW_EXCEPT(Exception::ERR_INVALID_STATE, ss.str(), mParams.fileName, -1); } return true; }
void displayRecognitionError (pANTLR3_BASE_RECOGNIZER recognizer, pANTLR3_UINT8 * tokenNames) { // Adopted code from https://github.com/antlr/antlr3/blob/master/runtime/C/src/antlr3baserecognizer.c pANTLR3_EXCEPTION ex; pANTLR3_COMMON_TOKEN theToken; pANTLR3_BASE_TREE theBaseTree; pANTLR3_COMMON_TREE theCommonTree; // Retrieve some info for easy reading. ex = recognizer->state->exception; String fileName; // See if there is a 'filename' we can use if (ex->streamName != NULL) { pANTLR3_STRING ftext; ftext = ex->streamName->to8(ex->streamName); fileName.assign((const char*)ftext->chars); } int line = recognizer->state->exception->line; StringStream ss; ss << (const char*) (recognizer->state->exception->message); // How we determine the next piece is dependent on which thing raised the // error. pANTLR3_STRING ttext; switch (recognizer->type) { case ANTLR3_TYPE_PARSER: { // Prepare the knowledge we know we have theToken = (pANTLR3_COMMON_TOKEN)(recognizer->state->exception->token); ttext = theToken->toString(theToken); ss << ", at offset " << recognizer->state->exception->charPositionInLine; if (theToken != NULL) { if (theToken->type == ANTLR3_TOKEN_EOF) ss << ", at <EOF>"; else // Guard against null text in a token ss << "\n near " << (ttext == NULL ? "<no text for the token>" : (const char*)ttext->chars) << "\n "; } } break; case ANTLR3_TYPE_TREE_PARSER: theBaseTree = (pANTLR3_BASE_TREE)(recognizer->state->exception->token); ttext = theBaseTree->toStringTree(theBaseTree); if (theBaseTree != NULL) { theCommonTree = (pANTLR3_COMMON_TREE) theBaseTree->super; if (theCommonTree != NULL) { theToken = (pANTLR3_COMMON_TOKEN) theBaseTree->getToken(theBaseTree); } ss << ", at offset " << theBaseTree->getCharPositionInLine(theBaseTree); ss << ", near " << (const char*)ttext->chars; } break; default: std::cerr << "Base recognizer function displayRecognitionError called by unknown parser type - provide override for this function\n"; return; break; } // Although this function should generally be provided by the implementation, this one // should be as helpful as possible for grammar developers and serve as an example // of what you can do with each exception type. In general, when you make up your // 'real' handler, you should debug the routine with all possible errors you expect // which will then let you be as specific as possible about all circumstances. // // Note that in the general case, errors thrown by tree parsers indicate a problem // with the output of the parser or with the tree grammar itself. The job of the parser // is to produce a perfect (in traversal terms) syntactically correct tree, so errors // at that stage should really be semantic errors that your own code determines and handles // in whatever way is appropriate. switch (ex->type) { case ANTLR3_UNWANTED_TOKEN_EXCEPTION: // Indicates that the recognizer was fed a token which seesm to be // spurious input. We can detect this when the token that follows // this unwanted token would normally be part of the syntactically // correct stream. Then we can see that the token we are looking at // is just something that should not be there and throw this exception. if (tokenNames == NULL) ss << " : Extraneous input..."; else { if (ex->expecting == ANTLR3_TOKEN_EOF) ss << " : Extraneous input - expected <EOF>\n"; else ss << " : Extraneous input - expected " << tokenNames[ex->expecting] << " ...\n"; } break; case ANTLR3_MISSING_TOKEN_EXCEPTION: // Indicates that the recognizer detected that the token we just // hit would be valid syntactically if preceeded by a particular // token. Perhaps a missing ';' at line end or a missing ',' in an // expression list, and such like. if (tokenNames == NULL) ss << " : Missing token (" << ex->expecting << ")...\n"; else { if (ex->expecting == ANTLR3_TOKEN_EOF) ss << " : Missing <EOF>\n"; else ss << " : Missing " << tokenNames[ex->expecting] << " \n"; } break; case ANTLR3_RECOGNITION_EXCEPTION: // Indicates that the recognizer received a token // in the input that was not predicted. This is the basic exception type // from which all others are derived. So we assume it was a syntax error. // You may get this if there are not more tokens and more are needed // to complete a parse for instance. ss << " : syntax error...\n"; break; case ANTLR3_MISMATCHED_TOKEN_EXCEPTION: // We were expecting to see one thing and got another. This is the // most common error if we coudl not detect a missing or unwanted token. // Here you can spend your efforts to // derive more useful error messages based on the expected // token set and the last token and so on. The error following // bitmaps do a good job of reducing the set that we were looking // for down to something small. Knowing what you are parsing may be // able to allow you to be even more specific about an error. if (tokenNames == NULL) ss << " : syntax error...\n"; else { if (ex->expecting == ANTLR3_TOKEN_EOF) ss << " : expected <EOF>\n"; else ss << " : expected " << tokenNames[ex->expecting] << " ...\n"; } break; case ANTLR3_NO_VIABLE_ALT_EXCEPTION: // We could not pick any alt decision from the input given // so god knows what happened - however when you examine your grammar, // you should. It means that at the point where the current token occurred // that the DFA indicates nowhere to go from here. ss << " : cannot match to any predicted input...\n"; break; case ANTLR3_MISMATCHED_SET_EXCEPTION: { ANTLR3_UINT32 count; ANTLR3_UINT32 bit; ANTLR3_UINT32 size; ANTLR3_UINT32 numbits; pANTLR3_BITSET errBits; // This means we were able to deal with one of a set of // possible tokens at this point, but we did not see any // member of that set. ss << " : unexpected input...\n expected one of : "; // What tokens could we have accepted at this point in the // parse? count = 0; errBits = antlr3BitsetLoad (ex->expectingSet); numbits = errBits->numBits (errBits); size = errBits->size (errBits); if (size > 0) { // However many tokens we could have dealt with here, it is usually // not useful to print ALL of the set here. I arbitrarily chose 8 // here, but you should do whatever makes sense for you of course. // No token number 0, so look for bit 1 and on. for (bit = 1; bit < numbits && count < 8 && count < size; bit++) { // TODO: This doesn;t look right - should be asking if the bit is set!! if (tokenNames[bit]) { ss << (count > 0 ? ", " : "") << tokenNames[bit]; count++; } } ss << "\n"; } else { std::cerr << "Actually dude, we didn't seem to be expecting anything here, or at least\n"; std::cerr << "I could not work out what I was expecting, like so many of us these days!\n"; } } break; case ANTLR3_EARLY_EXIT_EXCEPTION: // We entered a loop requiring a number of token sequences // but found a token that ended that sequence earlier than // we should have done. ss << " : missing elements...\n"; break; default: // We don't handle any other exceptions here, but you can // if you wish. If we get an exception that hits this point // then we are just going to report what we know about the // token. ss << " : syntax not recognized...\n"; break; } THROW_EXCEPT(Exception::ERR_PARSE, ss.str(), fileName, line); }