ush-env.c

一个在LINUX下运行的shell程序

/* ush-env.c */
/* environment functions for ush */

#include "ush.h"
#include "ush-env.h"

// this data structure is used to store the 
// environment assignment information.
struct varslot  /* symbol table slot */
{
    char *name;
    char *val;
    BOOLEAN exported;
}
sym[MAXVAR];


BOOLEAN assign(char **p, char *s)
{				/* initialize name or value */
    int size;

    size = strlen(s) + 1;
    if (*p == NULL) {
        if ((*p = malloc(size)) == NULL)
            return (FALSE);
    }
    else if ((*p = realloc(*p, size)) == NULL)
        return (FALSE);
    strcpy(*p, s);
    return (TRUE);
}

//////////////////////////////////////////////////////////
// You must implement the invoke function 					//
// do the environment export								       //
//////////////////////////////////////////////////////////
BOOLEAN EVexport(char *name)
{				/* set variable to be exported */    
    int i, nameLength;
    char* nameOfEV;
    struct varslot *v;
    
    if((nameLength = strcspn(name, "="))!=0)
    {
        if((nameOfEV = malloc(nameLength+1))==NULL)
            return FALSE;
        
        strncpy(nameOfEV, name, nameLength);
        nameOfEV[nameLength] = '\0';
         
        // 调用EVset设置环境变量
	if (!EVset(nameOfEV, &name[nameLength + 1]))
            return FALSE;
        
        // 把exported设为TRUE
        v = find(nameOfEV);
        v->exported = TRUE;
    }
    return TRUE;
}


struct varslot *find(char *name)
{				/* find symbol table entry */

    int i;
    struct varslot *v;

    v = NULL;
    for (i = 0; i < MAXVAR; i++)
	if (sym[i].name == NULL) {
	    if (v == NULL)
		v = &sym[i];
	}
	else if (strcmp(sym[i].name, name) == 0) {
	    v = &sym[i];
	    break;
	}
    return (v);
}

//////////////////////////////////////////////////////////
// You must implement the invoke function 					//
// do the environment set								       //
//////////////////////////////////////////////////////////
BOOLEAN EVset(char *name, char *val)
{				/* add name & valude to enviromnemt */
    int i;

    for (i = 0; i < MAXVAR; i++)
    {        
        if (sym[i].name != NULL)
        {
            // 已经存在这个环境变量
            if(!strcmp(sym[i].name,name))
            {    
                if(val!=NULL)
                {
                    sym[i].exported = FALSE;

                    if(assign(&sym[i].val,val))
                        return TRUE;
                    else
                        return FALSE;
                }
                else
                {
                    // 如果value为null,实现unset
                    free(sym[i].name);     
                    free(sym[i].val);
                    sym[i].name = NULL;
                    sym[i].val = NULL;
                    return TRUE;
                }            
            }
        }
    }

    for (i = 0; i < MAXVAR; i++)
    {
        if (sym[i].name == NULL)
        {
            // 没有这个环境变量，创建新的环境变量
            if(val!=NULL)
            {
                if(!((assign(&sym[i].name,name))&&(assign(&sym[i].val,val))))
                   return FALSE;

                sym[i].exported = FALSE; 
                return TRUE;
            }
        }
    }   


    return FALSE;
}


BOOLEAN EVinit()
{				/* initialize symbol table from
				   environment */
    int i, j,namelen;
    char name[100];
    for (i = 0; environ[i] != NULL; i++) {
	namelen = strcspn(environ[i], "=");
	strncpy(name, environ[i], namelen);
	name[namelen] = '\0';	
    j=0;
    while(sym[j].name != NULL)
        j++;

    assign(&sym[j].name,name);
    assign(&sym[j].val,&environ[i][namelen + 1]);
    sym[j].exported = TRUE;    
    }
    return (TRUE);
}


char *EVget(char *name)
{				/* get value of variable */
    struct varslot *v;   

    if ((v = find(name)) == NULL || v->name == NULL)
    {
	return (NULL);
    }    
    return (v->val);
}

void EVprint()
{				/* printf environment */
    int i;

    for (i = 0; i < MAXVAR; i++)
	if (sym[i].name != NULL)
	    printf("%3s %s=%s\n", sym[i].exported ? "[E]" : "",
		   sym[i].name, sym[i].val);
}

//////////////////////////////////////////////////////////
// You must implement the invoke function 					//
// do the environment assignment						       //
//////////////////////////////////////////////////////////
void asg(int argc, char *argv[])
{				/* assignment command */
    int i, namelen;
    char* name[argc];

    for (i = 0; i<argc; i++) 
    {
        // 将传入参数分割为名值对
        namelen = strcspn(argv[i], "=");

        if((name[i] = malloc(namelen+1))==NULL)
            return;
        
        strncpy(name[i], argv[i], namelen);
        name[i][namelen] = '\0';
 
        // 调用EVset设置环境变量
        if (!EVset(name[i], &argv[i][namelen + 1]))
            syserror("Set environment error.");
    }    
}

//////////////////////////////////////////////////////////
// You must implement the invoke function 					//
// do the environment assignment						       //
//////////////////////////////////////////////////////////
void set(int argc, char *argv[])
{				/* set command */
    int i,namelen;
    char* name[argc];
    if(argc == 1)
    {
        EVprint();  // 没有参数则打印环境变量列表
    }
    else
    {
        // 设置环境变量
        for(i = 1; i < argc; i++)
        {  
             namelen = strcspn(argv[i], "=");
             if((name[i] = malloc(namelen+1))==NULL)
                return;
        
             strncpy(name[i], argv[i], namelen);
             name[i][namelen] = '\0';

             // 调用EVset设置环境变量
             if (!EVset(name[i], &argv[i][namelen + 1]))
                 syserror("Set environment error.");
        }
    }         
}

// 实现unset，删除要求的环境变量
void unset(int argc,char *argv[])
{              /* unset command */
     int i;
     for(i = 1; i < argc; i++)
     {         
         EVset(argv[i], NULL);
     }
}


void export(int argc, char *argv[])
{				/* export command */
    int i;

    if (argc == 1) {
	set(argc, argv);
	return;
    }
    for (i = 1; i < argc; i++)
	if (!EVexport(argv[i])) {
	    printf("Cannot export %s\n", argv[i]);
	    return;
	}
}

// 用来实现环境变量名的替换，将$开头的参数替换为相应的值。
void EVsubstitute(int argc,char *argv[])
{
    int i,j,namelen;
    char **tempValue;
    char *total;
    char *pos;
    char *name;

    for(i = 1; i < argc; i++)
    {
        // 只处理包含$的参数
        if(pos=strchr(argv[i],'$'))
        {
            if(atoi(&pos[1])!=0)
            {
                 namelen = strcspn(argv[i], "$");
                 name = malloc(100);
                 
                 if(argv[i][0]!='$')
                 {
                    strncpy(name, argv[i], namelen);
                    strcat(name,sym[atoi(&pos[1])].val);
                 }
                 else
                    strcpy(name,sym[atoi(&pos[1])].val);
                 
                 assign(&argv[i],name);                 
            }
            else if(EVget(&pos[1]) != NULL)
            {               
                 namelen = strcspn(argv[i], "$");
                 name = malloc(100);
                 
                 if(argv[i][0]!='$')
                 {
                    strncpy(name, argv[i], namelen);
                    strcat(name,EVget(&pos[1]));
                 }
                 else
                    strcpy(name,EVget(&pos[1]));
                 
                 assign(&argv[i],name);       
            }
            else if (argv[i][1]=='*')
            {
                total = malloc(MAXVAR*30);
                strcpy(total,"");
                
                for (j = 0; j < MAXVAR; j++)
                {        
                    if (sym[j].name != NULL)
                    {
                        strcat(total,sym[j].name);
                        strcat(total,"=");
                        strcat(total,sym[j].val);
                        strcat(total," ");
                    }
                }

                strcpy(argv[i],total);
            }
            else
            {
                 syserror("No such environment variable.");
            }
        }
    }
}