void loadConf(char **src , const char* fileName)
{

	char buf[BUF_SIZE] = "";
	unsigned int read_size = 0;

	FILE *file = NULL;
	if(fopen_s(&file , fileName , "r"))
	{
		printf("找不到%s\n" , fileName);
		return;
	}
	while(1)
	{
		//每次少读一个字符,最后一个字符给'\0'
		read_size = fread(buf , 1 , BUF_SIZE - 1 , file);
		buf[read_size] = '\0';
		if( BUF_SIZE - 1 > read_size )
		{
			appendStr(src , buf);
			break;
		}
		appendStr(src , buf );
	}
	fclose(file);
}
void ActiveContours::runSDF() {

    dout << endl << "--------Running SDF ("<< width << "," << height << ")" << endl;
    bool norm = false;
    try {
        // Create the program from source
        if (!usingOGL) {
            //If we are not using the OpenGL texture, then we write it from the array.
            err = queue->enqueueWriteImage(img_in, CL_FALSE, origin, region, 0, 0, (void*) arr_img_in, 0, &evImgInWrt);
        }

        queue->finish();

        //Writes the mask as the original value for 
        err = queue->enqueueWriteBuffer(buf_mask, 
                CL_FALSE, 0, sizeof (float) *width*height, (void*) arr_buf_mask, 0, &evImgSegWrt);
        //        err = queue->enqueueWriteImage(img_mask, CL_FALSE, origin, region, 0, 0, (void*) arr_img_phi, 0, &evImgSegWrt);

        char* sdfPath = (char*) "images/SDF/CurrentRun/"; //Path to save SDF images

        if (WRITE) {//Writes the original mask
            string fileName = appendStr(sdfPath, (char*) "MASK.png");
            ImageManager::writeGrayScaleImage((char*) fileName.c_str(), arr_buf_mask, FIF_PNG, width, height, norm);
            if (PRINT_IMG_VAL) {
                cout << "Mask: " << endl;
                ImageManager::printImage(width, height, arr_buf_mask, 1);
            }
            cout << "--------------------Computing the SDF..." << endl;
        }

        vecWriteImage.push_back(evImgSegWrt);

        SignedDistFunc sdfObj;

        //        It reads from img_mask the mask, and writes into img_phi the output
        evSDF = sdfObj.runSDFBuf(&clMan, SDFmethod, buf_mask, buf_sdf, max_warp_size, width, height, evImgSegWrt, sdfPath);
        vecEvSDF.push_back(evSDF);

        if (WRITE) {// Saves the SDF result as an image
            cout << "Saving SDF result..." << endl;
            string fileName = appendStr(sdfPath, (char*) "SDFResult.png");

            //Reads from buf_sdf (GPU) and writes to arr_img_out (Host)
            res = queue->enqueueReadBuffer(buf_sdf, CL_TRUE, 0, sizeof (float) *width*height, (void*) arr_img_out, &vecEvSDF, 0);
            // Prints image into png file
            ImageManager::writeGrayScaleImage((char*) fileName.c_str(), arr_img_out, FIF_PNG, width, height,norm);
            if (PRINT_IMG_VAL) {
                ImageManager::printImage(width, height, arr_img_out, 1);
            }
        }

        queue->finish(); //Be sure we finish
        dout << "Out of ActiveContours initialization ......." << endl;

    } catch (cl::Error ex) {
        clMan.printError(ex);
        return;
    }
}
Exemple #3
0
char * appendPinStatus(char *buffer, io_pin_e pin) {
	char *ptr = appendStr(buffer, getPinShortName(pin));
	int state = getOutputPinValue(pin);
	// todo: should we handle INITIAL_PIN_STATE?
	if (state) {
		return appendStr(ptr, ":Y ");
	} else {
		return appendStr(ptr, ":n ");
	}
}
Exemple #4
0
static char * prepareCltIatTpsLine(char *buffer) {
	char *ptr = buffer;
	*ptr++ = 'C';
	ptr = ftoa(ptr, getCoolantTemperature(), 10.0f);

	ptr = appendStr(ptr, " C");
	ptr = ftoa(ptr, getIntakeAirTemperature(), 10.0f);

	ptr = appendStr(ptr, " TP");
	ptr = itoa10(ptr, (int) getTPS());
	return ptr;
}
Exemple #5
0
static void set_defaults(ImageInfo *ii)
{
    // default filename
    char *basename = get_basename(ii->filename);
    char *def = appendStr(basename, "_aoi");
    if (strncmp_case(def, "LED-", 4) == 0 ||
        strncmp_case(def, "IMG-", 4) == 0 ||
        strncmp_case(def, "TRL-", 4) == 0 ||
        strncmp_case(def, "VOL-", 4) == 0)
    {
        char *tmp = STRDUP(def+4);
        free(def);
        def = tmp;
    }
    free(basename);
    put_string_to_entry("filename_entry", def);
    free(def);

    // default directory
    char *dir = get_dirname(ii->filename);
    if (dir && strlen(dir) > 0)
        put_string_to_entry("dir_entry", dir);
    else
        put_string_to_entry("dir_entry", "");
    FREE(dir);

    // default data to save (Pixel Values)
    set_combo_box_item("data_combobox", 0);
}
static char * prepareCltIatTpsLine(Engine *engine, char *buffer) {
	char *ptr = buffer;
	*ptr++ = 'C';

	ptr = appendStr(ptr, " TP");
	ptr = itoa10(ptr, (int) getTPS(PASS_ENGINE_PARAMETER_F));
	return ptr;
}
static char * prepareVBattMapLine(engine_configuration_s *engineConfiguration, char *buffer) {
	char *ptr = buffer;
	*ptr++ = 'V';
	ptr = ftoa(ptr, getVBatt(PASS_ENGINE_PARAMETER_F), 10.0f);

	ptr = appendStr(ptr, " M");
	ptr = ftoa(ptr, getRawMap(), 10.0f);
	return ptr;
}
Exemple #8
0
static char * prepareVBattMapLine(char *buffer) {
	char *ptr = buffer;
	*ptr++ = 'V';
	ptr = ftoa(ptr, getVBatt(), 10.0f);

	ptr = appendStr(ptr, " M");
	ptr = ftoa(ptr, getRawMap(), 10.0f);
	return ptr;
}
void joinList(SLIST *strList, struct String *dest)
{
	strList->cur = strList->head;
	while(strList->cur != NULL) {
		appendStr(dest, strList->cur->str);
		appendChar(dest, ' ');
		strList->cur = strList->cur->next;
	}
	strList->cur = NULL;
}
void AccessLog::log( const char * pVHostName, int len, HttpConnection* pConn )
{
    if ( pVHostName )
    {
        m_buf.append( '[' );
        appendStr( pVHostName, len );
        m_buf.append( ']' );
        m_buf.append( ' ' );
    }
    log( pConn );
}
Exemple #11
0
static char * prepareInfoLine(char *buffer) {
	char *ptr = buffer;

	ptr = appendStr(ptr, algorithmStr[engineConfiguration->algorithm]);

	ptr = appendStr(ptr, " ");
	ptr = appendStr(ptr, ignitionModeStr[engineConfiguration->ignitionMode]);

	ptr = appendStr(ptr, " ");
	ptr = appendStr(ptr, injectionModeStr[engineConfiguration->injectionMode]);

	ptr = appendStr(ptr, " ");
	ptr = appendStr(ptr, idleModeStr[engineConfiguration->idleMode]);

	ptr = appendStr(ptr, " ");
	return ptr;
}
static char * prepareInfoLine(engine_configuration_s *engineConfiguration, char *buffer) {
	char *ptr = buffer;

	ptr = appendStr(ptr, " ");
	ptr = appendStr(ptr, ignitionModeStr[engineConfiguration->ignitionMode]);

	ptr = appendStr(ptr, " ");
	ptr = appendStr(ptr, injectionModeStr[engineConfiguration->injectionMode]);

	ptr = appendStr(ptr, " ");
	ptr = appendStr(ptr, idleModeStr[engineConfiguration->idleMode]);

	ptr = appendStr(ptr, " ");
	return ptr;
}
Exemple #13
0
int getVirtualSlot(struct p11Slot_t *slot, int index, struct p11Slot_t **vslot)
{
	struct p11Slot_t *newslot;
	char postfix[3];

	FUNC_CALLED();

	if ((index < 0) || (index > sizeof(slot->virtualSlots) / sizeof(*slot->virtualSlots)))
		FUNC_FAILS(CKR_ARGUMENTS_BAD, "Index must not exceed size of virtual slot list");

	if (slot->primarySlot)
		FUNC_FAILS(CKR_ARGUMENTS_BAD, "Slot is a virtual slot");

	if (slot->virtualSlots[index]) {
		*vslot = slot->virtualSlots[index];
		FUNC_RETURNS(CKR_OK);
	}

	newslot = (struct p11Slot_t *) calloc(1, sizeof(struct p11Slot_t));

	if (newslot == NULL)
		FUNC_FAILS(CKR_HOST_MEMORY, "Out of memory");

	*newslot = *slot;
	newslot->token = NULL;
	newslot->next = NULL;
	newslot->primarySlot = slot;

	/* If we already have a pre-allocated slot id, then assign the next id value */
	if (slot->id != 0)
		newslot->id = slot->id + index + 1;

	slot->virtualSlots[index] = newslot;

	postfix[0] = '.';
	postfix[1] = '2' + index;
	postfix[2] = 0;

	appendStr(newslot->info.slotDescription, sizeof(slot->info.slotDescription), postfix);

	addSlot(&context->slotPool, newslot);

	*vslot = newslot;
	FUNC_RETURNS(CKR_OK);
}
/**
 * Runs the SDF from the initialized mask. 
 */
void ActiveContours::runSDF() {
	
	buf_size = width*height*depth;//Local variable of the buffer size

    try {
        queue->finish();//We need to finish everything that it was queued before
		
        //Writes the mask stored in 'arr_buf_mask' into the cl::Buffer 'buf_mask' 
        err = queue->enqueueWriteBuffer(buf_mask, CL_FALSE, 0, 
				sizeof (unsigned char)*buf_size, (void*) arr_buf_mask, 0, &evImgSegWrt);
		
        char* sdfPath = (char*) "images/SDF/"; //Path to save SDF images
		
        if (WRITE) {//Writes the original mask
        //if (false) {//Writes the original mask
			dout << "******** Writing original mask .... " << endl;
            string folder = appendStr(sdfPath, (char*) "OriginalMask/");
			ImageManager::write3DImageSDF( (char*) folder.c_str(), arr_buf_mask, width, height, depth);
		}
		

        SignedDistFunc sdfObj;
		
		dev_max_work_items = 512;
		dout << "Max warpsize for SDF: " << dev_max_work_items << endl;
        // It reads from buf_mask the mask, and writes into buf_phi the output
        evSDF_newPhi = sdfObj.run3DSDFBuf(&clMan, buf_mask, buf_phi, dev_max_work_items, width, 
				height, depth, evImgSegWrt, sdfPath);
		
		if (WRITE) {// Saves the SDF result as an image
			cout << "--------------------Displaying some values of the SDF..." << endl;
			vecEvPrevPrinting.clear();
			vecEvPrevPrinting.push_back(evSDF_newPhi);
			//printBuffer(buf_phi, 10, vecEvPrevPrinting);
			printBuffer(buf_phi, width*height*2, 0, width, height, vecEvPrevPrinting);
		}

        if (WRITE) {// Saves the SDF result as an image
            dout << "Saving SDF result..." << endl;
            string folder = appendStr(sdfPath, (char*) "SDFOutput/");
			
			vecEvPrevPrinting.push_back(evSDF_newPhi);
			//Reads from buf_phi (GPU) and writes to arr_img_out (Host)
            res = queue->enqueueReadBuffer(buf_phi, CL_TRUE, 0, sizeof (float) *buf_size, 
					(void*) arr_img_out, &vecEvPrevPrinting, 0);
			// Prints image into png file
			ImageManager::write3DImage((char*) folder.c_str(), arr_img_out, width, height, depth, 0);
        }
		
		vecEvPrevCurvature.push_back(evSDF_newPhi);

        // Copying result to GL 3d Texture
		err = queue->enqueueAcquireGLObjects(&cl_textures, NULL, &evAcOGL);
		queue->finish();

        dout << "Initializing origin and region with " << width << "," << height << "," << depth << endl;
        origin.push_back(0); origin.push_back(0); origin.push_back(0);
        region.push_back(width); region.push_back(height); region.push_back(depth);

        queue->enqueueCopyBufferToImage(buf_phi, img_phi_gl, (size_t)0, origin, 
                            region,  &vecEvPrevCurvature, &evAcOGL);

		err = queue->enqueueReleaseGLObjects(&cl_textures, NULL, 0);

        dout << "Out of ActiveContours initialization  SDF computed!......." << endl;
		
    } catch (cl::Error ex) {
        clMan.printError(ex);
        return;
    }
}
Exemple #15
0
int extraction(char *host, char *path, SLIST *wordList, SLIST *urlList)
{
	int	conn;
	char buff[(BUFFSIZE + 1)] = {0};
	int	len;
	
	struct String *htmlString = createStr(); //Contains raw html pulled from web page
	struct String *cleanString = createStr(); //Contains the truncated html code 
	struct String *baseURL = createStr(); //Contains the url in the <base href = "">

	/* contact the web server */
	conn = socketClient(host, HTTPPORT);
	if (conn < 0) {
		exit(1);
	}

	/* send an HTTP/1.1 request to the webserver */
	sprintf(buff, "GET %s HTTP/1.1\r\nHost: %s\r\n", path, host);
	strcat(buff, "User-Agent: self-module\r\n");
	strcat(buff, "Accept: text/html,application/xhtml+xml\r\n");
	strcat(buff, "Accept-Language: en-us,en;q=0.5\r\n");
	//	strcat(buff, "Accept-Encoding: gzip,defalte\r\n");
	strcat(buff, "Accept-Charset: ISO-8859-1,utf-8;q=0.7\r\n");
	strcat(buff, "Keep-Alive: 115\r\n");
	strcat(buff, "Connection: keep-alive\r\n");
	strcat(buff, "\r\n");

	len = strlen(buff);
	(void) send(conn, buff, len, 0);

	/* convert all data received into chunks, append it to htmlString */
	while((len = recv(conn, buff, BUFFSIZE, 0)) > 0) {
		appendLit(htmlString, buff);
		memset(buff, 0, BUFFSIZE);
	}

	//Parsing base url
	if (-1 == parseBaseURL(baseURL, htmlString)) {
		printf("Could not locate base url.\n");
		return -1;
	}	
	
	//Parsing url links
	//printf("Building url link list.\n");
	buildLinkList(urlList, htmlString, baseURL);
	//Add the url that the crawler parsed the html from
	urlList->key = createStr();
	appendStr(urlList->key, baseURL);

	//creating word list
	appendStr(cleanString, htmlString);
	
	//cleaning html string by replacing all non-alphanumeric characters with spaces.
	truncateStr(cleanString);
	charSplit(wordList, cleanString, ' ');
	wordList->key = createStr();
	appendStr(wordList->key, baseURL);
		
	//cleaning word list based on existing stop words
	//printf("Started removing stop words.\n");
	rmStopWords(wordList);
	
	//free up memory
	//printf("Extraction: destroying htmlString, cleanString, & baseURL.\n");
	destroyStr(htmlString);
	destroyStr(cleanString);
	destroyStr(baseURL);
	
	return 0;
} 
Exemple #16
0
//PrettyPrinting type names
PCCOR_SIGNATURE PrettyPrintType(
    PCCOR_SIGNATURE typePtr,            // type to convert,     
    CQuickBytes *out,                   // where to put the pretty printed string   
    IMDInternalImport *pIMDI,           // ptr to IMDInternal class with ComSig
    DWORD formatFlags /*= formatILDasm*/)
{
    mdToken  tk;    
    const char* str;    
    int typ;
    CQuickBytes tmp;
    CQuickBytes Appendix;
    BOOL Reiterate;
    int n;

    do {
        Reiterate = FALSE;
        switch(typ = *typePtr++) {    
            case ELEMENT_TYPE_VOID          :   
                str = "void"; goto APPEND;  
            case ELEMENT_TYPE_BOOLEAN       :   
                str = "bool"; goto APPEND;  
            case ELEMENT_TYPE_CHAR          :   
                str = "char"; goto APPEND; 
            case ELEMENT_TYPE_I1            :   
                str = "int8"; goto APPEND;  
            case ELEMENT_TYPE_U1            :   
                str = "uint8"; goto APPEND; 
            case ELEMENT_TYPE_I2            :   
                str = "int16"; goto APPEND; 
            case ELEMENT_TYPE_U2            :   
                str = "uint16"; goto APPEND;    
            case ELEMENT_TYPE_I4            :   
                str = "int32"; goto APPEND; 
            case ELEMENT_TYPE_U4            :   
                str = "uint32"; goto APPEND;    
            case ELEMENT_TYPE_I8            :   
                str = "int64"; goto APPEND; 
            case ELEMENT_TYPE_U8            :   
                str = "uint64"; goto APPEND;    
            case ELEMENT_TYPE_R4            :   
                str = "float32"; goto APPEND;   
            case ELEMENT_TYPE_R8            :   
                str = "float64"; goto APPEND;   
            case ELEMENT_TYPE_U             :   
                str = "native uint"; goto APPEND;   
            case ELEMENT_TYPE_I             :   
                str = "native int"; goto APPEND;    
            case ELEMENT_TYPE_OBJECT        :   
                str = "object"; goto APPEND;    
            case ELEMENT_TYPE_STRING        :   
                str = "string"; goto APPEND;    
            case ELEMENT_TYPE_TYPEDBYREF        :   
                str = "typedref"; goto APPEND;    
            APPEND: 
                appendStr(out, (char*)str);
                break;  

            case ELEMENT_TYPE_VALUETYPE    :   
                if ((formatFlags & FormatKwInNames) != 0) 
                    str = "valuetype ";   
                else str = "";
                goto DO_CLASS;  
            case ELEMENT_TYPE_CLASS         :   
                if ((formatFlags & FormatKwInNames) != 0) 
                    str = "class "; 
                else str = "";
                goto DO_CLASS;  

            DO_CLASS:
                appendStr(out, (char*)str);
                typePtr += CorSigUncompressToken(typePtr, &tk); 
                if(IsNilToken(tk))
                {
                    appendStr(out, "[ERROR! NIL TOKEN]");
                }
                else PrettyPrintClass(out, tk, pIMDI, formatFlags);
                break;  

            case ELEMENT_TYPE_SZARRAY    :   
                insertStr(&Appendix,"[]");
                Reiterate = TRUE;
                break;
            
            case ELEMENT_TYPE_ARRAY       :   
                {   
                typePtr = PrettyPrintType(typePtr, out, pIMDI, formatFlags);
                unsigned rank = CorSigUncompressData(typePtr);  
                    // <TODO> what is the syntax for the rank 0 case? </TODO> 
                if (rank == 0) {
                    appendStr(out, "[BAD: RANK == 0!]");
                }
                else {
                    _ASSERTE(rank != 0);
#ifdef _PREFAST_
#pragma warning(push)
#pragma warning(disable:22009) // "Suppress PREfast warnings about integer overflow"
// PREFAST warns about using _alloca in a loop.  However when we're in this switch case we do NOT
// set Reiterate to true, so we only execute through the loop once!
#pragma warning(disable:6263) // "Suppress PREfast warnings about stack overflow due to _alloca in a loop."
#endif
                    int* lowerBounds = (int*) _alloca(sizeof(int)*2*rank);
                    int* sizes       = &lowerBounds[rank];  
                    memset(lowerBounds, 0, sizeof(int)*2*rank); 
                    
                    unsigned numSizes = CorSigUncompressData(typePtr);  
                    _ASSERTE(numSizes <= rank);
                        unsigned i;
                    for(i =0; i < numSizes; i++)
                        sizes[i] = CorSigUncompressData(typePtr);   
                    
                    unsigned numLowBounds = CorSigUncompressData(typePtr);  
                    _ASSERTE(numLowBounds <= rank); 
                    for(i = 0; i < numLowBounds; i++)   
                        typePtr+=CorSigUncompressSignedInt(typePtr,&lowerBounds[i]); 
                    
                    appendChar(out, '[');    
                    if (rank == 1 && numSizes == 0 && numLowBounds == 0)
                        appendStr(out, "...");  
                    else {
                        for(i = 0; i < rank; i++)   
                        {   
                            //if (sizes[i] != 0 || lowerBounds[i] != 0)   
                            {   
                                if (lowerBounds[i] == 0 && i < numSizes)    
                                    appendStrNum(out, sizes[i]);    
                                else    
                                {   
                                    if(i < numLowBounds)
                                    {
                                        appendStrNum(out, lowerBounds[i]);  
                                        appendStr(out, "...");  
                                        if (/*sizes[i] != 0 && */i < numSizes)  
                                            appendStrNum(out, lowerBounds[i] + sizes[i] - 1);   
                                    }
                                }   
                            }   
                            if (i < rank-1) 
                                appendChar(out, ',');    
                        }   
                    }
                    appendChar(out, ']'); 
#ifdef _PREFAST_
#pragma warning(pop)
#endif
                }
                } break;    

            case ELEMENT_TYPE_VAR        :   
                appendChar(out, '!');
                n  = CorSigUncompressData(typePtr);
                appendStrNum(out, n);
                break;

            case ELEMENT_TYPE_MVAR        :   
                appendChar(out, '!');    
                appendChar(out, '!');    
                n  = CorSigUncompressData(typePtr);
                appendStrNum(out, n);
                break;

            case ELEMENT_TYPE_FNPTR :   
                appendStr(out, "method ");  
                appendStr(out, "METHOD"); // was: typePtr = PrettyPrintSignature(typePtr, 0x7FFF, "*", out, pIMDI, NULL);
                break;

            case ELEMENT_TYPE_GENERICINST :
            {
              typePtr = PrettyPrintType(typePtr, out, pIMDI, formatFlags);
              if ((formatFlags & FormatSignature) == 0)
                  break;

              if ((formatFlags & FormatAngleBrackets) != 0)
                  appendStr(out, "<");
              else
                  appendStr(out,"[");
              unsigned numArgs = CorSigUncompressData(typePtr);    
              bool needComma = false;
              while(numArgs--)
              {
                  if (needComma)
                      appendChar(out, ',');
                  typePtr = PrettyPrintType(typePtr, out, pIMDI, formatFlags);
                  needComma = true;
              }
              if ((formatFlags & FormatAngleBrackets) != 0)
                  appendStr(out, ">");
              else
                  appendStr(out,"]");
              break;
            }

            case ELEMENT_TYPE_PINNED	:
                str = " pinned"; goto MODIFIER;
            case ELEMENT_TYPE_PTR           :
                str = "*"; goto MODIFIER;
            case ELEMENT_TYPE_BYREF         :
                str = "&"; goto MODIFIER;
            MODIFIER:
                insertStr(&Appendix, str);
                Reiterate = TRUE;
                break;  

            default:    
            case ELEMENT_TYPE_SENTINEL      :   
            case ELEMENT_TYPE_END           :   
                //_ASSERTE(!"Unknown Type");
                if(typ)
                {
                    char sz[64];
                    sprintf_s(sz,COUNTOF(sz),"/* UNKNOWN TYPE (0x%X)*/",typ);
                    appendStr(out, sz);
                }
                break;  
        } // end switch
    } while(Reiterate);
    if (Appendix.Size() > 0)
        appendStr(out,asString(&Appendix));

    return(typePtr);    
}
Exemple #17
0
const char* PrettyPrintClass(
    CQuickBytes *out,                   // where to put the pretty printed string   
    mdToken tk,					 		// The class token to look up 
    IMDInternalImport *pIMDI,           // ptr to IMDInternalImport class with ComSig
    DWORD formatFlags /*= formatILDasm*/)
{
    if(tk == mdTokenNil)  // Zero resolution scope for "somewhere here" TypeRefs
    {
        appendStr(out,"[*]");
        return(asString(out));
    }
    if (!pIMDI->IsValidToken(tk))
    {
        char str[1024];
        sprintf_s(str,COUNTOF(str)," [ERROR: INVALID TOKEN 0x%8.8X] ",tk);
        appendStr(out, str);
        return(asString(out));
    }
    switch (TypeFromToken(tk))
    {
        case mdtTypeRef:
        case mdtTypeDef:
            {
                const char *nameSpace = 0;  
                const char *name = 0;
                mdToken tkEncloser = mdTokenNil;
                
                if (TypeFromToken(tk) == mdtTypeRef)
                {
                    if ((formatFlags & FormatAssembly) && FAILED(pIMDI->GetResolutionScopeOfTypeRef(tk, &tkEncloser)) || 
                        FAILED(pIMDI->GetNameOfTypeRef(tk, &nameSpace, &name)))
                    {
                        char str[1024];
                        sprintf_s(str, COUNTOF(str), " [ERROR: Invalid TypeRef record 0x%8.8X] ", tk);
                        appendStr(out, str);
                        return asString(out);
                    }
                }
                else 
                {
                    if (((formatFlags & FormatNamespace) == 0) || FAILED(pIMDI->GetNestedClassProps(tk,&tkEncloser)))
                    {
                        tkEncloser = mdTypeDefNil;
                    }
                    if (FAILED(pIMDI->GetNameOfTypeDef(tk, &name, &nameSpace)))
                    {
                        char str[1024];
                        sprintf_s(str, COUNTOF(str), " [ERROR: Invalid TypeDef record 0x%8.8X] ", tk);
                        appendStr(out, str);
                        return asString(out);
                    }
                }
                MAKE_NAME_IF_NONE(name,tk);
                if((tkEncloser == mdTokenNil) || RidFromToken(tkEncloser))
                {
                    if (TypeFromToken(tkEncloser) == mdtTypeRef || TypeFromToken(tkEncloser) == mdtTypeDef)
                    {
                        PrettyPrintClass(out,tkEncloser,pIMDI, formatFlags);
                        if (formatFlags & FormatSlashSep)
                            appendChar(out, '/');    
                        else
                            appendChar(out, '+');
                        //nameSpace = ""; //don't print namespaces for nested classes!
                    }
                    else if (formatFlags & FormatAssembly)
                    {
                        PrettyPrintClass(out,tkEncloser,pIMDI, formatFlags);
                    }
                }
                if(TypeFromToken(tk)==mdtTypeDef)
                {
                    unsigned L = (unsigned)strlen(name)+1;
                    char* szFN = NULL;
                    if(((formatFlags & FormatNamespace) != 0) && nameSpace && *nameSpace)
                    {
                        const char* sz = nameSpace;
                        L+= (unsigned)strlen(sz)+1;
                        szFN = new char[L];
                        sprintf_s(szFN,L,"%s.",sz);
                    }
                    else
                    {
                        szFN = new char[L];
                        *szFN = 0;
                    }
                    strcat_s(szFN,L, name);
                    appendStr(out, szFN);
                    if (szFN) delete[] (szFN);
                }
                else
                {
                    if (((formatFlags & FormatNamespace) != 0) && nameSpace && *nameSpace) {
                        appendStr(out, nameSpace);  
                        appendChar(out, '.');    
                    }

                    appendStr(out, name);
                }
            }
            break;

        case mdtAssemblyRef:
            {
                LPCSTR	szName = NULL;
                pIMDI->GetAssemblyRefProps(tk,NULL,NULL,&szName,NULL,NULL,NULL,NULL);
                if(szName && *szName)
                {
                    appendChar(out, '[');    
                    appendStr(out, szName);
                    appendChar(out, ']');    
                }
            }
            break;
        case mdtAssembly:
            {
                LPCSTR	szName = NULL;
                pIMDI->GetAssemblyProps(tk,NULL,NULL,NULL,&szName,NULL,NULL);
                if(szName && *szName)
                {
                    appendChar(out, '[');    
                    appendStr(out, szName);
                    appendChar(out, ']');    
                }
            }
            break;
        case mdtModuleRef:
            {
                LPCSTR	szName = NULL;
                pIMDI->GetModuleRefProps(tk,&szName);
                if(szName && *szName)
                {
                    appendChar(out, '[');    
                    appendStr(out, ".module ");
                    appendStr(out, szName);
                    appendChar(out, ']');    
                }
            }
            break;

        case mdtTypeSpec:
            {
                ULONG cSig;
                PCCOR_SIGNATURE sig;
                if (FAILED(pIMDI->GetSigFromToken(tk, &cSig, &sig)))
                {
                    char str[128];
                    sprintf_s(str, COUNTOF(str), " [ERROR: Invalid token 0x%8.8X] ", tk);
                    appendStr(out, str);
                }
                else
                {
                    PrettyPrintType(sig, out, pIMDI, formatFlags);
                }
            }
            break;

        case mdtModule:
            break;
        
        default:
            {
                char str[128];
                sprintf_s(str,COUNTOF(str)," [ERROR: INVALID TOKEN TYPE 0x%8.8X] ",tk);
                appendStr(out, str);
            }
    }
    return(asString(out));
}
Exemple #18
0
static void appendStrNum(CQuickBytes *out, int num) {
    char buff[16];  
    sprintf_s(buff, COUNTOF(buff), "%d", num);   
    appendStr(out, buff);   
}
Exemple #19
0
char * tftp_get(IPAddr server, char * file,
		void(*receiver)(Octet *, Uint32)) {
  UDP *sendBuf = (UDP *)enet_alloc();
  UDPPort local = udp_allocPort(NULL);
  sendBuf->ip.dest = hton(server);
  sendBuf->udp.dest = htons(tftpPort);
  sendBuf->udp.srce = htons(local);
  TFTPHeader * sendHeader = (TFTPHeader *)&(sendBuf->data[0]);
  sendHeader->op = htons(tftpOpRRQ);
  Uint32 pos = tftpPosName;
  appendStr(sendBuf, &pos, file);
  appendStr(sendBuf, &pos, "octet");
  Uint32 blockNum;
  for (blockNum = 1; ; blockNum++) {
    Uint32 recvLen;
    IP * recvBuf;
    TFTPHeader * recvHeader;
    Octet * recvData;
    Uint32 dataLen;
    int tries;
    for (tries = 0; ; tries++) {
      if (tries >= retryLimit) {
	udp_freePort(local);
	enet_free((Enet *)sendBuf);
	return "Timeout";
      }
      udp_send(sendBuf, pos);
      recvLen = udp_recv(&recvBuf, local, timeout);
      if (recvBuf) {
	recvHeader = (TFTPHeader *)udp_payload(recvBuf);
	recvData = udp_payload(recvBuf) + tftpPosData;
	dataLen = recvLen - tftpPosData;
	if (ntohs(recvHeader->op) == tftpOpData) {
	  if (ntohs(recvHeader->block) == blockNum) break;
	} else if (ntohs(recvHeader->op) == tftpOpError) {
	  recvData[dataLen-1] = 0; // in case server omitted it
	  udp_freePort(local);
	  enet_free((Enet *)sendBuf);
	  int slen = strlen((char *)recvData);
	  char *s = malloc(slen+1);
	  strncpy(s, (char *)recvData, slen+1);
	  udp_recvDone(recvBuf);
	  return s;
	} else {
	  udp_freePort(local);
	  enet_free((Enet *)sendBuf);
	  udp_recvDone(recvBuf);
	  return "Unknown opcode from server";
	}
	// ignore other stuff - excess retransmissions
	udp_recvDone(recvBuf);
      }
    }
    // The only way to get here is by receiving the expected data block
    receiver(recvData, dataLen);
    UDPHeader *recvUDPHeader = (UDPHeader *)ip_payload(recvBuf);
    sendBuf->udp.dest = recvUDPHeader->srce;
    sendHeader->op = htons(tftpOpAck);
    sendHeader->block = recvHeader->block;
    pos = tftpPosData;
    udp_recvDone(recvBuf);
    if (dataLen < 512) break;
  }
  udp_send(sendBuf, pos); // final ACK, sent without retransmissions
  udp_freePort(local);
  enet_free((Enet *)sendBuf);
  return NULL;
}
QString convertTimeDate(const QString &mac_format, const QDateTime &datetime)
{
    QDate date = datetime.date();
    QTime time = datetime.time();
    QString str;
    if (mac_format.contains('%'))
    {
        const QChar *chars = mac_format.constData();
        bool is_percent = false;
        int length = 0;
        bool error = false;
        while ((*chars).unicode() && !error)
        {
            if (is_percent)
            {
                is_percent = false;
                switch ((*chars).unicode())
                {
                case L'%':
                    str += *chars;
                    break;
                case L'a':
                    appendStr(str, QDate::shortDayName(date.dayOfWeek()), length);
                    break;
                case L'A':
                    appendStr(str, QDate::longDayName(date.dayOfWeek()), length);
                    break;
                case L'b':
                    appendStr(str, QDate::shortMonthName(date.day()), length);
                    break;
                case L'B':
                    appendStr(str, QDate::longMonthName(date.day()), length);
                    break;
                case L'c':
                    appendStr(str, QLocale::system().toString(datetime), length);
                    break;
                case L'd':
                    appendInt(str, date.day(), length > 0 ? length : 2);
                    break;
                case L'e':
                    appendInt(str, date.day(), length);
                    break;
                case L'F':
                    appendInt(str, time.msec(), length > 0 ? length : 3);
                    break;
                case L'H':
                    appendInt(str, time.hour(), length > 0 ? length : 2);
                    break;
                case L'I':
                    appendInt(str, time.hour() % 12, length > 0 ? length : 2);
                    break;
                case L'j':
                    appendInt(str, date.dayOfYear(), length > 0 ? length : 3);
                    break;
                case L'm':
                    appendInt(str, date.month(), length > 0 ? length : 2);
                    break;
                case L'M':
                    appendInt(str, time.minute(), length > 0 ? length : 2);
                    break;
                case L'p':
                    appendStr(str, time.hour() < 12 ? "AM" : "PM", length);
                    break;
                case L'S':
                    appendInt(str, time.second(), length > 0 ? length : 2);
                    break;
                case L'w':
                    appendInt(str, date.dayOfWeek(), length);
                    break;
                case L'x':
                    appendStr(str, QLocale::system().toString(date), length);
                    break;
                case L'X':
                    appendStr(str, QLocale::system().toString(time), length);
                    break;
                case L'y':
                    appendInt(str, date.year() % 100, length > 0 ? length : 2);
                    break;
                case L'Y':
                    appendInt(str, date.year(), length > 0 ? length : 4);
                    break;
                case L'Z':
                    // It should be localized, isn't it?..
                    appendStr(str, SystemInfo::instance()->timezone(), length);
                    break;
                case L'z':
                {
                    int offset = SystemInfo::instance()->timezoneOffset();
                    appendInt(str, (offset/60)*100 + offset%60, length > 0 ? length : 4);
                    break;
                }
                default:
                    if ((*chars).isDigit())
                    {
                        is_percent = true;
                        length *= 10;
                        length += (*chars).digitValue();
                    }
                    else
                        error = true;
                }
            }
            else if (*chars == '%')
            {
                length = 0;
                is_percent = true;
            }
            else
                str += *chars;
            chars++;
        }
        if (!error)
            return str;

        str.clear();
    }

    WeekDate week_date(date);
    QChar last;
    QChar cur;
    int length = 0;
    bool quote = false;
    const QChar *chars = mac_format.constData();
    forever
    {
        cur = *chars;
        if (cur == '\'')
        {
            if (*(chars+1) == '\'')
            {
                chars++;
                str += cur;
            }
            else
            {
                if (!quote)
                    finishStr(str, week_date, date, time, last, length);
                quote = !quote;
            }
            length = 0;
        }
        else if (quote)
            str += cur;
        else
        {
            if (cur == last)
                length++;
            else
            {
                finishStr(str, week_date, date, time, last, length);
                length = 1;
            }
        }
        if (!chars->unicode())
            break;

        last = cur;
        chars++;
    }
    return str;
}
void AccessLog::log( HttpConnection* pConn )
{
    int  n;
    HttpReq*  pReq  = pConn->getReq();
    HttpResp* pResp = pConn->getResp();
    const char * pUser = pReq->getAuthUser();
    long contentWritten = pResp->getBodySent();
    const ClientInfo * pInfo = pConn->getClientInfo();
    const char * pAddr = pInfo->getHostName();
    pResp->needLogAccess( 0 );
    if ( m_iPipedLog )
    {
        if ( !m_pManager )
            return;
        m_pAppender = m_pManager->getAppender();
        if ( !m_pAppender )
            return;
    }
    
    if ( m_pCustomFormat )
        return customLog( pConn );
    
    if (( pAddr )&&( *pAddr ))
    {
        n = pInfo->getHostNameLen();
    }
    else
    {
        pAddr = pInfo->getAddrString();
        n = pInfo->getAddrStrLen();
    }
    m_buf.appendNoCheck( pAddr, n );
    if ( ! *pUser )
    {
        m_buf.appendNoCheck( " - - ", 5 );
    }
    else
    {
        n = safe_snprintf( m_buf.end(), 70, " - \"%s\" ", pUser );
        m_buf.used( n );
    }

    DateTime::getLogTime( pConn->getReqTime(), m_buf.end() );
    m_buf.used( 30 );
    n = pReq->getOrgReqLineLen();
    char * pOrgReqLine = (char *)pReq->getOrgReqLine();
    if ( pReq->getVersion() == HTTP_1_0 )
        *(pOrgReqLine + n - 1) = '0';
    if (( n > 4096 )||( m_buf.available() < 100 + n ))
    {
        flush();
        m_pAppender->append( pOrgReqLine, n );
    }
    else
        m_buf.appendNoCheck(pOrgReqLine, n );
    m_buf.append( '"' );
    m_buf.appendNoCheck(
        HttpStatusCode::getCodeString( pReq->getStatusCode() ), 5 );
    if ( contentWritten == 0 )
    {
        m_buf.append( '-' );
    }
    else
    {
        n = safe_snprintf( m_buf.end(), 20, "%ld", contentWritten );
        m_buf.used( n );
    }
    if ( getAccessLogHeader() & LOG_REFERER )
    {
        m_buf.append( ' ' );
        appendStr( pReq->getHeader( HttpHeader::H_REFERER ),
                pReq->getHeaderLen( HttpHeader::H_REFERER ));
    }
    if ( getAccessLogHeader() & LOG_USERAGENT )
    {
        m_buf.append( ' ' );
        appendStr( pReq->getHeader( HttpHeader::H_USERAGENT),
                pReq->getHeaderLen( HttpHeader::H_USERAGENT) );
    }
    if ( getAccessLogHeader() & LOG_VHOST )
    {
        m_buf.append( ' ' );
        appendStr( pReq->getHeader( HttpHeader::H_HOST ),
                pReq->getHeaderLen( HttpHeader::H_HOST ) );
    }
    m_buf.append( '\n' );
    if (( m_buf.available() < MAX_LOG_LINE_LEN )
        ||!asyncAccessLog() )
    {
        flush();
    }
}
// Input:
//   meta_parameters *meta_sar--  SAR geometry to subset the DEM
//   const char *demImg       --  DEM data filename
//   const char *demMeta      --  DEM metadata filename
//   int pad                  --  number of lines to add at the top/bottom/left/right
//   double tolerance         --  how accurate the approximation mapping needs to be,
//                                in units of pixels
//   const char *output_name  --  output filename (basename)
//   int test_mode            --  adds checks for the accuracy of the mapping, and
//                                does some unit testing
// Output:
//   no output parameters, the output is the output_name files (.img and .meta)
// Return Value:
//   return TRUE on success, FALSE on fail
//
int make_gr_dem_ext(meta_parameters *meta_sar, const char *demImg, const char *demMeta,
                    int pad, double tolerance, const char *output_name, int test_mode)
{
  if (test_mode)
    test_interp();
  
  asfPrintStatus("Reading DEM...\n");
  meta_parameters *meta_dem = meta_read(demMeta);
  float *demData = NULL;
  FloatImage *fi_dem = NULL;

  int dnl = meta_dem->general->line_count;
  int dns = meta_dem->general->sample_count;

  if (0)
    demData = read_dem(meta_dem, demImg);
  else
    fi_dem = float_image_new_from_metadata(meta_dem, demImg);

  if (demData)
    asfPrintStatus("Old method: reading entire DEM.\n");
  if (fi_dem)
    asfPrintStatus("New method: float image\n");
  if (demData && fi_dem)
    asfPrintError("Impossible.\n");

  char *outImg = appendExt(output_name, ".img");
  char *output_name_tmp, *outImgTmp;

  // do not do DEM smoothing if the DEM pixel size is better or close to the
  // SAR image's pixel size.
  int do_averaging = TRUE;
  if (meta_dem->general->y_pixel_size - 10 < meta_sar->general->y_pixel_size)
    do_averaging = FALSE;
  asfPrintStatus("Averaging: %s (DEM %f, SAR: %f)\n", do_averaging ? "YES" : "NO",
                 meta_dem->general->y_pixel_size,
                 meta_sar->general->y_pixel_size);
  if (do_averaging) {
    output_name_tmp = appendStr(output_name, "_unsmoothed");
    outImgTmp = appendExt(output_name_tmp, ".img");
  }
  else {
    output_name_tmp = STRDUP(output_name);
    outImgTmp = STRDUP(outImg);
  }

  // add the padding if requested
  meta_parameters *meta_out = meta_copy(meta_sar);
  meta_out->general->line_count += pad*2;
  meta_out->general->sample_count += pad*2;
  meta_out->general->start_line -= pad;
  meta_out->general->start_sample -= pad;

  // fixing up the output metadata.  Note that we must keep the SAR section
  // intact since that specifies our geometry which is the whole point of
  // this exercise.
  strcpy(meta_out->general->basename, meta_dem->general->basename);
  strcpy(meta_out->general->sensor, MAGIC_UNSET_STRING);
  strcpy(meta_out->general->processor, MAGIC_UNSET_STRING);
  strcpy(meta_out->general->mode, MAGIC_UNSET_STRING);
  strcpy(meta_out->general->sensor_name, MAGIC_UNSET_STRING);
  meta_out->general->image_data_type = DEM;
  meta_out->general->radiometry = MAGIC_UNSET_INT;
  strcpy(meta_out->general->acquisition_date, meta_dem->general->acquisition_date);
  meta_out->general->orbit = MAGIC_UNSET_INT;
  meta_out->general->orbit_direction = MAGIC_UNSET_CHAR;
  meta_out->general->frame = MAGIC_UNSET_INT;
  meta_out->general->band_count = 1;
  strcpy(meta_out->general->bands, "DEM");

  int nl = meta_out->general->line_count;
  int ns = meta_out->general->sample_count;

  // finding the right grid size
  int size = find_grid_size(meta_sar, meta_dem, 512, .1*tolerance);

  asfPrintStatus("Creating ground range image...\n");

  float *buf = MALLOC(sizeof(float)*ns*size);
  FILE *fpOut = FOPEN(outImgTmp, "wb");

  // these are for tracking the quality of the bilinear interp
  // not used if test_mode is false
  int num_out_of_tol = 0;
  int num_checked = 0;
  int num_bad = 0;
  double max_err = 0;
  double avg_err = 0;

  int ii, jj;
  for (ii=0; ii<nl; ii += size) {
    int line_lo = ii;
    int line_hi = ii + size;

    for (jj=0; jj<ns; jj += size) {
      double lines[4], samps[4];
      
      int samp_lo = jj;
      int samp_hi = jj + size;

      get_interp_params(meta_sar, meta_dem, line_lo, line_hi, samp_lo, samp_hi,
                        lines, samps);

      int iii, jjj;
      for (iii=0; iii<size; ++iii) {
        for (jjj=0; jjj<size && jj+jjj<ns; ++jjj) {
          int index = iii*ns + jj + jjj;
          assert(index < ns*size);

          double line_out, samp_out;
          xy_interp(ii+iii, jj+jjj, line_lo, line_hi, samp_lo, samp_hi, lines, samps,
                    &line_out, &samp_out);

          // random checking of the quality of our interpolations
          if (test_mode && iii%11==0 && jjj%13==0) {
            double real_line, real_samp; 
            sar_to_dem(meta_sar, meta_dem, ii+iii, jj+jjj, &real_line, &real_samp);

            double err = hypot(real_line - line_out, real_samp - samp_out);

            avg_err += err;
            if (err > max_err)
              max_err = err;

            if (err > tolerance) {
              asfPrintStatus("Out of tolerance at %d,%d: (%f,%f) vs (%f,%f) -> %f\n",
                             ii+iii, jj+jjj, line_out, samp_out, real_line, real_samp,
                             err);
              ++num_out_of_tol;
            }
            if (err > .5) {
              asfPrintStatus("Error is larger than 1 pixel!\n");
              ++num_bad;
            }
            ++num_checked;
          }
          if (demData)
            buf[index] = interp_demData(demData, dnl, dns, line_out, samp_out);
          else if (fi_dem)
            buf[index] = interp_dem(fi_dem, line_out, samp_out);
          else
            asfPrintError("Oops.\n");
        }
      }
    }

    put_float_lines(fpOut, meta_out, ii, size, buf);
    asfPrintStatus("Completed %.1f%%  \r", 100.*ii/(double)nl);
  }
  asfPrintStatus("Completed 100%%   \n");

  if (test_mode) {
    asfPrintStatus("Tolerance was %f\n", tolerance);
    asfPrintStatus("%d/%d checked pixels had error exceeding tolerance. (%.1f%%)\n",
                   num_out_of_tol, num_checked, 100.*num_out_of_tol/(double)num_checked);
    asfPrintStatus("%d/%d checked pixels had error larger than half a pixel. (%.1f%%)\n",
                   num_bad, num_checked, 100.*num_bad/(double)num_checked);
    asfPrintStatus("Maximum error: %f pixels\n", max_err);
    avg_err /= (double)num_checked;
    asfPrintStatus("Average error: %f pixels\n", avg_err);
  }

  FCLOSE(fpOut);
  meta_write(meta_out, outImgTmp);

  meta_free(meta_out);
  meta_free(meta_dem);

  FREE(buf);
  FREE(demData);
  if (fi_dem)
    float_image_free(fi_dem);

  // now apply 3x3 filter
  if (do_averaging) {
    asfPrintStatus("Smoothing with 3x3 kernel ...\n");
    smooth(outImgTmp, outImg, 3, EDGE_TRUNCATE);
  }

  FREE(outImg);
  FREE(outImgTmp);
  FREE(output_name_tmp);

  return FALSE;
}
Exemple #23
0
void SSDBProtocolRequest::appendInt64(int64_t val)
{
    char str[30];
    snprintf(str, sizeof(str), "%lld", val);
    appendStr(str);
}
Exemple #24
0
void main(void)
{
	char s[256] = "C ";
	appendStr(s);
	printf("%s\n", s);
}