bool KAbstractObjParserPrivate::parse()
{
for (;;)
{
switch (nextToken())
{
case PT_ERROR:
qFatal("Encountered an error! Aborting");
return false;
case PT_EOF:
return true;
case PT_VERTEX:
parseVertex();
break;
case PT_TEXTURE:
parseTexture();
break;
case PT_NORMAL:
parseNormal();
break;
case PT_PARAMETER:
parseParameter();
break;
case PT_FACE:
parseFace();
case PT_ENDSTATEMENT:
break;
}
}
}
SymbolArray parseParameterList(CharacterSource* source)
{
SymbolList list;
Symbol parameter = parseParameter(source);
if (!parameter.valid())
return list;
list.add(parameter);
Span span;
while (Space::parseCharacter(source, ',', &span)) {
Symbol parameter = parseParameter(source);
if (!parameter.valid())
source->location().throwError("Expected parameter");
list.add(parameter);
}
return list;
}
void CLSSource::parseSignature(CLSSource::Function *function) {
std::string sign = function->signature;
//std::cout << std::endl;
//std::cout << "Parsing signature " << std::endl;
//std::cout << sign << std::endl;
size_t i = sign.find_first_of(" \t\n", 0);
function->returntype = sign.substr(0, i);
//std::cout << "Return type: " << std::endl;
//std::cout << function->returntype << std::endl;
bool done = false;
i = sign.find_first_of("(", i)+1; // < start of param list
size_t j = i;
while(!done){
if (sign[i] == ')') {
function->parameters.push_back(parseParameter(sign.substr(j, i-j)));
done = true;
}
if (sign[i] == ',') {
function->parameters.push_back(parseParameter(sign.substr(j, i-j)));
j = i = sign.find_first_not_of(" \t\n", i+1);
}
i++;
}
/*
std::cout << "Parameters ["<<function->parameters.size()<<"]:" << std::endl;
for (int k = 0; k < function->parameters.size(); ++k) {
std::cout << "[" << function->parameters[k]->type
<< " " << function->parameters[k]->name;
if(function->parameters[k]->array_type){
std::cout << "[" << function->parameters[k]->array_size << "]";
}
std::cout << "], ";
}
std::cout << std::endl;
std::cout << std::endl;
*/
}
/*
* ------------------------------------------------------------- main --
*/
int main(int argc, const char * argv[]) {
data_collect shm_sem;
int shm_size = 0;
int sendData;
int pos = 0;
char output;
/* get size as parameter */
shm_size = parseParameter(argc, argv);
/* create segment/semaphore and return collection or when already created only return collection */
shm_sem = createSegment(shm_size);
// 3) while (!= EOF) von Shared Memory lesen
// aufpassen das Leseindex hinter Schreibindex bleibt
do {
/* Decrement read semaphore, because we read from a written segment, if >0 all ok else block application */
if (P(shm_sem.sem_r) != 0) {
if (errno == EINTR) {
/* syscall interrupted by signal, try again */
continue;
}
perror("P(shm_sem.sem_r)");
closeSegment(shm_sem);
break;
}
/* get character from shared memory and write to stdout */
output = shm_sem.segment[pos];
pos++;
if (output != EOF) {
printf("%c", output);
}
/* if pos == shared memory size, start at 0 again */
if (pos == shm_sem.shm_size) {
pos = 0;
}
/* increment write semaphore to tell sender that segment is read and can be overwritten */
if (V(shm_sem.sem_w) != 0) {
perror("V(shm_sem.sem_w)");
closeSegment(shm_sem);
break;
}
} while (output != EOF);
return 0;
}
void process_command_remote( xbee_dev_t *xbee, const char *cmdstr,
const addr64 FAR *ieee)
{
char cmdptr[2];
const char *param;
int16_t request;
if (! *cmdstr)
{
puts( "Enter an AT command");
return;
}
param = cmdstr;
do {
// convert command to upper case
cmdptr[0] = (char) toupper( (unsigned char)param[0]);
cmdptr[1] = (char) toupper( (unsigned char)param[1]);
param += 2; // advance beyond two-letter command
} while (memcmp( cmdptr, "AT", 2) == 0); // skip leading AT
request = xbee_cmd_create( xbee, cmdptr);
if (request < 0)
{
// Note that strerror() expects the positive error value
// (what would have been stored in errno) so we have to
// negate the xbee_cmd_create() return value.
printf( "Error creating request: %d (%" PRIsFAR ") \n",
request, strerror( -request));
}
else
{
// allow for "ATXX=1234" syntax
if (*param == '=' || *param == ' ')
{
++param;
}
if (parseParameter( param, request) == 0)
{
if (ieee)
{
xbee_cmd_set_target( request, ieee, WPAN_NET_ADDR_UNDEFINED);
}
xbee_cmd_set_callback( request, xbee_cmd_callback, NULL);
xbee_cmd_send( request);
}
}
}
int loadSettings() {
int rc = 0;
char *buf[bufsize], *tok;
openSettingsRead(settingsFileName);
if (pSettingsFile != NULL) {
while (fgets(buf, bufsize, pSettingsFile) != NULL) {
/*Here we tokenize our string and scan for " \n" characters*/
for (tok = strtok(buf, " \n"); tok; tok = strtok(0, " \n")) {
parseParameter(tok);
}
} /*Continue until EOF is encoutered*/
closeSettings();
} else {
fputs("File error", stderr);
rc = -1;
}
return rc;
}
bool pscli::LexParser::parseOne(std::string input){
if(input.size() < 1)
return true;
bool success = true;
if(input.size() >= 2 && input[0] == '-' && input[1] != '-'){
success &= parseShortOption(input.substr(1));
}else if(input.size() >= 4 && input[0] == '-' && input[1] == '-'){
success &= parseLongOption(input.substr(2));
}else if(input[0] != '-'){
success &= parseParameter(input);
}else{
pscli::Error::syntaxError();
return false;
}
return success;
}
int Distributer::getHashedPartitionForParameter(ByteBuffer ¶mBuffer, int parameterId){
int index = 5;//offset
bool wasNull;
std::string name = paramBuffer.getString(index, wasNull);
//Skip procedure name and size, client data
index += sizeof(int32_t) + name.size() + sizeof(int64_t);
//get number of parameters
paramBuffer.getInt16(index);
index += 2;
//partition key must be the first
if (parameterId > 0)
return -1;//throw
return parseParameter(paramBuffer, index);
}
void Services::parseParameters(vector<string> & args)
{
for(unsigned int i = 0; i < args.size(); i++){
parseParameter(args[i]);
}
}
