Beispiel #1
0
static void parseFile(ParserInterface *parser,
                      Entry *root,EntryNav *rootNav,FileDef *fd,const char *fn,
                      bool sameTu,QStrList &filesInSameTu)
{
  static bool clangAssistedParsing = FALSE;
  QCString fileName=fn;
  QCString extension;
  int ei = fileName.findRev('.');
  if (ei!=-1)
  {
    extension=fileName.right(fileName.length()-ei);
  }
  else
  {
    extension = ".no_extension";
  }

  QFileInfo fi(fileName);
  BufStr preBuf(fi.size()+4096);

  if (true && 
      parser->needsPreprocessing(extension))
  {
    BufStr inBuf(fi.size()+4096);
    readInputFile(fileName,inBuf);
//    preprocessFile(fileName,inBuf,preBuf);
  }
  else // no preprocessing
  {
    readInputFile(fileName,preBuf);
  }
  if (preBuf.data() && preBuf.curPos()>0 && *(preBuf.data()+preBuf.curPos()-1)!='\n')
  {
    preBuf.addChar('\n'); // add extra newline to help parser
  }

  BufStr convBuf(preBuf.curPos()+1024);

  // convert multi-line C++ comments to C style comments
  convertCppComments(&preBuf,&convBuf,fileName);

  convBuf.addChar('\0');

  // use language parse to parse the file
  parser->parseInput(fileName,convBuf.data(),root,sameTu,filesInSameTu);

  // store the Entry tree in a file and create an index to
  // navigate/load entries
  //printf("root->createNavigationIndex for %s\n",fd->name().data());
  root->createNavigationIndex(rootNav,g_storage,fd);
}
TVerdict CDataReadyCancelNotificationStep::doTestStepL()
/**
 * @return - TVerdict code
 * Override of base class pure virtual
 * Our implementation only gets called if the base class doTestStepPreambleL() did
 * not leave. That being the case, the current test result value will be EPass.
 */
	{
	  if (TestStepResult()==EPass)
		{
		_LIT8(KTestOutBuf,"test message");
		HBufC* InBuf = HBufC::NewLC(KTestOutBuf().Length() / 2);
		TPtr ptr = InBuf->Des();
		TPtr8 inBuf(ptr.Collapse());
		
		TBuf<50> msg;
		_LIT(KOperReading, "Data available request canceled in port <%d>");
		_LIT(KOperWriting, "Written port <%d>");
		TRequestStatus status;
		for(TInt i = 0; i < KSupportedPorts; i++)
			{
			if(IsEven(i))
				{
				iPortList[i].port.Write(status, KTestOutBuf);
				msg.Format(KOperWriting, i);
				User::WaitForRequest(status);
				TestErrorCodeL(status.Int(), msg);
				}
			else
				{
				iPortList[i].port.NotifyDataAvailableCancel();
				msg.Format(KOperReading, i);
				}
			}
		CleanupStack::PopAndDestroy();

		SetTestStepResult(EPass);
		}
	  return TestStepResult();
	}
Transfer * ResponseProtocol::parse( const QByteArray & wire, uint & bytes )
{
	m_bytes = 0;
	m_collatingFields.clear();
	//m_din = new QDataStream( wire, IO_ReadOnly );
	QBuffer inBuf( wire );
	inBuf.open( IO_ReadOnly); 
	m_din.setDevice( &inBuf );
	m_din.setByteOrder( QDataStream::LittleEndian );
	
	// check that this begins with a HTTP (is a response)
	Q_UINT32 val;
	m_din >> val;
	m_bytes += sizeof( Q_UINT32 );
	
	Q_ASSERT( qstrncmp( (const char *)&val, "HTTP", strlen( "HTTP" ) ) == 0 );
	
	// read rest of HTTP header and look for a 301 redirect. 
	QCString headerFirst;
	if ( !readGroupWiseLine( headerFirst ) )
		return 0;
	// pull out the HTTP return code
	int firstSpace = headerFirst.find( ' ' );
	QString rtnField = headerFirst.mid( firstSpace, headerFirst.find( ' ', firstSpace + 1 ) );
	bool ok = true;
	int rtnCode;
	int packetState = -1;
	rtnCode = rtnField.toInt( &ok );
	debug( "CoreProtocol::readResponse() got HTTP return code " );
	// read rest of header
	QStringList headerRest;
	QCString line;
	while ( line != "\r\n" )
	{
		if ( !readGroupWiseLine( line ) )
		{
			m_din.unsetDevice();
			return 0;
		}
		headerRest.append( line );
		debug( QString( "- read header line - (%1) : %2" ).arg( line.length() ).arg( line.data() ) );
	}
	debug( "ResponseProtocol::readResponse() header finished" );
	// if it's a redirect, set flag
	if ( ok && rtnCode == 301 )
	{	
		debug( "- server redirect " );
		packetState = ServerRedirect;
		m_din.unsetDevice();
		return 0;
	}
	// other header processing ( 500! )
	if ( ok && rtnCode == 500 )
	{
		debug( QString( "- server error %1" ).arg( rtnCode ) );
		packetState = ServerError;
		m_din.unsetDevice();
		return 0;
	}
	if ( ok && rtnCode == 404 )
	{
		debug( QString( "- server error %1" ).arg( rtnCode ) );
		packetState = ServerError;
		m_din.unsetDevice();
		return 0;
	}
	if ( m_din.atEnd() )
	{
		debug( "- no fields" );
		packetState = ProtocolError;
		m_din.unsetDevice();
		return 0;
	}
	
	// read fields
	if ( !readFields( -1 ) )
	{
		m_din.unsetDevice();
		return 0;
	}
	// find transaction id field and create Response object if nonzero
	int tId = 0;
	int resultCode = 0;
	Field::FieldListIterator it;
	Field::FieldListIterator end = m_collatingFields.end();
	it = m_collatingFields.find( NM_A_SZ_TRANSACTION_ID );
	if ( it != end )
	{
		Field::SingleField * sf = dynamic_cast<Field::SingleField*>( *it );
		if ( sf )
		{
			tId = sf->value().toInt();
			debug( QString( "ResponseProtocol::readResponse() - transaction ID is %1" ).arg( tId ) );
			m_collatingFields.remove( it );
			delete sf;
		}
	}
	it = m_collatingFields.find( NM_A_SZ_RESULT_CODE );
	if ( it != end )
	{
		Field::SingleField * sf = dynamic_cast<Field::SingleField*>( *it );
		if ( sf )
		{
			resultCode = sf->value().toInt();
			debug( QString( "ResponseProtocol::readResponse() - result code is %1" ).arg( resultCode ) );
			m_collatingFields.remove( it );
			delete sf;
		}
	}
	// append to inQueue
	if ( tId )
	{
		debug( QString( "ResponseProtocol::readResponse() - setting state Available, got %1 fields in base array" ).arg(m_collatingFields.count() ) );
		packetState = Available;
		bytes = m_bytes;
		m_din.unsetDevice();
		return new Response( tId, resultCode, m_collatingFields );
	}
	else
	{
		debug( "- WARNING - NO TRANSACTION ID FOUND!" );
		m_state = ProtocolError;
		m_din.unsetDevice();
		m_collatingFields.purge();
		return 0;
	}
}
Beispiel #4
0
void MainWindow::OnMenuCrawlTimer(wxTimerEvent & event)
{
	// our crawl timer has triggered, time to gets goin'

	static const std::string clStr("\r");
	static const std::string eolStr("\n");

	// wake up the device.
	DRUID::SerialUIUserPtr serial_user = connection->serialUser();
	serial_user->send(eolStr);
	// PLATFORM_SLEEP(1);


	if(connection->ping(3, false))
	{
		DRUID4ARDUINO_DEBUG2("Device seems to be alive on ", serial_port);

		//= ;
		std::string inBuf(serial_user->incomingBuffer());

		std::string name;
		std::string::iterator findIter = std::search(inBuf.begin(), inBuf.end(),
				clStr.begin(), clStr.end());

		if (findIter == inBuf.end())
		{
			findIter = std::search(inBuf.begin(), inBuf.end(),
				eolStr.begin(), eolStr.end());
		}

		if (findIter != inBuf.end()) {

			// copy the newly arrived message to last_message
			name.reserve(findIter - inBuf.begin());
			std::copy(inBuf.begin(), findIter, std::back_inserter(name));
		} else {
			name = inBuf;
		}

		prog_name = DRUID_STDSTRING_TOWX(name);
		resetStatusBar();

	} else {

		wxString errMsg(wxT("No response to ping for 3 seconds on "));
		errMsg += DRUID_STDSTRING_TOWX(serial_port);
		SetStatusText(errMsg);
	}



	// parse the menu
	if (serial_user->isConnected())
	{



		resetSUIWindows();
		if (topLevelMenu)
		{
			// clear out the window menu and its callbacks

			for (unsigned int elementId=MAINWINDOW_DYNAMICMENU_ELEMENTID_START;
					elementId < menu_id_counter; elementId++)
			{
				this->Disconnect(elementId, wxEVT_COMMAND_MENU_SELECTED);
			}

			for (unsigned int i=0; i < topLevelMenu->size(); i++)
			{
				// TODO: must we destroy the returned wxMenuItem?
				deviceMenu->Remove(deviceMenu->FindItemByPosition(0));
			}


		}

		parser.setControlStrings(serial_user->enterProgramMode());
		executing_request = true;
		topLevelMenu = parser.crawl(serial_user);

		if (topLevelMenu)
		{
			// ok, we have our menu structure
			parser.dumpMenus();
			buildAllDeviceMenus(topLevelMenu);

		} else {
			// TODO:FIXME return error
			currentlyEnabledSUIWindown()->setError(wxT("Parser could not crawl menus\r\nEnsure a valid SerialUI device is connected."));
			SetStatusText(wxT("Parser could not crawl menus"));
		}

		serial_user->clear();
		executing_request = false;
		pingTimer->Start(200, false);
	} else {
		SetStatusText(wxT("Serial connection failure"));
	}


}
Beispiel #5
0
bool ossimCodecFactory::encodeJpeg( ossim_uint32 quality,
                                    const ossimRefPtr<ossimImageData>& in,
                                    std::vector<ossim_uint8>& out ) const
{
   bool result = false;

   if ( in.valid() && (in->getDataObjectStatus() != OSSIM_NULL) )
   {
      if ( in->getScalarType() == OSSIM_UINT8 )
      {
         // Open a memory stream up to put the jpeg image in memory:
         std::stringstream jpegStreamBuf;
         
         //---
         // Initialize JPEG compression library:
         // NOTE: JDIMENSION is an "unsigned int"
         //---
         struct jpeg_compress_struct cinfo;
         struct jpeg_error_mgr jerr;
         cinfo.err = jpeg_std_error( &jerr );
         jpeg_create_compress(&cinfo);
      
         // Define a custom stream destination manager for jpeglib to write compressed block:
         jpeg_cpp_stream_dest(&cinfo, jpegStreamBuf);
      
         /* Setting the parameters of the output file here */
         cinfo.image_width = in->getWidth();
         cinfo.image_height = in->getHeight();
   
         // Bands must be one or three for this writer.
         const ossim_uint32 INPUT_BANDS = in->getNumberOfBands();
         if ( (INPUT_BANDS == 1) || (INPUT_BANDS == 3) )
         {
            cinfo.input_components = INPUT_BANDS;
         }
         else
         {
            if ( INPUT_BANDS < 3 )
            {
               cinfo.input_components = 1; // Use first band.
            }
            else
            {
               cinfo.input_components = 3; // Use the first 3 bands.
            }
         }
      
         // colorspace of input image 
         if ( cinfo.input_components == 3)
         {
            cinfo.in_color_space = JCS_RGB;
         }
         else
         {
            cinfo.in_color_space = JCS_GRAYSCALE;
         }
      
         // Default compression parameters, we shouldn't be worried about these.
         jpeg_set_defaults( &cinfo );
      
         jpeg_set_quality(&cinfo, quality, TRUE); //limit to baseline-JPEG values
      
         // Now do the compression...
         jpeg_start_compress( &cinfo, TRUE );
      
         // Line buffer:
         ossim_uint32 buf_size = cinfo.input_components*cinfo.image_width;
         std::vector<ossim_uint8> buf(buf_size);
      
         // Compress the tile on line at a time:
      
         JSAMPROW row_pointer[1]; // Pointer to a single row.
         row_pointer[0] = (JSAMPLE*)&buf.front();

         // Get pointers to the input data:
         std::vector<const ossim_uint8*> inBuf(cinfo.input_components);
         for ( ossim_int32 band = 0; band < cinfo.input_components; ++band )
         {
            inBuf[band] = in->getUcharBuf(band);
         }

         ossim_uint32 inIdx = 0;
         for (ossim_uint32 line=0; line< cinfo.image_height; ++line)
         {
            // Convert from band sequential to band interleaved by pixel.
            ossim_uint32 outIdx = 0;
            for ( ossim_uint32 p = 0; p < cinfo.image_width; ++p )
            {
               for ( ossim_int32 band = 0; band < cinfo.input_components; ++band )
               {
                  buf[outIdx++] = inBuf[band][inIdx];
               }
               ++inIdx;
            }

            // Write it...
            jpeg_write_scanlines( &cinfo, row_pointer, 1 );
         }
      
         // Similar to read file, clean up after we're done compressing.
         jpeg_finish_compress( &cinfo );
         jpeg_destroy_compress( &cinfo );

         // Copy the memory stream to output vector.
         out.resize(jpegStreamBuf.str().size());
         jpegStreamBuf.seekg(0, std::ios_base::beg);
         jpegStreamBuf.read((char*)&out.front(), jpegStreamBuf.str().size());

         result = true;
      }
      else // Scalar type check...
      {
         ossimNotify(ossimNotifyLevel_WARN)
            << "ossimCodecFactory::encodeJpeg ERROR:"
            << "\nPassing non-eight bit data to eight bit encoder!" << std::endl;
      }
      
   } // Matches: if ( in.valid() ... )
   
   return result;
}