debug/org.eclipse.ptp.debug.sdm/libmi/MIVar.c - gerrit/ptp/org.eclipse.ptp - Git at Google

 /******************************************************************************
  * Copyright (c) 2005 The Regents of the University of California.
  * This material was produced under U.S. Government contract W-7405-ENG-36
  * for Los Alamos National Laboratory, which is operated by the University
  * of California for the U.S. Department of Energy. The U.S. Government has
  * rights to use, reproduce, and distribute this software. NEITHER THE
  * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
  * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified
  * to produce derivative works, such modified software should be clearly
  * marked, so as not to confuse it with the version available from LANL.
  *
  * Additionally, this program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * LA-CC 04-115
  ******************************************************************************/

  /*
   * Based on the QNX Java implementation of the MI interface
   */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include "MIList.h"
 #include "MIValue.h"
 #include "MIResult.h"
 #include "MIVar.h"
 #include "MIOOBRecord.h"

 MIVar *
 MIVarNew(void)
 {
 	MIVar *	var = (MIVar *)malloc(sizeof(MIVar));
 	var->name = NULL;
 	var->type = NULL;
 	var->exp = NULL;
 	var->numchild = 0;
 	var->children = NULL;
 	return var;
 }

 void
 MIVarFree(MIVar *var)
 {
 	int i;

 	if (var->name != NULL) {
 		free(var->name);
 	}
 	if (var->type != NULL) {
 		free(var->type);
 	}
 	if (var->exp != NULL) {
 		free(var->exp);
 	}
 	if (var->children != NULL) {
 		for (i = 0; i < var->numchild; i++) {
 			MIVarFree(var->children[i]);
 		}
 		free(var->children);
 	}
 	free(var);
 }

 MIVarChange *
 MIVarChangeNew(void) {
 	MIVarChange *varchange = (MIVarChange *)malloc(sizeof(MIVarChange));

 	varchange->name = NULL;
 	varchange->in_scope = 0;
 	varchange->type_changed = 0;
 	return varchange;
 }

 void
 MIVarChangeFree(MIVarChange *varchange) {
 	if (varchange->name != NULL)
 		free(varchange->name);
 	free(varchange);
 }

 MIVar *
 MIVarParse(MIList *results)
 {
 	MIValue *	value;
 	MIResult *	result;
 	MIVar *		var = MIVarNew();
 	char *		str;

 	for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL; ) {
 		value = result->value;
 		if (value != NULL && value->type == MIValueTypeConst) {
 			str = value->cstring;
 		} else {
 			str = "";
 		}

 		if (strcmp(result->variable, "numchild") == 0) {
 			var->numchild = (int)strtol(str, NULL, 10);
 		} else if (strcmp(result->variable, "name") == 0) {
 			var->name = strdup(str);
 		} else if (strcmp(result->variable, "type") == 0) {
 			var->type = strdup(str);
 		} else if (strcmp(result->variable, "exp") == 0) {
 			var->exp = strdup(str);
 		}
 	}

 	return var;
 }

 MIVar *
 MIGetVarCreateInfo(MICommand *cmd)
 {
 	if (!cmd->completed || cmd->output == NULL || cmd->output->rr == NULL)
 		return NULL;

 	return MIVarParse(cmd->output->rr->results);
 }

 /*
  * Some gdb MacOSX do not return a MITuple so we have
  * to check for different format.
  * See PR 81019
  */
 static void
 parseChildren(MIValue *val, MIList **res)
 {
 	MIValue *	value;
 	MIResult *	result;
 	MIList *	children = NULL;
 	MIList * 	results = val->results;

 	if (results != NULL) {
 		for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL; ) {
 			if (strcmp(result->variable, "child") == 0) { //$NON-NLS-1$
 				value = result->value;
 				if (value->type == MIValueTypeTuple) {
 					if (children == NULL) {
 						children = MIListNew();
 					}
 					MIListAdd(children, MIVarParse(value->results));
 				}
 			}
 		}
 	}
 	*res = children;
 }

 void
 MIGetVarListChildrenInfo(MICommand *cmd, MIVar *var)
 {
 	int					num;
 	MIVar *				child;
 	MIValue *			value;
 	MIResult *			result;
 	MIResultRecord *	rr;
 	MIList *			children = NULL;

 	if (!cmd->completed || cmd->output == NULL || cmd->output->rr == NULL)
 		return;

 	rr = cmd->output->rr;
 	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL; ) {
 		value = result->value;

 		if (strcmp(result->variable, "numchild") == 0) {
 			if (value->type == MIValueTypeConst) {
 				var->numchild = (int)strtol(value->cstring, NULL, 10);
 			}
 		} else if (strcmp(result->variable, "children") == 0) {
 			parseChildren(value, &children);
 		}
 	}

 	if (children != NULL) {
 		num = MIListSize(children);
 		if (var->numchild != num) {
 			var->numchild = num;
 		}
 		var->children = (MIVar **)malloc(sizeof(MIVar *) * var->numchild);
 		for (num = 0, MIListSet(children); (child = (MIVar *)MIListGet(children)) != NULL; ) {
 			var->children[num++] = child;
 		}
 		MIListFree(children, NULL);
 	}
 }

 char *
 MIGetVarEvaluateExpressionInfo(MICommand *cmd)
 {
 	MIValue *			value;
 	MIResult *			result;
 	MIResultRecord *	rr;
 	char *				expr = NULL;

 	if (!cmd->completed || cmd->output == NULL || cmd->output->rr == NULL) {
 		return NULL;
 	}

 	rr = cmd->output->rr;
 	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL; ) {
 		value = result->value;
 		if (strcmp(result->variable, "value") == 0) {
 			if (value->type == MIValueTypeConst) {
 				expr = strdup(value->cstring);
 			}
 		}
 	}
 	return expr;
 }

 char *
 MIGetDataEvaluateExpressionInfo(MICommand *cmd)
 {
 	MIValue *			value;
 	MIResult *			result;
 	MIResultRecord *	rr;
 	char *				expr = NULL;

 	if (!cmd->completed || cmd->output == NULL || cmd->output->rr == NULL) {
 		return NULL;
 	}

 	rr = cmd->output->rr;
 	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL; ) {
 		value = result->value;
 		if (strcmp(result->variable, "value") == 0) {
 			if (value->type == MIValueTypeConst) {
 				expr = strdup(value->cstring);
 			}
 		}
 	}
 	return expr;
 }

 void
 MIGetVarUpdateParseValue(MIValue* tuple, MIList* varchanges)
 {
 	MIResult * result;
 	char * str = NULL;
 	char * var;
 	MIValue * value;
 	MIVarChange * varchange = NULL;
 	MIList * results = tuple->results;

 	if (results != NULL) {
 		for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL;) {
 			var = result->variable;
 			value = result->value;

 			//this code is for mac
 			if (value->type == MIValueTypeTuple) {
 				MIGetVarUpdateParseValue(value, varchanges);
 				continue;
 			}

 			if (value->type == MIValueTypeConst) {
 				str = value->cstring;
 			}

 			if (strcmp(var, "name") == 0 && str != NULL) {
 				varchange = MIVarChangeNew();
 				varchange->name = strdup(str);
 				MIListAdd(varchanges, (void *)varchange);
 			} else if (strcmp(var, "in_scope") == 0) {
 				if (varchange != NULL) {
 					varchange->in_scope = (strcmp(str, "true")==0)?1:0;
 				}
 			} else if (strcmp(var, "type_changed") == 0) {
 				if (varchange != NULL) {
 					varchange->type_changed = (strcmp(str, "true")==0)?1:0;
 				}
 			}
 		}
 	}
 }

 void
 MIGetVarUpdateParser(MIValue* miVal, MIList *varchanges)
 {
 	MIValue* value;
 	MIResult* result;

 	if (miVal->type == MIValueTypeTuple) {
 		MIGetVarUpdateParseValue(miVal, varchanges);
 	} else if (miVal->type == MIValueTypeList) {
 		if (MIListIsEmpty(miVal->values)) {
 			for (MIListSet(miVal->results); (result = (MIResult *)MIListGet(miVal->results)) != NULL;) {
 				MIGetVarUpdateParser(result->value, varchanges);
 			}
 		} else {
 			for (MIListSet(miVal->values); (value = (MIValue *)MIListGet(miVal->values)) != NULL;) {
 				MIGetVarUpdateParser(value, varchanges);
 			}
 		}
 	}
 }

 void
 MIGetVarUpdateInfo(MICommand *cmd, MIList** varchanges)
 {
 	MIResult *			result;
 	MIResultRecord *	rr;

 	*varchanges = MIListNew();

 	if (!cmd->completed || cmd->output == NULL || cmd->output->rr == NULL)
 		return;

 	rr = cmd->output->rr;
 	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL;) {
 		if (strcmp(result->variable, "changelist") == 0) {
 			MIGetVarUpdateParser(result->value, *varchanges);
 		}
 	}
 }

 MIVar *
 MIGetVarInfoType(MICommand *cmd)
 {
 	if (!cmd->completed || cmd->output == NULL || cmd->output->rr == NULL) {
 		return NULL;
 	}

 	return MIVarParse(cmd->output->rr->results);
 }

 void
 MIGetVarInfoNumChildren(MICommand *cmd, MIVar *var)
 {
 	MIList *	results;
 	MIValue *	value;
 	MIResult *	result;
 	char *		str;

 	if (!cmd->completed || cmd->output == NULL || cmd->output->rr == NULL)
 		return;

 	if (var == NULL) {
 		var = MIVarNew();
 	}

 	results = cmd->output->rr->results;
 	for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL; ) {
 		value = result->value;
 		if (value != NULL && value->type == MIValueTypeConst) {
 			str = value->cstring;
 		} else {
 			str = "";
 		}

 		if (strcmp(result->variable, "numchild") == 0) {
 			var->numchild = (int)strtol(str, NULL, 10);
 		}
 	}
 }
	/******************************************************************************
	* Copyright (c) 2005 The Regents of the University of California.
	* This material was produced under U.S. Government contract W-7405-ENG-36
	* for Los Alamos National Laboratory, which is operated by the University
	* of California for the U.S. Department of Energy. The U.S. Government has
	* rights to use, reproduce, and distribute this software. NEITHER THE
	* GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
	* ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified
	* to produce derivative works, such modified software should be clearly
	* marked, so as not to confuse it with the version available from LANL.
	*
	* Additionally, this program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* LA-CC 04-115
	******************************************************************************/

	/*
	* Based on the QNX Java implementation of the MI interface
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "MIList.h"
	#include "MIValue.h"
	#include "MIResult.h"
	#include "MIVar.h"
	#include "MIOOBRecord.h"

	MIVar *
	MIVarNew(void)
	{
	MIVar * var = (MIVar *)malloc(sizeof(MIVar));
	var->name = NULL;
	var->type = NULL;
	var->exp = NULL;
	var->numchild = 0;
	var->children = NULL;
	return var;
	}

	void
	MIVarFree(MIVar *var)
	{
	int i;

	if (var->name != NULL) {
	free(var->name);
	}
	if (var->type != NULL) {
	free(var->type);
	}
	if (var->exp != NULL) {
	free(var->exp);
	}
	if (var->children != NULL) {
	for (i = 0; i < var->numchild; i++) {
	MIVarFree(var->children[i]);
	}
	free(var->children);
	}
	free(var);
	}

	MIVarChange *
	MIVarChangeNew(void) {
	MIVarChange varchange = (MIVarChange )malloc(sizeof(MIVarChange));

	varchange->name = NULL;
	varchange->in_scope = 0;
	varchange->type_changed = 0;
	return varchange;
	}

	void
	MIVarChangeFree(MIVarChange *varchange) {
	if (varchange->name != NULL)
	free(varchange->name);
	free(varchange);
	}

	MIVar *
	MIVarParse(MIList *results)
	{
	MIValue * value;
	MIResult * result;
	MIVar * var = MIVarNew();
	char * str;

	for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL; ) {
	value = result->value;
	if (value != NULL && value->type == MIValueTypeConst) {
	str = value->cstring;
	} else {
	str = "";
	}

	if (strcmp(result->variable, "numchild") == 0) {
	var->numchild = (int)strtol(str, NULL, 10);
	} else if (strcmp(result->variable, "name") == 0) {
	var->name = strdup(str);
	} else if (strcmp(result->variable, "type") == 0) {
	var->type = strdup(str);
	} else if (strcmp(result->variable, "exp") == 0) {
	var->exp = strdup(str);
	}
	}

	return var;
	}

	MIVar *
	MIGetVarCreateInfo(MICommand *cmd)
	{
	if (!cmd->completed \|\| cmd->output == NULL \|\| cmd->output->rr == NULL)
	return NULL;

	return MIVarParse(cmd->output->rr->results);
	}

	/*
	* Some gdb MacOSX do not return a MITuple so we have
	* to check for different format.
	* See PR 81019
	*/
	static void
	parseChildren(MIValue val, MIList *res)
	{
	MIValue * value;
	MIResult * result;
	MIList * children = NULL;
	MIList * results = val->results;

	if (results != NULL) {
	for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL; ) {
	if (strcmp(result->variable, "child") == 0) { //$NON-NLS-1$
	value = result->value;
	if (value->type == MIValueTypeTuple) {
	if (children == NULL) {
	children = MIListNew();
	}
	MIListAdd(children, MIVarParse(value->results));
	}
	}
	}
	}
	*res = children;
	}

	void
	MIGetVarListChildrenInfo(MICommand cmd, MIVar var)
	{
	int num;
	MIVar * child;
	MIValue * value;
	MIResult * result;
	MIResultRecord * rr;
	MIList * children = NULL;

	if (!cmd->completed \|\| cmd->output == NULL \|\| cmd->output->rr == NULL)
	return;

	rr = cmd->output->rr;
	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL; ) {
	value = result->value;

	if (strcmp(result->variable, "numchild") == 0) {
	if (value->type == MIValueTypeConst) {
	var->numchild = (int)strtol(value->cstring, NULL, 10);
	}
	} else if (strcmp(result->variable, "children") == 0) {
	parseChildren(value, &children);
	}
	}

	if (children != NULL) {
	num = MIListSize(children);
	if (var->numchild != num) {
	var->numchild = num;
	}
	var->children = (MIVar *)malloc(sizeof(MIVar ) * var->numchild);
	for (num = 0, MIListSet(children); (child = (MIVar *)MIListGet(children)) != NULL; ) {
	var->children[num++] = child;
	}
	MIListFree(children, NULL);
	}
	}

	char *
	MIGetVarEvaluateExpressionInfo(MICommand *cmd)
	{
	MIValue * value;
	MIResult * result;
	MIResultRecord * rr;
	char * expr = NULL;

	if (!cmd->completed \|\| cmd->output == NULL \|\| cmd->output->rr == NULL) {
	return NULL;
	}

	rr = cmd->output->rr;
	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL; ) {
	value = result->value;
	if (strcmp(result->variable, "value") == 0) {
	if (value->type == MIValueTypeConst) {
	expr = strdup(value->cstring);
	}
	}
	}
	return expr;
	}

	char *
	MIGetDataEvaluateExpressionInfo(MICommand *cmd)
	{
	MIValue * value;
	MIResult * result;
	MIResultRecord * rr;
	char * expr = NULL;

	if (!cmd->completed \|\| cmd->output == NULL \|\| cmd->output->rr == NULL) {
	return NULL;
	}

	rr = cmd->output->rr;
	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL; ) {
	value = result->value;
	if (strcmp(result->variable, "value") == 0) {
	if (value->type == MIValueTypeConst) {
	expr = strdup(value->cstring);
	}
	}
	}
	return expr;
	}

	void
	MIGetVarUpdateParseValue(MIValue* tuple, MIList* varchanges)
	{
	MIResult * result;
	char * str = NULL;
	char * var;
	MIValue * value;
	MIVarChange * varchange = NULL;
	MIList * results = tuple->results;

	if (results != NULL) {
	for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL;) {
	var = result->variable;
	value = result->value;

	//this code is for mac
	if (value->type == MIValueTypeTuple) {
	MIGetVarUpdateParseValue(value, varchanges);
	continue;
	}

	if (value->type == MIValueTypeConst) {
	str = value->cstring;
	}

	if (strcmp(var, "name") == 0 && str != NULL) {
	varchange = MIVarChangeNew();
	varchange->name = strdup(str);
	MIListAdd(varchanges, (void *)varchange);
	} else if (strcmp(var, "in_scope") == 0) {
	if (varchange != NULL) {
	varchange->in_scope = (strcmp(str, "true")==0)?1:0;
	}
	} else if (strcmp(var, "type_changed") == 0) {
	if (varchange != NULL) {
	varchange->type_changed = (strcmp(str, "true")==0)?1:0;
	}
	}
	}
	}
	}

	void
	MIGetVarUpdateParser(MIValue* miVal, MIList *varchanges)
	{
	MIValue* value;
	MIResult* result;

	if (miVal->type == MIValueTypeTuple) {
	MIGetVarUpdateParseValue(miVal, varchanges);
	} else if (miVal->type == MIValueTypeList) {
	if (MIListIsEmpty(miVal->values)) {
	for (MIListSet(miVal->results); (result = (MIResult *)MIListGet(miVal->results)) != NULL;) {
	MIGetVarUpdateParser(result->value, varchanges);
	}
	} else {
	for (MIListSet(miVal->values); (value = (MIValue *)MIListGet(miVal->values)) != NULL;) {
	MIGetVarUpdateParser(value, varchanges);
	}
	}
	}
	}

	void
	MIGetVarUpdateInfo(MICommand cmd, MIList* varchanges)
	{
	MIResult * result;
	MIResultRecord * rr;

	*varchanges = MIListNew();

	if (!cmd->completed \|\| cmd->output == NULL \|\| cmd->output->rr == NULL)
	return;

	rr = cmd->output->rr;
	for (MIListSet(rr->results); (result = (MIResult *)MIListGet(rr->results)) != NULL;) {
	if (strcmp(result->variable, "changelist") == 0) {
	MIGetVarUpdateParser(result->value, *varchanges);
	}
	}
	}

	MIVar *
	MIGetVarInfoType(MICommand *cmd)
	{
	if (!cmd->completed \|\| cmd->output == NULL \|\| cmd->output->rr == NULL) {
	return NULL;
	}

	return MIVarParse(cmd->output->rr->results);
	}

	void
	MIGetVarInfoNumChildren(MICommand cmd, MIVar var)
	{
	MIList * results;
	MIValue * value;
	MIResult * result;
	char * str;

	if (!cmd->completed \|\| cmd->output == NULL \|\| cmd->output->rr == NULL)
	return;

	if (var == NULL) {
	var = MIVarNew();
	}

	results = cmd->output->rr->results;
	for (MIListSet(results); (result = (MIResult *)MIListGet(results)) != NULL; ) {
	value = result->value;
	if (value != NULL && value->type == MIValueTypeConst) {
	str = value->cstring;
	} else {
	str = "";
	}

	if (strcmp(result->variable, "numchild") == 0) {
	var->numchild = (int)strtol(str, NULL, 10);
	}
	}
	}