pdl_variable.c

Go to the documentation of this file.

/*                                                                                                            
 * Copyright (c) Members of the EGEE Collaboration. 2004.
 * See http://eu-egee.org/partners/ for details on the copyright holders.
 * For license conditions see the license file or
 * http://eu-egee.org/license.html
 */

/*
 *   Copyright (c) 2003 EU DataGrid        http://www.eu-datagrid.org/
 *
 *   $Id: pdl_variable.c,v 1.12 2005/03/01 17:05:10 venekamp Exp $
 *
 *   Copyright (c) 2003 by
 *      G.M. Venekamp <venekamp@nikhef.nl>
 *      NIKHEF Amsterdam, the Netherlands
 *
 *   This software is distributed under a BSD-style open source
 *   licence. For a complete description of the licence take a look
 *   at: http://eu-datagrid.web.cern.ch/eu-datagrid/license.html
 *
 */


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

#include "lcmaps_log.h"
#include "pdl_variable.h"
#include "pdl_rule.h"

static var_t *top_var=0, *last_var=0;

BOOL   _add_variable(const record_t* name, const record_t* value);
void   free_vars(void);
var_t* find_variable(const char* name);
var_t* detect_loop(const char* name, const char* value);
void   show_vars(void);


void add_variable(record_t* name, record_t* value)
{
  if (!_add_variable(name, value)) {
    free(name->string);  name->string = NULL;
    free(value->string); name->string = NULL;
  }

  free(name);  name  = NULL;
  free(value); value = NULL;
}


BOOL _add_variable(const record_t* name, const record_t* value)
{
  var_t *var;

  if ((var = find_variable(name->string))) {
    warning(PDL_ERROR, "variable '%s' already defined at line %d; ", var->name, var->lineno);
    warning(PDL_SAME,  "pervious value: '%s'.", var->value);
    return FALSE;
  }

  if ((var = detect_loop(name->string, value->string))) {
    warning(PDL_ERROR, "loop detected on variable '%s'; %s = %s", name->string, name->string, value->string);
    while (var) {
      var_t* tmp = var;
      warning(PDL_SAME,  "see also line: %d  %s = %s", var->lineno, var->name, var->value);
      var = var->next;
      /*
       *  A list is created during the detect_loop call. This list must be
       *  freed. However, the elements of the structure are direct copies
       *  of existing elements. Therefore, only the list elements need be
       *  freed and not any of the structure elements!
       */
      free(tmp);
    }
    return FALSE;
  }

  if (!(var = (var_t *)malloc(sizeof(var_t)))) {
    warning(PDL_ERROR, "Out of memory; cannot add variable '%s'.\n", name->string);
    return FALSE;
  }

  var->name   = name->string;
  var->value  = value->string;
  var->okay   = FALSE;
  var->lineno = name->lineno;
  var->next   = 0;
  
  if (top_var)
    last_var->next = var;
  else
    top_var = var;
  
  last_var = var;

  return TRUE;
}


void free_variables(void)
{
  var_t* var = top_var;

  while (var) {
    var_t* t = var->next;

    free((char *)var->name);   var->name  = NULL;
    free((char *)var->value);  var->value = NULL;
    free(var);

    var = t;
  }

  top_var = 0;
}


var_t* find_variable(const char* name)
{
  var_t* var = top_var;

  if (!name)
    return 0;

  while (var && strcmp(name, var->name)!=0) {
    var = var->next;
  }

  return var;
}


var_t* detect_loop(const char* name, const char* value)
{
  var_t *loop=0, *top_loop=0, *var = find_variable(value);

  while (var) {
    var_t* tmp = (var_t *)malloc(sizeof(var_t));

    if (loop) 
      loop->next = tmp;
    else
      top_loop = tmp;

    loop = tmp;
    memcpy(loop, var, sizeof(var_t));
    loop->next = 0;

    tmp = top_loop;
    while (tmp && strcmp(name, tmp->value)!=0) {
      tmp = tmp->next;
    }
    
    if (tmp) return top_loop;

    var = find_variable(var->value);
  }

  /*  No loop was detected, free the allocated memory.  */
  while (top_loop) {
    var_t* tmp = top_loop;
    free(top_loop);
    top_loop = tmp->next;
  }

  return 0;
}


void reduce_to_var(const char** name, rule_type_t rule_type)
{
  var_t *var=0, *tmp;
  const char* n = *name;

  while ((tmp = find_variable(n))) {
    var = tmp;
    n = var->value;
  }

  if (var) {
    const rule_t* t;
    if (var->okay || !(t = get_rule(n, rule_type==STATE ? right_side : left_side))) {
      var->okay = TRUE;
      free((char *)*name);
      *name = (const char*)strdup(n);
    } else {
      lineno = var->lineno;
      warning(PDL_WARNING, "Variable %s points to state %s. This is considered dangerous.", var->name, n);
    }
  }
}


var_t* get_variables(void)
{
  return top_var;
}


void show_variables(void)
{
  var_t* var = top_var;

  while (var) {
    lcmaps_log_debug(1, "var: %s = %s\n", var->name, var->value);
    var = var->next;
  }
}

---