//-------------------------------------------------------------------------------------------------- static void ParseValue ( Parser_t* parserPtr, char c ) //-------------------------------------------------------------------------------------------------- { // Throw away whitespace until something else comes along. if (!isspace(c)) { if (c == '{') // Start of an object. { PushContext(parserPtr, LE_JSON_CONTEXT_OBJECT, GetEventHandler(parserPtr)); parserPtr->next = EXPECT_MEMBER_OR_OBJECT_END; Report(parserPtr, LE_JSON_OBJECT_START); } else if (c == '[') // Start of an array. { PushContext(parserPtr, LE_JSON_CONTEXT_ARRAY, GetEventHandler(parserPtr)); parserPtr->next = EXPECT_VALUE_OR_ARRAY_END; Report(parserPtr, LE_JSON_ARRAY_START); } else if (c == '"') { PushContext(parserPtr, LE_JSON_CONTEXT_STRING, GetEventHandler(parserPtr)); parserPtr->next = EXPECT_STRING; } else if (c == 't') { PushContext(parserPtr, LE_JSON_CONTEXT_TRUE, GetEventHandler(parserPtr)); AddToBuffer(parserPtr, c); parserPtr->next = EXPECT_TRUE; } else if (c == 'f') { PushContext(parserPtr, LE_JSON_CONTEXT_FALSE, GetEventHandler(parserPtr)); AddToBuffer(parserPtr, c); parserPtr->next = EXPECT_FALSE; } else if (c == 'n') { PushContext(parserPtr, LE_JSON_CONTEXT_NULL, GetEventHandler(parserPtr)); AddToBuffer(parserPtr, c); parserPtr->next = EXPECT_NULL; } else if (isdigit(c) || (c == '-')) { PushContext(parserPtr, LE_JSON_CONTEXT_NUMBER, GetEventHandler(parserPtr)); AddToBuffer(parserPtr, c); parserPtr->next = EXPECT_NUMBER; } else { Error(parserPtr, LE_JSON_SYNTAX_ERROR, "Unexpected character at beginning of value."); } } }
/* AppendParm: append the src file to current Buffer pb. Return appended len */ HTime AppendParm(char *src) { int i; char bf1[MAXSTRLEN]; char bf2[MAXSTRLEN]; short swidth[SMAX]; Boolean eSep; ParmBuf b, cb; Observation o; BufferInfo info; if((b = OpenBuffer(&iStack,src,0,srcFF,TRI_UNDEF,TRI_UNDEF))==NULL) HError(1050,"AppendParm: Config parameters invalid"); GetBufferInfo(b,&info); if(trace & T_KINDS ){ printf("Appending file %s format: %s [%s]->[%s]\n",src, Format2Str(info.srcFF), ParmKind2Str(info.srcPK,bf1), ParmKind2Str(info.tgtPK,bf2)); } if (tgtSampRate != info.tgtSampRate) HError(1032,"AppendParm: Input file %s has inconsistent sample rate",src); if ( BaseParmKind(tgtPK) != BaseParmKind(info.tgtPK)) HError(1032,"AppendParm: Input file %s has inconsistent tgt format",src); cb = (chopF)?ChopParm(b,st,en,info.tgtSampRate) : b; ZeroStreamWidths(swidth0,swidth); SetStreamWidths(info.tgtPK,info.tgtVecSize,swidth,&eSep); o = MakeObservation(&iStack, swidth, info.tgtPK, saveAsVQ, eSep); for (i=0; i < ObsInBuffer(cb); i++){ ReadAsTable(cb, i, &o); AddToBuffer(pb, o); } CloseBuffer(cb); return(i*info.tgtSampRate); }
int int_09_LAT(unsigned char code) { /*Veo que teclas estan oprimidas y modifico las variables *globales, en caso de ser las teclas scrolllock,capslock *o numlock */ char ascii; if( code==LSHIFT || code==RSHIFT) shift=1; else if( code==(LSHIFT | MASK) || code==(RSHIFT | MASK) ) shift=0; else if( code==CAPSLOCK ) caps=!caps; else if( code==NUMLOCK ) numlock=!numlock; else if( code==SCROLLLOCK ) scrolllock=!scrolllock; else if( IS_NUMPAD_KEY(code) && !numlock) return 0; else { if( IS_MAKE_CODE(code) && code<=CANT_KEYS) { ascii=ToAsciiLAT(code); if(IS_VALID_ASCII(ascii)) AddToBuffer(ascii); } } return 0; }
void *ReadInterruptInThread(void *devh) { libusb_device_handle *device = (libusb_device_handle*)devh; int bytes_transferred, success; int i = 0; BYTE data[64]; while (running) { //pthread_mutex_lock(&syncRoot); success = libusb_interrupt_transfer( device, INTERRUPT_IN_ENDPOINT, data, sizeof(data), &bytes_transferred, 5000); //pthread_mutex_unlock(&syncRoot); if (success == LIBUSB_SUCCESS) { if (verbose) { //DumpBytes(data, sizeof(data)); printf("HID SMBus Interrupt In: %u bytes transferred. ReportId: %02X\n", bytes_transferred, data[0]); } AddToBuffer(data, sizeof(data)); }// else { // fprintf(stderr, "ReadInterruptInThread: Error receiving interrupt report: %s (Bytes transferred: %d)\n", libusb_strerror(success), bytes_transferred); //} usleep(10 * 1000); // sleep for a sec to minimize lock contention } printf(BOLDGREEN "Receive thread stopped." RESET "\n"); }
static void ProcNonDiscardable( void ) /************************************/ { AddToBuffer( "nondiscardable", 14 ); ImplyFormat( FMT_WINDOWS ); // NotNecessary( "nondiscardable" ); }
int BufferedAnalogRead::Read() { if(!IsEnabled) return Value; BaseAnalogRead::Read(); AddToBuffer(Value); return Value; }
void Scanner::AtIdentifier() //判断其余字符 { while(isalnum(c) || c == '_') //字母数字或下划线 { AddToBuffer(c); //加入 ExtractChar(); //读取下一个字符,一直到不满足条件 } IdentifyAndMake(); }
//-------------------------------------------------------------------------------------------------- static void ParseString ( Parser_t* parserPtr, char c ) //-------------------------------------------------------------------------------------------------- { // See if this is a string terminating '"' character. if (c == '"') { if ((parserPtr->numBytes != 0) && (parserPtr->buffer[parserPtr->numBytes - 1] == '\\')) { // Escaped ", replace with ". parserPtr->buffer[parserPtr->numBytes - 1] = '"'; } else { // Make we have a valid UTF-8 string. if (!le_utf8_IsFormatCorrect(parserPtr->buffer)) { Error(parserPtr, LE_JSON_SYNTAX_ERROR, "String is not valid UTF-8."); } else { // Handling of the end of the string depends on the context. le_json_ContextType_t contextType = GetContext(parserPtr)->type; if (contextType == LE_JSON_CONTEXT_STRING) { Report(parserPtr, LE_JSON_STRING); PopContext(parserPtr); } else if (contextType == LE_JSON_CONTEXT_MEMBER) { Report(parserPtr, LE_JSON_OBJECT_MEMBER); parserPtr->next = EXPECT_COLON; } else { LE_FATAL("Unexpected context '%s' for string termination.", le_json_GetContextName(contextType)); } } } } else { AddToBuffer(parserPtr, c); } }
void FormatAppend(char* buffer, size_t buffer_size, const char* text, size_t* cursor) { char const* next = text; char ch = *(next++); while (ch != '\0') { AddToBuffer(ch, buffer, buffer_size, cursor); ch = *(next++); } /* Be sure to null terminate the generated string. */ if (buffer_size > 0) { buffer[SizeMin(*cursor, buffer_size - 1)] = '\0'; } }
void Scanner::AtInterger() { while (isdigit(c)) // { AddToBuffer(c); ExtractChar(); } /*if (tolower(c) == 'e' || (c == '.' && in.peek() != '.')) { AddToBuffer(c); ExtractChar(); EatRealFractPart(); }*/ MakeToken(INT_CONST); }
static int __gz_lines_iterator (lua_State *L) { gzFile zf = (gzFile) lua_topointer (L, lua_upvalueindex(1)); int ch = '\0'; char* ret; if (content_buffer_length == 0) ExtendBuffer (); else ResetBuffer (); #ifdef READ_LINE_ONE_BY_ONE while ( (ch = gzgetc(zf)) != -1 && ch != '\n') { AddToBuffer ((char) ch); } #else do { ret = gzgets (zf, content_buffer + BufferFill (), BufferFree ()); if (ret == Z_NULL) break; int l = strlen (content_buffer); content_length = l; if (l > 0) { ch = content_buffer[l - 1]; if (ch != '\n') ExtendBuffer (); else content_buffer[l-1] = '\0'; } } while (ret && ch != '\n'); #endif if (ch == '\n' || BufferFill () > 0) { if (ch == '\n') lua_pushstring (L, FinishBuffer ()); return 1; } else { return pushresult(L, &zf, NULL); } }
void Scanner::AtOperation() //运算符的判断 { bool match = false; if (!in.eof() && !isalnum(c) && c != '_'&&!isspace(c)) { AddToBuffer(c); if (TryToIdentify()) //判断关系操作符 for example <=此时为真 { match = true; ExtractChar(); } else ReduceBuffer(); } if (!match && !TryToIdentify()) throw "illegal expression"; }
/* ChopParm: return parm chopped to st and end. end = 0 means all */ ParmBuf ChopParm(ParmBuf b, HTime start, HTime end, HTime sampRate) { int stObs, endObs, nObs, i; HTime length; short swidth[SMAX]; Boolean eSep; ParmBuf cb; Observation o; BufferInfo info; length = ObsInBuffer(b) * sampRate; ClampStEn(length,&start,&end); if(start >= length) HError(1030,"ChopParm: Src file too short to get data from %.0f",start); if(trace & T_SEGMENT) printf("ChopParm: Extracting segment %.0f to %.0f\n",start,end); stObs = (int) (start/sampRate); endObs = (int) (end/sampRate); nObs = endObs -stObs; if(nObs <= 0) HError(1030,"ChopParm: Truncation options result in zero-length file"); GetBufferInfo(b,&info); ZeroStreamWidths(swidth0,swidth); SetStreamWidths(tgtPK,info.tgtVecSize,swidth,&eSep); o = MakeObservation(&cStack, swidth, info.tgtPK, saveAsVQ, eSep); if (saveAsVQ){ if (info.tgtPK&HASNULLE){ info.tgtPK=DISCRETE+HASNULLE; }else{ info.tgtPK=DISCRETE; } } cb = EmptyBuffer(&cStack, nObs, o, info); for (i=stObs; i < endObs; i++){ ReadAsTable(b, i, &o); AddToBuffer(cb, o); } CloseBuffer(b); if(chopF && labF) ChopLabs(tr,start,end); return(cb); }
/* OpenParmFile: open source parm file and return length */ HTime OpenParmFile(char *src) { int i; ParmBuf b, cb; short swidth[SMAX]; Boolean eSep; Observation o; BufferInfo info; if((b = OpenBuffer(&iStack,src,0,srcFF,TRI_UNDEF,TRI_UNDEF))==NULL) HError(1050,"OpenParmFile: Config parameters invalid"); GetBufferInfo(b,&info); srcSampRate = info.srcSampRate; tgtSampRate = info.tgtSampRate; srcPK = info.srcPK; tgtPK = info.tgtPK; cb = chopF?ChopParm(b,st,en,info.tgtSampRate):b; ZeroStreamWidths(swidth0,swidth); SetStreamWidths(info.tgtPK,info.tgtVecSize,swidth,&eSep); o = MakeObservation(&oStack, swidth, info.tgtPK, saveAsVQ, eSep); if (saveAsVQ){ if (info.tgtPK&HASNULLE){ info.tgtPK=DISCRETE+HASNULLE; }else{ info.tgtPK=DISCRETE; } } pb = EmptyBuffer(&oStack, ObsInBuffer(cb), o, info); for(i=0; i < ObsInBuffer(cb); i++){ ReadAsTable(cb, i, &o); AddToBuffer(pb, o); } CloseBuffer(cb); if( info.nSamples > 0 ) return(info.nSamples*srcSampRate); else return(ObsInBuffer(pb)*info.tgtSampRate); }
//-------------------------------------------------------------------------------------------------- static void ParseConstant ( Parser_t* parserPtr, char c, const char* expected ) //-------------------------------------------------------------------------------------------------- { AddToBuffer(parserPtr, c); if (strncmp(parserPtr->buffer, expected, parserPtr->numBytes) != 0) { char msg[256]; snprintf(msg, sizeof(msg), "Unexpected character '%c' (expected '%c' in '%s').", c, expected[parserPtr->numBytes - 1], expected); Error(parserPtr, LE_JSON_SYNTAX_ERROR, msg); } }
static void ProcReadOnly( void ) /******************************/ { AddToBuffer( "readonly", 8 ); }
static void ProcReadWrite( void ) /*******************************/ { AddToBuffer( "readwrite", 9 ); }
static void ProcDiscardable( void ) /*********************************/ { AddToBuffer( "discardable", 11 ); ImplyFormat( FMT_WINDOWS ); }
static void ProcFixed( void ) /***************************/ { AddToBuffer( "fixed", 5 ); ImplyFormat( FMT_WINDOWS ); }
static void ProcMoveable( void ) /*****************************/ { AddToBuffer( "moveable", 8 ); ImplyFormat( FMT_WINDOWS ); }
static void ProcNonConforming( void ) /***********************************/ { AddToBuffer( "nonconforming", 13 ); }
static void ProcConforming( void ) /********************************/ { AddToBuffer( "conforming", 10 ); }
static void ProcNoIopl( void ) /****************************/ { AddToBuffer( "noiopl", 6 ); }
static void ProcIopl( void ) /**************************/ { AddToBuffer( "iopl", 4 ); }
static void ProcExecuteRead( void ) /*********************************/ { AddToBuffer( "executeread", 11 ); }
static void ProcNonShared( void ) /*******************************/ { AddToBuffer( "nonshared", 9 ); }
static void ProcShared( void ) /****************************/ { AddToBuffer( "shared", 6 ); }
static void ProcLoadOnCall( void ) /********************************/ { AddToBuffer( "loadoncall", 10 ); }
/*----------------------------------------------------------------------------- - FUNCTION: PacketCheck - - DATE: November 21st, 2013 - - REVISIONS: - 2013/12/02 - Vincent - Created - - - DESIGNER: Vincent Lau - - PROGRAMMER: Vincent Lau - German Villarreal - - INTERFACE: BOOL PacketCheck(HWND hwnd, CHAR* packet) - - RETURNS: void, nothing. - - PARAMETERS: HWND hwnd - a dynamic char buffer that contains the whole file - CHAR* packet: 1024 bytes of data - - NOTES: This is a function that cecks the packet for data. - - -----------------------------------------------------------------------------*/ BOOL PacketCheck(HWND hwnd, CHAR* packet) { char* data = (CHAR*) malloc(1020); data[1020] = '\0'; int lengthOfData = strlen(data); //Make sure we're getting our own packets, not some other packet switch (packet[0]) { case SYN: break; default: // discard packet return FALSE; } switch (packet[1]) { case ENQ: bENQReceived = TRUE; //SendControl(hComm, ACK); bWantToSendACK = TRUE; // Set "what we're waiting for" flag to DC1 waitForType = DC1; break; case ACK: // check if we wanted an ACK if (waitForType == ACK) { // check if we're actually bidding for the line if (bWantLine) ReleaseSemaphore(hWaitForLineSemaphore, 1, NULL); else // check if we're sending a file ReleaseSemaphore(hACKWaitSemaphore, 1, NULL); } break; case DC1: //if we're waiting for a DC2 packet if(waitForType == DC2 || !ErrorCheck(packet+2))//pass data+crcbits { SendControl(hComm, NAK); break; } waitForType = DC2; bWantToSendACK = TRUE; GetData(packet, data); AddToBuffer(data); break; case DC2: // if we're waiting for a DC1 packet if (waitForType == DC1 || !ErrorCheck(packet+2)) { SendControl(hComm, NAK); break; } waitForType = DC1; bWantToSendACK = TRUE; GetData(packet, data); AddToBuffer(data); break; case NAK: //Set "What we're waiting for" flag to ACK waitForType = ACK; SendData(hComm, Packet); // send the previous packet break; case EOT: bENQReceived = FALSE; if (bENQToSend) { ReleaseSemaphore(hWaitForLineSemaphore, 1, NULL); break; } // GO back to IDLE state waitForType = ENQ; break; } return TRUE; }
static void ProcExecuteOnly( void ) /*********************************/ { AddToBuffer( "executeonly", 11 ); }