void setDeltaTWithPythonFunctionObject::readParameters(const dictionary &dict)
{
    readCode(dict,"init",initCode_);
    readCode(dict,"deltaT",deltaTCode_);

    pythonInterpreterWrapper::executeCode(
        initCode_,
        false
    );
}
void writeAndEndPythonFunctionObject::readParameters(const dictionary &dict)
{
    readCode(dict,"init",initCode_);
    readCode(dict,"condition",conditionCode_);

    pythonInterpreterWrapper::executeCode(
        initCode_,
        false
    );
}
bool pythonIntegrationFunctionObject::read(const dictionary& dict)
{
    Pbug << "read" << endl;

    readCode(dict,"start",startCode_);
    readCode(dict,"end",endCode_);
    readCode(dict,"execute",executeCode_);
    readCode(dict,"write",writeCode_,false);

#ifdef FOAM_FUNCTIONOBJECT_HAS_SEPARATE_WRITE_METHOD_AND_NO_START
    return start();
#else
    return true;
#endif
}
void writeIfPythonFunctionObject::readParameters(const dictionary &dict)
{
    readCode(dict,"initVariables",initCode_);
    readCode(dict,"startWrite",writeCode_);
    if(writeControlMode()==scmWriteUntilSwitch) {
        readCode(dict,"stopWrite",stopWriteCode_);
    }
    if(cooldownMode()==cdmRetrigger) {
        readCode(dict,"stopCooldown",stopCooldownCode_);
    }

    pythonInterpreterWrapper::executeCode(
        initCode_,
        false
    );
}
예제 #5
0
파일: unpack.c 프로젝트: btyy77c/C-language
/**
   Start of program.  Accepts input from console with name of files to read and name of
  files to write.  Checks files for reading/writing.  Then, calls on other methods to read
  through the file and uncompress the file.

  @param argc - number of commands user submitted
  @param argv - string text for each command from user
  @return Sucessfull end of the program
*/
int main( int argc, char *argv[] )
{
  //Default file which contains the "dictionary" of words
  char *wordFile = "words.txt";

  //Open file from agrs
  FILE *input;
  FILE *output;

  //Check to make sure user entered the correct number of arguments
  if ( argc < ( ARGS - 1 ) || argc > ARGS ){
    fprintf(stderr, "usage: unpack <compressed.raw> <output.txt> [word_file.txt]\n" );
    exit( EXIT_FAILURE );
  }

  //Optional input.  If user enters optional file name, program will use it
  if ( argc == ARGS ) {
    wordFile = argv[ ARGS - 1 ];
  }

  //Create wordList for our "dictionary"
  WordList *wordList = readWordList( wordFile );

  //Open file for reading.  Procduces error if file cannot open.
  if ( ( input = fopen( argv[ 1 ], "r" ) ) == NULL  ){
    fprintf(stderr, "Can't open file: %s\n", argv[ 1 ] );
    fprintf(stderr, "usage: unpack <compressed.raw> <output.txt> [word_file.txt]\n" );
    exit( EXIT_FAILURE );
  //Open file for writing.  Produces error if file cannot open.
  } else if ( ( output = fopen( argv[ 2 ], "w" ) ) == NULL  ){
    fprintf(stderr, "Can't open file: %s\n", argv[ 2 ] );
    fprintf(stderr, "usage: unpack <compressed.raw> <output.txt> [word_file.txt]\n" );
    exit( EXIT_FAILURE );
  }

  //Variable to hold leftover binary code
  PendingBits pending = { 0, 0 };

  //Loop that runs through file, writting letters to the writer file
  int number;
  //Continues to call method until method returns -1
  while ( (number = readCode( &pending, input ) ) != -1 ){
    //Prints words unless number is -1 or -2
    if ( number != -1 &&  number != -2 ){
      fprintf(output, "%s", wordList->words[ number ] );
    }
  }

  //free wordList
  freeWordList( wordList );

  //Close file
  fclose( input );
  fclose( output );

  return EXIT_SUCCESS;
}
예제 #6
0
파일: shell.c 프로젝트: gajewskies/shell
void prompt(char *command)
{
	char buffer[100] = {'\0'};
	int i = 0;
	static bool blockCode = false;
	static int blocks = 0;

	if (blockCode == false && blocks == 0)
	{
		printf(">>> ");
	}
	else
	{
		printf("... ");
	}

	fgets (buffer, 100, stdin);

	if (strncmp(buffer, "exit()", 6) == 0)
	{
		int status;
		status = remove("./c_code_temp.c");
		if (status == 1)
		{
			error("Failure to remove file");
		}
		exit(1);
	}

	if (strncmp(buffer, "read()", 6) == 0)
	{
		readCode();
	}

	if (strncmp(buffer, "help()", 6) == 0)
	{
		help();
	}

	if (strchr(buffer, '{') != NULL)
	{
		blockCode = true;
		blocks++;
	}
	else if(strchr(buffer, '}') != NULL)
	{
		blockCode = false;
		blocks--;
	}

	for (i = 0; i < 100; i++)
	{
		command[i] = buffer[i];
	}
}
예제 #7
0
bool Playlist::play() {
    char playCode[CODE_LENGTH + 1];
    bool ok = readCode(playIndex, playCode);

    if(ok) {
        playChirpCode(playCode);
        isFirst = false;
    }

    return ok;
}
  bool
internalizeOneObjectFile(objectFileListType *objectFile)
{
	FILE		*objectFildes;
	int		 magic;
	int		 mode;
	addressType	 startAddress;
	addressType	 endAddress;

	currentFileName = objectFile->name;
	if ((objectFildes = fopen(objectFile->name, "r")) == NULL) {
		error(CANT_OPEN_OBJECT_FILE_ERROR, objectFile->name);
		perror("Unix says");
		return(FALSE);
	}
	if (verbose)
		printf("internalizing %s:\n", objectFile->name);
	if ((magic = readWord(objectFildes, objectFile->name)) != 0xFFFF) {
		error(BAD_OBJECT_FILE_ERROR, objectFile->name);
		return(FALSE);
	}
	mode = MODE_ABSOLUTE;
	for (;;) {
		startAddress = readWord(objectFildes, objectFile->name);
		if (startAddress == 0xFFFF) {
			if (mode == MODE_ABSOLUTE) {
				mode = MODE_RELOCATABLE;
				continue;
			} else {
				break;
			}
		}
		endAddress = readWord(objectFildes, objectFile->name);
		readCode(startAddress, endAddress, mode, objectFile,
			objectFildes);
	}
	readReservations(objectFile, objectFildes);
	readReferences(objectFile, objectFildes);
	readSymbols(objectFile, objectFildes);
	readExpressions(objectFile, objectFildes);
	readFunctions(objectFile, objectFildes);
	instantiateExpressionAndSymbolPointers(objectFile);
	if (readExpressionEntryPoint) {
		pc = entryPointExpression;
		putSymbolPointersIntoExpression();
		readExpressionEntryPoint = FALSE;
		haveExpressionEntryPoint = TRUE;
	}
	qsort(objectFile->symbolTable, objectFile->symbolCount,
		sizeof(symbolType *), compareSymbolValues);
	fclose(objectFildes);
	return(TRUE);
}
int main(int argc, char* argv[])
{
	if (argc == 4)
	{
		int socketDescriptor = createInetStreamSocket();
		connectToInetServer(socketDescriptor, PORT, argv[1]);
		
		printf("%sConnected successful.%s\n", BLUE, RESET_COLOR);

		Message message;
		strcpy(message, argv[2]);
		writeMessage(socketDescriptor, message, sizeof(message));
		printf("I've requested for: \"%s\"\n", message);

		Code size = 4;
		readCode(socketDescriptor, &size);

		printf("Code: %d\n", size);

		if (size == FILE_NOT_FOUND)
		{
			printf("%sError, file not found.%s\n", RED, RESET_COLOR);
		}
		else
		{
			Message message;
			int fileDescriptor = creat(argv[3], 0777);
			while (size > 0)
			{
				int readCode = readMessage(socketDescriptor, &message, sizeof(message));
				int writeCode = writeMessage(fileDescriptor, message, readCode);
				//write(1, message, readCode);
				size -= readCode;
			}
			close(fileDescriptor);
		}
		
		close(socketDescriptor);
		printf("%sServer connexion closed, socket closed.%s\n", RED, RESET_COLOR);
	}
	else
	{
		perror("Invalid sintax. Use: ClienteRemoto IP SERVER_FILE CLIENT_FILE\n");
		exit(-1);
	}
}
예제 #10
0
// IBridge初始化方法
void IBridge::Init(int _myArgc, char* _myArgv[]) {
	// 没有附加参数就进入命令行模式
	if (_myArgc == 1) {
		cout << NEWLINE
		  << "SSQL Interpreter v1.0" << NEWLINE
			<< "Copyright Group 12 of CAS 2012 SYSU" << NEWLINE
			<< "-----------------------------------------" << NEWLINE
			<< endl;
		this->sourcePath = _myArgv[0];
		this->iType = RunType::RUN_CONSOLE;
	}
	// 否则是读文件的情况
	else {
		this->sourcePath = _myArgv[1];
		this->iType = RunType::RUN_INFILE;
		this->sourceCode = readCode(this->sourcePath);
	}
}
예제 #11
0
void Playlist::printAsScript() {
    char buffer[max(max(TIME_STRING_LENGTH, CODE_LENGTH), MAX_SCRIPT_ADDRESS_LENGTH) + 1];

    AutoplayStructure autoplaySettings;
    getAutoplaySettings(&autoplaySettings);

    if(readScriptAddress(buffer)) {
        Serial.print('#');
        Serial.println(buffer);
        Serial.print('#');
        Serial.println(READ_FROM_PLAYLIST(updateFlags));
    }
    Serial.println('~'); // clear list

    Serial.print(':');
    bool porta = READ_FROM_PLAYLIST(porta) != 0;
    Serial.print(porta ? 'P' : 'U');
    Serial.println(READ_FROM_PLAYLIST(volume));

    if(autoplaySettings.count) {
        Serial.print('*');
        minutesToString(autoplaySettings.startMinute, buffer);
        Serial.print(buffer);

        if(autoplaySettings.count > 1) {
            Serial.print(' ');
            minutesToString(autoplaySettings.repeatMinutes, buffer);
            Serial.print(buffer);

            Serial.print(' ');
            Serial.print(autoplaySettings.count);
        }
        Serial.println();
    }

    Serial.print('.');
    Serial.print(autoplaySettings.order);
    Serial.println(autoplaySettings.interval);

    for(uint8_t ch = 0; ch < nChirps; ch++) {
        readCode(ch, buffer);
        Serial.println(buffer);
    }
}
예제 #12
0
/**
 * Create the shaders.
 *
 * @param  fileName   file name of shader. Path is assume to be the project.
 * @param  shaderType Can either be vertex shader or fragment shader.  The type
 *                    must correspond to the OpenGL shader types.
 * @param  shaderid   Shader identifier pointer.
 * @return            0 - if successful, -1 if error.
 */
int Shader::createShaderObj(char* fileName , int shaderType, GLuint *shaderid) {
  char *code = NULL;
  int rc = 0;

  // create a shader handle
  *shaderid = glCreateShader(shaderType);

  // read the code
  code = readCode(fileName);
  if (code == NULL) return(-1);

  // attach the source to the shaders
  glShaderSource(*shaderid, 1, &code, NULL);

  // compile the code
  glCompileShader(*shaderid);

  // check for errors
  glGetShaderiv(*shaderid, GL_COMPILE_STATUS, &rc);
  if (rc != GL_TRUE) {
    GLsizei length;
    GLsizei bufSize = 0;
    char *error = NULL;
    fprintf(stderr,"Error when creating a shader \n");
    //fputs("Error when creating a shader \n",stderr);
    glGetShaderiv(*shaderid, GL_INFO_LOG_LENGTH, &bufSize);
    error = (char *) malloc(bufSize*sizeof(char)+1);
    if (error != NULL) {
      glGetShaderInfoLog(*shaderid, bufSize, &length, error);
      fprintf(stderr,"%s \n", error);
    }
    if (error != NULL) free(error);
    rc = -1;
  } else rc = 0;

  if (code != NULL) free(code); // free the source code of the shader

  return(rc);

}
예제 #13
0
void inflate_data(State& ioState, uint8_t* ioOutputTab, const uint32_t iOutputSize)
{
    uint32_t anOutputPos = 0;

    // Reading the const write size addition value
    needBits(ioState, 8);
    dropBits(ioState, 4);
    uint16_t aWriteSizeConstAdd = readBits(ioState, 4) + 1;
    dropBits(ioState, 4);

    // Declaring our HuffmanTrees
    HuffmanTree aHuffmanTreeSymbol;
    HuffmanTree aHuffmanTreeCopy;

    while (anOutputPos < iOutputSize)
    {
        // Resetting Huffmantrees
        memset(&aHuffmanTreeSymbol, 0, sizeof(HuffmanTree));
        memset(&aHuffmanTreeCopy, 0, sizeof(HuffmanTree));

        // Reading HuffmanTrees
        parseHuffmanTree(ioState, aHuffmanTreeSymbol);
        parseHuffmanTree(ioState, aHuffmanTreeCopy);

        // Reading MaxCount
        needBits(ioState, 4);
        uint32_t aMaxCount = (readBits(ioState, 4) + 1) << 12;
        dropBits(ioState, 4);

        uint32_t aCurrentCodeReadCount = 0;

        while ((aCurrentCodeReadCount < aMaxCount) &&
               (anOutputPos < iOutputSize))
        {
            ++aCurrentCodeReadCount;

            // Reading next code
            uint16_t aCode = 0;
            readCode(aHuffmanTreeSymbol, ioState, aCode);

            if (aCode < 0x100)
            {
                ioOutputTab[anOutputPos] = static_cast<uint8_t>(aCode);
                ++anOutputPos;
                continue;
            }

            // We are in copy mode !
            // Reading the additional info to know the write size
            aCode -= 0x100;

            // write size
            div_t aCodeDiv4 = div(aCode, 4);

            uint32_t aWriteSize = 0;
            if (aCodeDiv4.quot == 0)
            {
                aWriteSize = aCode;
            }
            else if (aCodeDiv4.quot < 7)
            {
                aWriteSize = ((1 << (aCodeDiv4.quot - 1)) * (4 + aCodeDiv4.rem));
            }
            else if (aCode == 28)
            {
                aWriteSize = 0xFF;
            }
            else
            {
                throw exception::Exception("Invalid value for writeSize code.");
            }

            //additional bits
            if (aCodeDiv4.quot > 1 && aCode != 28)
            {
                uint8_t aWriteSizeAddBits = aCodeDiv4.quot - 1;
                needBits(ioState, aWriteSizeAddBits);
                aWriteSize |= readBits(ioState, aWriteSizeAddBits);
                dropBits(ioState, aWriteSizeAddBits);
            }
            aWriteSize += aWriteSizeConstAdd;

            // write offset
            // Reading the write offset
            readCode(aHuffmanTreeCopy, ioState, aCode);

            div_t aCodeDiv2 = div(aCode, 2);

            uint32_t aWriteOffset = 0;
            if (aCodeDiv2.quot == 0)
            {
                aWriteOffset = aCode;
            }
            else if (aCodeDiv2.quot < 17)
            {
                aWriteOffset = ((1 << (aCodeDiv2.quot - 1)) * (2 + aCodeDiv2.rem));
            }
            else
            {
                throw exception::Exception("Invalid value for writeOffset code.");
            }

            //additional bits
            if (aCodeDiv2.quot > 1)
            {
                uint8_t aWriteOffsetAddBits = aCodeDiv2.quot - 1;
                needBits(ioState, aWriteOffsetAddBits);
                aWriteOffset |= readBits(ioState, aWriteOffsetAddBits);
                dropBits(ioState, aWriteOffsetAddBits);
            }
            aWriteOffset += 1;

            uint32_t anAlreadyWritten = 0;
            while ((anAlreadyWritten < aWriteSize) &&
                   (anOutputPos < iOutputSize))
            {
                ioOutputTab[anOutputPos] = ioOutputTab[anOutputPos - aWriteOffset];
                ++anOutputPos;
                ++anAlreadyWritten;
            }
        }
    }
}
예제 #14
0
파일: unpack.c 프로젝트: jannelouisea/NCSU
/** Opens appropriate files and handles them
    @param argc number of command line arguments 
    @param argv array of command line arguments
    @return the exit status of the program
  */
int main( int argc, char *argv[] )
{
  char *wordFile = "words.txt";
  
  FILE *input;
  FILE *output;
  
  if ( argc < 3 || argc > 4 ) {
    fprintf( stderr, "usage: pack <input.txt> <compressed.raw> [wordfile.txt]\n" );
    exit( 1 );
  }
  input = fopen( argv[ 1 ], "rb" );
  if ( !input ) {
    printf( "usage: readFile <input-file>\n" );
    exit( 1 );
  }
  output = fopen( argv[ 2 ], "rw" );
  if ( !output ) {
    printf( "usage: readFile <input-file>\n" );
    exit( 1 );
  }
  if ( argc == 4 ) {
    wordFile = argv[ 3 ];
  }
  
  WordList *wordList = readWordList( wordFile );

#ifdef DEBUG
  // Report the entire contents of the word list, once it's built.
  printf( "---- word list -----\n" );
  for ( int i = 0; i < wordList->len; i++ )
    printf( "%d == %s\n", i, wordList->words[ i ] );
  printf( "--------------------\n" );
#endif

  // ... 

  // Read the contents of the whole file into one big buffer.  This could be more
  // efficient, but it simplifies the rest of the program.
  char *buffer = readFile( input );

  // Write out codes for everything in the buffer.
  int pos = 0;
  PendingBits pending = { 0, 0 };
  while ( buffer[ pos ] ) {
    // Get the next code.
    int code = bestCode( wordList, buffer + pos );
#ifdef DEBUG
    printf( "%d <- %s\n", code, wordList->words[ code ] );
#endif

    // Write it out and move ahead by the number of characters we just encoded.
  readCode( &pending, input );
    pos += strlen( wordList->words[ code ] );
  }

  // Write out any remaining bits in the last, partial byte.
  flushBits( &pending, output );

  // ...
  fclose( input );
  fclose( output );
  return EXIT_SUCCESS;
}
예제 #15
0
int main(int argc,char** argv)
	{
	int width;
	int height;
	
	const char* source;		// Source code
	cl_platform_id platform;	// Platform { CPU, GPU, FPGA }
	cl_device_id device;		// Device { GPU_ID }
	cl_context context;		// Context
	cl_command_queue queue;		// Queue 
	cl_int err;			// for error checking

	cl_event event[NR_KERNELS-1];	// must be ok for second kernel to run

	cl_program program;		// program
	cl_kernel kernels_code[NR_KERNELS];


	cl_mem bufferIN;	// data IN
	cl_mem bufferOUT;	// data OUT

	int* inputImage;	// input image
	int* outputImage;	// output image

	cl_uint *ptr;			// data to be shown
	size_t global_work_size;	// work size

	// get platform, get device, create context
	clGetPlatformIDs(1,&platform,NULL);
	clGetDeviceIDs(platform,COMPUTE,1,&device,NULL);
	context=clCreateContext(NULL,1,&device,NULL,NULL,NULL);
	queue=clCreateCommandQueue(context,device,0,NULL);

	
	
	// read data from file, allocate memory & copy
	inputImage=input_image(INPUT_IMAGE,&width,&height);
	
	bufferIN=clCreateBuffer(context,CL_MEM_READ_WRITE,width*height *sizeof(int),NULL,NULL);
	clEnqueueWriteBuffer(queue,bufferIN,1,0,width * height * sizeof(int),inputImage,0,0,0);

	bufferOUT= clCreateBuffer(context,CL_MEM_READ_WRITE,width*height *sizeof(int),NULL,NULL);	

	// read code from file / check code
	source=readCode(FILENAME);
	if(source==NULL)
		{
		printf("Error reading code. Exiting");
		return 1;
		}
	
	// init OPENCL program
	
	
	program=clCreateProgramWithSource(context,1,&source,NULL,&err);
	check(err,program,device);
	check(clBuildProgram(program,1,&device,NULL,NULL,NULL));


	// kernels
	for(int i=0;i<NR_KERNELS;i++)
		{
			kernels_code[i]=clCreateKernel(program,kernels[i],&err);
			check(err,program,device);
		}
	

	// pass args, execute OPENCL kernels
	global_work_size=width*height;

	for(int i=0;i<NR_KERNELS;i++)
	{	
		if((i+1)%2==0){
			check(clSetKernelArg(kernels_code[i],0,sizeof(bufferOUT),(void*)&bufferOUT));
			check(clSetKernelArg(kernels_code[i],1,sizeof(bufferIN),(void*)&bufferIN));
			check(clSetKernelArg(kernels_code[i],2,sizeof(int),(void*)&width));
			check(clSetKernelArg(kernels_code[i],3,sizeof(int),(void*)&height));
			}
		else {
			check(clSetKernelArg(kernels_code[i],0,sizeof(bufferIN),(void*)&bufferIN));
			check(clSetKernelArg(kernels_code[i],1,sizeof(bufferOUT),(void*)&bufferOUT));
			check(clSetKernelArg(kernels_code[i],2,sizeof(int),(void*)&width));
			check(clSetKernelArg(kernels_code[i],3,sizeof(int),(void*)&height));
			}
	}

	

	
	size_t global_work[2];
	global_work[0]=width;
	global_work[1]=height;

	// enqueue / run all kernels (pipeline in this case)

	// start first kernel
	check(clEnqueueNDRangeKernel(queue,kernels_code[0],2,NULL,global_work,NULL,0,NULL,&event[0]));

	// run all the rest (n-2)
	for(int i=1;i<NR_KERNELS-1;i++)
		check(clEnqueueNDRangeKernel(queue,kernels_code[i],2,NULL,global_work,NULL,i,event,&event[i]));

	// start last kernel
	if(NR_KERNELS>2)
	check(clEnqueueNDRangeKernel(queue,kernels_code[NR_KERNELS-1],2,NULL,global_work,NULL,NR_KERNELS-1,event,NULL));
		
	
	// finish queue
	check(clFinish(queue));
	 
	if(NR_KERNELS%2==1)
    		outputImage= (int*)clEnqueueMapBuffer(queue,bufferOUT,CL_TRUE,CL_MAP_READ,0,width*height*sizeof(int),0,NULL,NULL,NULL);
	else 
		outputImage= (int*)clEnqueueMapBuffer(queue,bufferIN,CL_TRUE,CL_MAP_READ,0,width*height*sizeof(int),0,NULL,NULL,NULL);
    	
    	output_image(OUTPUT_IMAGE,outputImage,width,height);
	return 0;
}
void executeIfPythonFunctionObject::readParameters(const dictionary &dict)
{
    readCode(dict,"condition",conditionCode_);
}