sola/scpi-parser.git

			@@ -53,7 +53,11 @@
			* @return number of bytes written
			*/
			static size_t writeData(scpi_t * context, const char * data, size_t len) {
			return context->interface->write(context, data, len);
			if (len > 0) {
			return context->interface->write(context, data, len);
			} else {
			return 0;
			}
			}

			/**
			@@ -129,6 +133,7 @@
			context->cmd_error = FALSE;
			context->output_count = 0;
			context->input_count = 0;
			context->arbitrary_reminding = 0;

			/* if callback exists - call command callback */
			if (cmd->callback != NULL) {
			@@ -214,7 +219,11 @@
			result &= processCommand(context);
			cmd_prev = state->programHeader;
			} else {
			SCPI_ErrorPush(context, SCPI_ERROR_UNDEFINED_HEADER);
			/* place undefined header with error */
			/* calculate length of errornouse header and trim \r\n */
			size_t r2 = r;
			while (r2 > 0 && (data[r2 - 1] == '\r' \|\| data[r2 - 1] == '\n')) r2--;
			SCPI_ErrorPushEx(context, SCPI_ERROR_UNDEFINED_HEADER, data, r2);
			result = FALSE;
			}
			}
			@@ -237,27 +246,53 @@
			/**
			* Initialize SCPI context structure
			* @param context
			* @param command_list
			* @param buffer
			* @param commands
			* @param interface
			* @param units
			* @param idn1
			* @param idn2
			* @param idn3
			* @param idn4
			* @param input_buffer
			* @param input_buffer_length
			* @param error_queue_data
			* @param error_queue_size
			*/
			void SCPI_Init(scpi_t * context) {
			if (context->idn[0] == NULL) {
			context->idn[0] = SCPI_DEFAULT_1_MANUFACTURE;
			}
			if (context->idn[1] == NULL) {
			context->idn[1] = SCPI_DEFAULT_2_MODEL;
			}
			if (context->idn[2] == NULL) {
			context->idn[2] = SCPI_DEFAULT_3;
			}
			if (context->idn[3] == NULL) {
			context->idn[3] = SCPI_DEFAULT_4_REVISION;
			}

			void SCPI_Init(scpi_t * context,
			const scpi_command_t * commands,
			scpi_interface_t * interface,
			const scpi_unit_def_t * units,
			const char * idn1, const char * idn2, const char * idn3, const char * idn4,
			char * input_buffer, size_t input_buffer_length,
			scpi_error_t * error_queue_data, int16_t error_queue_size) {
			memset(context, 0, sizeof (*context));
			context->cmdlist = commands;
			context->interface = interface;
			context->units = units;
			context->idn[0] = idn1;
			context->idn[1] = idn2;
			context->idn[2] = idn3;
			context->idn[3] = idn4;
			context->buffer.data = input_buffer;
			context->buffer.length = input_buffer_length;
			context->buffer.position = 0;
			SCPI_ErrorInit(context);
			SCPI_ErrorInit(context, error_queue_data, error_queue_size);
			}

			#if USE_DEVICE_DEPENDENT_ERROR_INFORMATION && !USE_MEMORY_ALLOCATION_FREE

			/**
			* Initialize context's
			* @param context
			* @param data
			* @param len
			* @return
			*/
			void SCPI_InitHeap(scpi_t * context,
			char * error_info_heap, size_t error_info_heap_length) {
			scpiheap_init(&context->error_info_heap, error_info_heap, error_info_heap_length);
			}
			#endif

			/**
			* Interface to the application. Adds data to system buffer and try to search
			@@ -476,13 +511,132 @@
			*/
			size_t SCPI_ResultText(scpi_t * context, const char * data) {
			size_t result = 0;
			size_t len = strlen(data);
			const char * quote;
			result += writeDelimiter(context);
			result += writeData(context, "\"", 1);
			// TODO: convert " to ""
			result += writeData(context, data, strlen(data));
			while ((quote = strnpbrk(data, len, "\""))) {
			result += writeData(context, data, quote - data + 1);
			result += writeData(context, "\"", 1);
			len -= quote - data + 1;
			data = quote + 1;
			}
			result += writeData(context, data, len);
			result += writeData(context, "\"", 1);
			context->output_count++;
			return result;
			}

			/**
			* SCPI-99:21.8 Device-dependent error information.
			* Write error information with the following syntax:
			* <Error/event_number>,"<Error/event_description>[;<Device-dependent_info>]"
			* The maximum string length of <Error/event_description> plus <Device-dependent_info>
			* is SCPI_STD_ERROR_DESC_MAX_STRING_LENGTH (255) characters.
			*
			* @param context
			* @param error
			* @return
			*/
			size_t SCPI_ResultError(scpi_t * context, scpi_error_t * error) {
			size_t result = 0;
			size_t outputlimit = SCPI_STD_ERROR_DESC_MAX_STRING_LENGTH;
			size_t step = 0;
			const char * quote;

			const char * data[SCPIDEFINE_DESCRIPTION_MAX_PARTS];
			size_t len[SCPIDEFINE_DESCRIPTION_MAX_PARTS];
			size_t i;

			data[0] = SCPI_ErrorTranslate(error->error_code);
			len[0] = strlen(data[0]);

			#if USE_DEVICE_DEPENDENT_ERROR_INFORMATION
			data[1] = error->device_dependent_info;
			#if USE_MEMORY_ALLOCATION_FREE
			len[1] = error->device_dependent_info ? strlen(data[1]) : 0;
			#else
			SCPIDEFINE_get_parts(&context->error_info_heap, data[1], &len[1], &data[2], &len[2]);
			#endif
			#endif

			result += SCPI_ResultInt32(context, error->error_code);
			result += writeDelimiter(context);
			result += writeData(context, "\"", 1);

			for (i = 0; (i < SCPIDEFINE_DESCRIPTION_MAX_PARTS) && data[i] && outputlimit; i++) {
			if (i == 1) {
			result += writeSemicolon(context);
			outputlimit -= 1;
			}
			if (len[i] > outputlimit) {
			len[i] = outputlimit;
			}

			while ((quote = strnpbrk(data[i], len[i], "\""))) {
			if ((step = quote - data[i] + 1) >= outputlimit) {
			len[i] -= 1;
			outputlimit -= 1;
			break;
			}
			result += writeData(context, data[i], step);
			result += writeData(context, "\"", 1);
			len[i] -= step;
			outputlimit -= step + 1;
			data[i] = quote + 1;
			if (len[i] > outputlimit) {
			len[i] = outputlimit;
			}
			}

			result += writeData(context, data[i], len[i]);
			outputlimit -= len[i];
			}
			result += writeData(context, "\"", 1);

			return result;
			}

			/**
			* Write arbitrary block header with length
			* @param context
			* @param len
			* @return
			*/
			size_t SCPI_ResultArbitraryBlockHeader(scpi_t * context, size_t len) {
			char block_header[12];
			size_t header_len;
			block_header[0] = '#';
			SCPI_UInt32ToStrBase((uint32_t) len, block_header + 2, 10, 10);

			header_len = strlen(block_header + 2);
			block_header[1] = (char) (header_len + '0');

			context->arbitrary_reminding = len;
			return writeData(context, block_header, header_len + 2);
			}

			/**
			* Add data to arbitrary block
			* @param context
			* @param data
			* @param len
			* @return
			*/
			size_t SCPI_ResultArbitraryBlockData(scpi_t * context, const void * data, size_t len) {

			if (context->arbitrary_reminding < len) {
			SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
			return 0;
			}

			context->arbitrary_reminding -= len;

			if (context->arbitrary_reminding == 0) {
			context->output_count++;
			}

			return writeData(context, (const char *) data, len);
			}

			/**
			@@ -492,20 +646,10 @@
			* @param len
			* @return
			*/
			size_t SCPI_ResultArbitraryBlock(scpi_t * context, const char * data, size_t len) {
			size_t SCPI_ResultArbitraryBlock(scpi_t * context, const void * data, size_t len) {
			size_t result = 0;
			char block_header[12];
			size_t header_len;
			block_header[0] = '#';
			SCPI_UInt32ToStrBase((uint32_t) len, block_header + 2, 10, 10);

			header_len = strlen(block_header + 2);
			block_header[1] = (char) (header_len + '0');

			result += writeData(context, block_header, header_len + 2);
			result += writeData(context, data, len);

			context->output_count++;
			result += SCPI_ResultArbitraryBlockHeader(context, len);
			result += SCPI_ResultArbitraryBlockData(context, data, len);
			return result;
			}

			@@ -555,7 +699,7 @@
			if (mandatory) {
			SCPI_ErrorPush(context, SCPI_ERROR_MISSING_PARAMETER);
			} else {
			parameter->type = SCPI_TOKEN_PROGRAM_MNEMONIC; // TODO: select something different
			parameter->type = SCPI_TOKEN_PROGRAM_MNEMONIC; /* TODO: select something different */
			}
			return FALSE;
			}
			@@ -990,7 +1134,7 @@
			break;
			}

			// TODO: return also parameter type (ProgramMnemonic, ArbitraryBlockProgramData, SingleQuoteProgramData, DoubleQuoteProgramData
			/* TODO: return also parameter type (ProgramMnemonic, ArbitraryBlockProgramData, SingleQuoteProgramData, DoubleQuoteProgramData */
			}

			return result;
			@@ -1126,6 +1270,15 @@
			return FALSE;
			}

			/*
			* Definition of BOOL choice list
			*/
			const scpi_choice_def_t scpi_bool_def[] = {
			{"OFF", 0},
			{"ON", 1},
			SCPI_CHOICE_LIST_END /* termination of option list */
			};

			/**
			* Read BOOL parameter (0,1,ON,OFF)
			* @param context
			@@ -1137,12 +1290,6 @@
			scpi_bool_t result;
			scpi_parameter_t param;
			int32_t intval;

			scpi_choice_def_t bool_options[] = {
			{"OFF", 0},
			{"ON", 1},
			SCPI_CHOICE_LIST_END /* termination of option list */
			};

			if (!value) {
			SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
			@@ -1156,7 +1303,7 @@
			SCPI_ParamToInt32(context, &param, &intval);
			*value = intval ? TRUE : FALSE;
			} else {
			result = SCPI_ParamToChoice(context, &param, bool_options, &intval);
			result = SCPI_ParamToChoice(context, &param, scpi_bool_def, &intval);
			if (result) {
			*value = intval ? TRUE : FALSE;
			}
			@@ -1351,6 +1498,7 @@
			}

			#if USE_COMMAND_TAGS

			/**
			* Return the .tag field of the matching scpi_command_t
			* @param context
			@@ -1391,3 +1539,294 @@
			scpi_bool_t SCPI_ParamErrorOccurred(scpi_t * context) {
			return context->cmd_error;
			}

			/**
			* Result binary array and swap bytes if needed (native endiannes != required endiannes)
			* @param context
			* @param array
			* @param count
			* @param item_size
			* @param format
			* @return
			*/
			static size_t produceResultArrayBinary(scpi_t * context, const void * array, size_t count, size_t item_size, scpi_array_format_t format) {

			if (SCPI_GetNativeFormat() == format) {
			switch (item_size) {
			case 1:
			case 2:
			case 4:
			case 8:
			return SCPI_ResultArbitraryBlock(context, array, count * item_size);
			default:
			SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
			return 0;
			}
			} else {
			size_t result = 0;
			size_t i;
			switch (item_size) {
			case 1:
			case 2:
			case 4:
			case 8:
			result += SCPI_ResultArbitraryBlockHeader(context, count * item_size);
			break;
			default:
			SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
			return 0;
			}

			switch (item_size) {
			case 1:
			result += SCPI_ResultArbitraryBlockData(context, array, count);
			break;
			case 2:
			for (i = 0; i < count; i++) {
			uint16_t val = SCPI_Swap16(((uint16_t*) array)[i]);
			result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
			}
			break;
			case 4:
			for (i = 0; i < count; i++) {
			uint32_t val = SCPI_Swap32(((uint32_t*) array)[i]);
			result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
			}
			break;
			case 8:
			for (i = 0; i < count; i++) {
			uint64_t val = SCPI_Swap64(((uint64_t*) array)[i]);
			result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
			}
			break;
			}

			return result;
			}
			}


			#define RESULT_ARRAY(func) do {\
			size_t result = 0;\
			if (format == SCPI_FORMAT_ASCII) {\
			size_t i;\
			for (i = 0; i < count; i++) {\
			result += func(context, array[i]);\
			}\
			} else {\
			result = produceResultArrayBinary(context, array, count, sizeof(*array), format);\
			}\
			return result;\
			} while(0)

			/**
			* Result array of signed 8bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayInt8(scpi_t * context, const int8_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultInt8);
			}

			/**
			* Result array of unsigned 8bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayUInt8(scpi_t * context, const uint8_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultUInt8);
			}

			/**
			* Result array of signed 16bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayInt16(scpi_t * context, const int16_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultInt16);
			}

			/**
			* Result array of unsigned 16bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayUInt16(scpi_t * context, const uint16_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultUInt16);
			}

			/**
			* Result array of signed 32bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayInt32(scpi_t * context, const int32_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultInt32);
			}

			/**
			* Result array of unsigned 32bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayUInt32(scpi_t * context, const uint32_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultUInt32);
			}

			/**
			* Result array of signed 64bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayInt64(scpi_t * context, const int64_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultInt64);
			}

			/**
			* Result array of unsigned 64bit integers
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayUInt64(scpi_t * context, const uint64_t * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultUInt64);
			}

			/**
			* Result array of floats
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayFloat(scpi_t * context, const float * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultFloat);
			}

			/**
			* Result array of doubles
			* @param context
			* @param array
			* @param count
			* @param format
			* @return
			*/
			size_t SCPI_ResultArrayDouble(scpi_t * context, const double * array, size_t count, scpi_array_format_t format) {
			RESULT_ARRAY(SCPI_ResultDouble);
			}

			/*
			* Template macro to generate all SCPI_ParamArrayXYZ function
			*/
			#define PARAM_ARRAY_TEMPLATE(func) do{\
			if (format != SCPI_FORMAT_ASCII) return FALSE;\
			for (o_count = 0; o_count < i_count; (*o_count)++) {\
			if (!func(context, &data[*o_count], mandatory)) {\
			break;\
			}\
			mandatory = FALSE;\
			}\
			return mandatory ? FALSE : TRUE;\
			}while(0)

			/**
			* Read list of values up to i_count
			* @param context
			* @param data - array to fill
			* @param i_count - number of elements of data
			* @param o_count - real number of filled elements
			* @param mandatory
			* @return TRUE on success
			*/
			scpi_bool_t SCPI_ParamArrayInt32(scpi_t * context, int32_t data, size_t i_count, size_t o_count, scpi_array_format_t format, scpi_bool_t mandatory) {
			PARAM_ARRAY_TEMPLATE(SCPI_ParamInt32);
			}

			/**
			* Read list of values up to i_count
			* @param context
			* @param data - array to fill
			* @param i_count - number of elements of data
			* @param o_count - real number of filled elements
			* @param mandatory
			* @return TRUE on success
			*/
			scpi_bool_t SCPI_ParamArrayUInt32(scpi_t * context, uint32_t data, size_t i_count, size_t o_count, scpi_array_format_t format, scpi_bool_t mandatory) {
			PARAM_ARRAY_TEMPLATE(SCPI_ParamUInt32);
			}

			/**
			* Read list of values up to i_count
			* @param context
			* @param data - array to fill
			* @param i_count - number of elements of data
			* @param o_count - real number of filled elements
			* @param mandatory
			* @return TRUE on success
			*/
			scpi_bool_t SCPI_ParamArrayInt64(scpi_t * context, int64_t data, size_t i_count, size_t o_count, scpi_array_format_t format, scpi_bool_t mandatory) {
			PARAM_ARRAY_TEMPLATE(SCPI_ParamInt64);
			}

			/**
			* Read list of values up to i_count
			* @param context
			* @param data - array to fill
			* @param i_count - number of elements of data
			* @param o_count - real number of filled elements
			* @param mandatory
			* @return TRUE on success
			*/
			scpi_bool_t SCPI_ParamArrayUInt64(scpi_t * context, uint64_t data, size_t i_count, size_t o_count, scpi_array_format_t format, scpi_bool_t mandatory) {
			PARAM_ARRAY_TEMPLATE(SCPI_ParamUInt64);
			}

			/**
			* Read list of values up to i_count
			* @param context
			* @param data - array to fill
			* @param i_count - number of elements of data
			* @param o_count - real number of filled elements
			* @param mandatory
			* @return TRUE on success
			*/
			scpi_bool_t SCPI_ParamArrayFloat(scpi_t * context, float data, size_t i_count, size_t o_count, scpi_array_format_t format, scpi_bool_t mandatory) {
			PARAM_ARRAY_TEMPLATE(SCPI_ParamFloat);
			}

			/**
			* Read list of values up to i_count
			* @param context
			* @param data - array to fill
			* @param i_count - number of elements of data
			* @param o_count - real number of filled elements
			* @param mandatory
			* @return TRUE on success
			*/
			scpi_bool_t SCPI_ParamArrayDouble(scpi_t * context, double data, size_t i_count, size_t o_count, scpi_array_format_t format, scpi_bool_t mandatory) {
			PARAM_ARRAY_TEMPLATE(SCPI_ParamDouble);
			}