Example #1
0
/* Runs the command in shell and returns its output (joined standard output and
 * standard error streams).  All trailing newline characters are stripped to
 * allow easy appending to command output.  Returns the output. */
static var_t
system_builtin(const call_info_t *call_info)
{
	var_t result;
	char *cmd;
	FILE *cmd_stream;
	size_t cmd_out_len;
	var_val_t var_val;

	cmd = var_to_string(call_info->argv[0]);
	cmd_stream = read_cmd_output(cmd);
	free(cmd);

	ui_cancellation_enable();
	var_val.string = read_nonseekable_stream(cmd_stream, &cmd_out_len);
	ui_cancellation_disable();
	fclose(cmd_stream);

	if(var_val.string == NULL)
	{
		var_val.string = "";
		return var_new(VTYPE_STRING, var_val);
	}

	/* Remove trailing new line characters. */
	while(cmd_out_len != 0U && var_val.string[cmd_out_len - 1] == '\n')
	{
		var_val.string[cmd_out_len - 1] = '\0';
		--cmd_out_len;
	}

	result = var_new(VTYPE_STRING, var_val);
	free(var_val.string);
	return result;
}
Example #2
0
File: arrays.c Project: Vuzi/vuziks
return_code arrays_array(Object* o, Linked_list *args, Variable* eval_value, int as_constructor) {

    (void)o;
    (void)args;

    if(!as_constructor) {
        err_add(E_ERROR, OP_IMPOSSIBLE, "Can't use this built-in function (arrays.array) as a function");
        return RC_ERROR;
    }

    // Nouvel objet array
    eval_value->type = T_OBJECT;
    eval_value->value.v_obj = var_new_object(NULL);

    // Nom d'objet : array
    eval_value->value.v_obj->name = "array";
    eval_value->value.v_obj->name_h = ARRAY_HASH;

    // Array en lui même
    Array* ar = xcalloc(1, sizeof(Array));

    eval_value->value.v_obj->data = (void*)ar;

    // Initialisation de l'array
    array_init(ar);

    // Fonction des strings

    Variable *v = var_new("add", str_hash("add"), T_FUNCTION_BUILTIN);
    v->value.v_func_builtin = arrays_array_add;
    v->container = &eval_value->value.v_obj->ec;
    v->container->object = eval_value->value.v_obj;

    linked_list_push(&(eval_value->value.v_obj->ec.variables), LLT_VARIABLE, (void*)v);

    v = var_new("get", str_hash("get"), T_FUNCTION_BUILTIN);
    v->value.v_func_builtin = arrays_array_get;
    v->container = &eval_value->value.v_obj->ec;
    v->container->object = eval_value->value.v_obj;

    linked_list_push(&(eval_value->value.v_obj->ec.variables), LLT_VARIABLE, (void*)v);

    v = var_new("pop", str_hash("pop"), T_FUNCTION_BUILTIN);
    v->value.v_func_builtin = arrays_array_pop;
    v->container = &eval_value->value.v_obj->ec;
    v->container->object = eval_value->value.v_obj;

    linked_list_push(&(eval_value->value.v_obj->ec.variables), LLT_VARIABLE, (void*)v);

    v = var_new("length", str_hash("length"), T_FUNCTION_BUILTIN);
    v->value.v_func_builtin = arrays_array_length;
    v->container = &eval_value->value.v_obj->ec;
    v->container->object = eval_value->value.v_obj;

    linked_list_push(&(eval_value->value.v_obj->ec.variables), LLT_VARIABLE, (void*)v);

    return RC_OK;
}
Example #3
0
/* Returns string representation of file type. */
static var_t
filetype_builtin(const call_info_t *call_info)
{
	char *str_val = var_to_string(call_info->argv[0]);
	const int fnum = get_fnum(str_val);
	var_val_t var_val = { .string = "" };
  free(str_val);

	if(fnum >= 0)
	{
#ifndef _WIN32
		const mode_t mode = curr_view->dir_entry[fnum].mode;
		var_val.const_string = get_mode_str(mode);
#else
		const FileType type = curr_view->dir_entry[fnum].type;
		var_val.const_string = get_type_str(type);
#endif
	}
	return var_new(VTYPE_STRING, var_val);
}

/* Returns file type from position or -1 if the position has wrong value. */
static int
get_fnum(const char position[])
{
	if(strcmp(position, ".") == 0)
	{
		return curr_view->list_pos;
	}
	else
	{
		return -1;
	}
}
Example #4
0
File: exec.c Project: moxley/parse1
struct t_value * exec_i_assign(struct t_exec *exec, struct t_icode *icode)
{
  struct t_var *var;
  struct t_value *ret = NULL;
  struct t_value *opnd1, *opnd2;
  
  debug(2, "%s(): Begin\n", __FUNCTION__);
  
  opnd2 = list_pop(&exec->stack);
  assert(opnd2);
  opnd1 = list_pop(&exec->stack);
  assert(opnd1);
  
  debug(3, "%s(): Got operands from stack\n", __FUNCTION__);

  if (opnd2->type == VAL_VAR) {
    debug(3, "%s(): Fetching value for opnd2\n", __FUNCTION__);
    var = var_lookup(exec, opnd2->name);
    opnd2 = var->value;
    assert(opnd2);
  }

  if (opnd1->type != VAL_VAR) {
    fprintf(stderr, "Left side of assignment must be a variable. Got %s=%d instead.\n", value_types[opnd1->type], opnd1->intval);
    return NULL;
  }
  debug(3, "%s(): Looking up opnd1 var name=%s\n", __FUNCTION__, opnd1->name);
  var = var_lookup(exec, opnd1->name);
  if (var) {
    if (var->value->type != opnd2->type) {
      fprintf(stderr, "Type mismatch when assigning new value: %s = %s\n", opnd1->name, value_types[opnd2->type]);
      return NULL;
    }
  }
  else {
    var = var_new(opnd1->name, opnd2);
    list_push(&exec->vars, var);
  }
  debug(3, "%s(): Copying value to variable\n", __FUNCTION__);

  if (var->value->type == VAL_INT) {
    var->value->intval = opnd2->intval;
    ret = create_num_from_int(var->value->intval);
    list_push(&exec->values, ret);
    debug(3, "%s(): New int val: %d\n", __FUNCTION__, ret->intval);
  }
  else if (var->value->type == VAL_STRING) {
    var->value->stringval = opnd2->stringval;
    ret = var->value;
    debug(3, "%s(): Assigned string: %s\n", __FUNCTION__, ret->stringval);
  }
  else {
    fprintf(stderr, "Don't know how to assign %s type value\n", value_types[opnd2->type]);
    return NULL;
  }
  
  list_push(&exec->stack, ret);

  return ret;
}
Example #5
0
/* Gets string representation of file type.  Returns the string. */
static var_t
filetype_builtin(const call_info_t *call_info)
{
	char *str_val = var_to_string(call_info->argv[0]);
	const int fnum = get_fnum(str_val);
	var_val_t var_val = { .string = "" };
	free(str_val);

	if(fnum >= 0)
	{
		const FileType type = curr_view->dir_entry[fnum].type;
		var_val.const_string = get_type_str(type);
	}
	return var_new(VTYPE_STRING, var_val);
}

/* Returns file type from position or -1 if the position has wrong value. */
static int
get_fnum(const char position[])
{
	if(strcmp(position, ".") == 0)
	{
		return curr_view->list_pos;
	}
	return -1;
}

/* Retrieves type of current pane as a string. */
static var_t
getpanetype_builtin(const call_info_t *call_info)
{
	FileView *const view = curr_view;
	var_val_t var_val;

	if(flist_custom_active(view))
	{
		var_val.string = (view->custom.unsorted ? "very-custom" : "custom");
	}
	else
	{
		var_val.string = "regular";
	}

	return var_new(VTYPE_STRING, var_val);
}
Example #6
0
return_code strings_string(Object* o, Linked_list *args, Variable* eval_value, int as_constructor) {

    (void)o;
    (void)args;

    if(!as_constructor) {
        err_add(E_ERROR, OP_IMPOSSIBLE, "Can't use this built-in function (strings.string) as a function");
        return RC_ERROR;
    }

    // Nouvel objet string
    eval_value->type = T_OBJECT;
    eval_value->value.v_obj = var_new_object(NULL);

    // Nom d'objet : string
    eval_value->value.v_obj->name = "string";
    eval_value->value.v_obj->name_h = STRING_HASH;

    // String en lui même
    VK_String* vks = xcalloc(1, sizeof(VK_String));

    eval_value->value.v_obj->data = (void*)vks;

    // Fonction des strings
    Variable *v = var_new("append", str_hash("append"), T_FUNCTION_BUILTIN);
    v->value.v_func_builtin = strings_string_append;
    v->container = &eval_value->value.v_obj->ec;
    v->container->object = eval_value->value.v_obj;

    linked_list_push(&(eval_value->value.v_obj->ec.variables), LLT_VARIABLE, (void*)v);

    v = var_new("length", str_hash("length"), T_FUNCTION_BUILTIN);
    v->value.v_func_builtin = strings_string_length;
    v->container = &eval_value->value.v_obj->ec;
    v->container->object = eval_value->value.v_obj;

    linked_list_push(&(eval_value->value.v_obj->ec.variables), LLT_VARIABLE, (void*)v);

    return RC_OK;
}
Example #7
0
struct instr * icall(char *fn, struct stack * args)
{
	struct instr *i = malloc(sizeof *i);

	if (i == NULL) {
		perror("malloc");
		return NULL;
	}

	i->optype = I_CAL;
	i->fn = fn;
	i->args = args;
	i->ret = elt_new(E_REG, reg_new(var_new(fn)));

	return i;
}
Example #8
0
/* Returns string after expanding expression. */
static var_t
expand_builtin(const call_info_t *call_info)
{
	var_t result;
	var_val_t var_val;
	char *str_val;

	str_val = var_to_string(call_info->argv[0]);
	var_val.string = expand_macros(str_val, NULL, NULL, 0);
	free(str_val);

	result = var_new(VTYPE_STRING, var_val);
	free(var_val.string);

	return result;
}
Example #9
0
File: arrays.c Project: Vuzi/vuziks
// Initialisation de l'objet built-in string
Object* arrays_init(Exec_context* ec_obj) {
    // Création de l'objet
    Object* o = var_new_object(NULL);

    (void)ec_obj;

    // Définition du type
    o->name = "arrays";
    o->name_h = str_hash(o->name);

    // Ajout des fonctions
    Variable* v = var_new("array", str_hash("array"), T_FUNCTION_BUILTIN);
    v->value.v_func_builtin = arrays_array;
    v->container = &o->ec; v->container->object = o;
    linked_list_push(&(o->ec.variables), LLT_VARIABLE, (void*)v);

    return o;
}
Example #10
0
static int target_x86_add_local_var(target_x86_t *target_x86, char *name)
{
	var_t *var;
	char addr[STR_SIZE];
	int count;
	
	if( target_x86_get_local_var(target_x86, name) != NULL )
	{
		return -1;
	}
	
	count = target_x86->array_local->count;
	sprintf(addr, "[ebp-0x%x]", 4+4*count);
	
	var = var_new(name, addr);
	array_add(target_x86->array_local, var);
	
	return 0;
}
Example #11
0
SLPError generic_set_val(struct xx_SLPAttributes *slp_attr, const char *tag, value_t *value, SLPInsertionPolicy policy, SLPType attr_type) 
/* Finds and sets the value named in tag.                                    */
/* 
 * slp_attr  - The attr object to add to.
 * tag       - the name of the tag to add to.
 * value     - the already-allocated value object with fields set
 * policy    - the policy to use when inserting.
 * attr_type - the type of the value being added.
 *****************************************************************************/
{
	var_t *var;
	/***** Create a new attribute. *****/	
	if ( (var = attr_val_find_str(slp_attr, tag)) == NULL) {	
		/*** Couldn't find a value with this tag. Make a new one. ***/	
		var = var_new((char *)tag);	
		if (var == NULL) {	
			return SLP_MEMORY_ALLOC_FAILED;	
		}	
		var->type = attr_type;	
		/** Add variable to list. **/	
		attr_add(slp_attr, var);	
	} else {
		SLPError err;
		/*** The attribute already exists. ***/ 
		/*** Verify type. ***/	
		err = attr_type_verify(slp_attr, var, attr_type);	
		if (err == SLP_TYPE_ERROR && policy == SLP_REPLACE) { 
			var_list_destroy(var); 
			var->type = attr_type; 
		} 
		else if (err != SLP_OK) {	
			value_free(value); 
			return err;	
		}	
	}	
	/***** Set value *****/	
	var_insert(var, value, policy); 

	return SLP_OK;
}
Example #12
0
static var_t
dummy(const call_info_t *call_info)
{
	static const var_val_t var_val = { .string = "" };
	called = 1;
	return var_new(VTYPE_STRING, var_val);
}

TEST(or_is_lazy)
{
	ASSERT_OK("1 || a()", "1");
	assert_false(called);
}

TEST(and_is_lazy)
{
	ASSERT_OK("0 && a()", "0");
	assert_false(called);
}

TEST(compares_are_lazy)
{
	ASSERT_OK("0 && 1 < a()", "0");
	assert_false(called);
}

TEST(negation_is_lazy)
{
	ASSERT_OK("0 && -a()", "0");
	assert_false(called);
}

TEST(not_is_lazy)
{
	ASSERT_OK("0 && !a()", "0");
	assert_false(called);
}
Example #13
0
int vis_particle( geometry_t *geometry, element_model_t *model, particle_t *particles, double gtime )
{
    double *f_x0 = NULL, *f_y0 = NULL, *f_z0 = NULL, *f_c0 = NULL;
    double *PartX, *PartY, *PartZ, *PartC, *PartI;

    double x, y, z, c, CAdd = 0.0, CScl = 1.0;

    double LX,LY,LZ, LC;
    double r = 0.05, *C;

    double x0,y0,x1,y1,z0,z1;
    double k1,k2,k3,k4;

    double t, dt, ddt;

    double CEPS = particles->Tolerance;

    int i, j, k, n, quick;

    double s = MAX(MAX(xmax-xmin,ymax-ymin),zmax-zmin);

    float pnt[3], vec[3];

    if ( !GlobalOptions.StereoMode )
      if ( particles->Material->Diffuse[3]  < 1.0 )
      {
          if ( GlobalPass != 0 ) return TRUE;
      } else if ( GlobalPass == 0 )
      {
          return TRUE;
      }

    if ( particles->NofParticles < 1 ) return TRUE;
    if ( !particles->VectorData   || !particles->VectorData[0]->f )   return TRUE;
    if ( !particles->ParticleData || !particles->ParticleData[0]->f ) return TRUE;

    f_x0 = particles->VectorData[0]->f;
    f_y0 = particles->VectorData[1]->f;
    f_z0 = particles->VectorData[2]->f;

    gra_set_material( particles->Material );

    if ( particles->ColorData && particles->ColorData->f )
    {
        f_c0 = particles->ColorData->f;

        CAdd = particles->ColorData->min;
        if ( particles->ColorData->max - particles->ColorData->min != 0.0 )
            CScl = 1.0 / ( particles->ColorData->max - particles->ColorData->min );
        else
            CScl = 1.0;

        gra_set_colormap( particles->ColorMap );
    } else gra_set_colormap( NULL );

    PartX = particles->ParticleData[0]->f;
    PartY = particles->ParticleData[1]->f;
    PartZ = particles->ParticleData[2]->f;
    PartC = particles->ParticleData[3]->f;
    PartI = particles->ParticleData[4]->f;

    n = particles->NofParticles;
    if ( particles->SaveNofParticles != n )
    {
        {
          VARIABLE *var = var_new( "_particle_last", TYPE_DOUBLE,5,n );

          particles->X = &M(var,0,0);
          particles->Y = &M(var,1,0);
          particles->Z = &M(var,2,0);
          particles->C = &M(var,3,0);
          particles->I = &M(var,4,0);
        }

        for( i=0; i<n; i++ )
        {
            particles->X[i] = PartX[i]; 
            particles->Y[i] = PartY[i];
            particles->Z[i] = PartZ[i];
            particles->C[i] = PartC[i];
            particles->I[i] = PartI[i];
        }
        particles->SaveNofParticles = n;
    }

    quick  = (particles->LineStyle == line_style_line);
    quick |= epMouseDown && epMouseDownTakesTooLong;

    if ( quick )
    {
        if ( particles->Style == particle_style_vector )
        {
           gra_beg_lines();
        } else
        {
           gra_polygon_mode( GRA_LINE );
        }
        gra_sphere_quality( 1 );

        if ( !(epMouseDown && epMouseDownTakesTooLong) )
          gra_line_width( particles->LineWidth );
        else
          gra_line_width( 1.0 );
    }

    if ( !quick && (particles->LineStyle == line_style_cylinder) )
    {
        gra_sphere_quality( particles->LineQuality );
    }

    t = 0.0;
    for( i=0; i<n; i++ )
    {
        if ( particles->ParticleData[4]->f[i]<0 ) continue;
        
        x = PartX[i];
        y = PartY[i];
        z = PartZ[i];
        c = PartC[i];

        if ( particles->Advance && !epMouseDown )
        {
            particles->X[i] = x;
            particles->Y[i] = y;
            particles->Z[i] = z;
            particles->C[i] = c;
            particles->I[i] = PartI[i];

            t = 0.0;
            while( t < particles->OutDT-CEPS )
            {
                dt = MIN( particles->OutDT-t,particles->MaxDT );
                while( TRUE )
                {
                    if ( dt < 1.0E-9 ) break;

                    x0 = x1 = x;
                    y0 = y1 = y;
                    z0 = z1 = z;

                    switch( particles->IntegMethod )
                    {
                        case particle_integ_euler:
                           vis_Euler( particles, model, i, &x0, &y0, &z0, &c, t, dt, f_x0, f_y0, f_z0, f_c0 );
                           if ( particles->IntegPolicy==particle_policy_adaptive )
                           {
                               vis_Euler( particles, model, i, &x1, &y1, &z1, &c, t,  dt / 2, f_x0, f_y0, f_z0, f_c0 );
                               vis_Euler( particles, model, i, &x1, &y1, &z1, &c, t + dt / 2, dt / 2, f_x0, f_y0, f_z0, f_c0 );
                           }
                        break;

                        case particle_integ_runge_kutta:
                           vis_RungeKutta( particles, model, i, &x0, &y0, &z0, &c, t,  dt, f_x0, f_y0, f_z0, f_c0 );
                           if ( particles->IntegPolicy==particle_policy_adaptive )
                           {
                               vis_RungeKutta( particles, model, i, &x1, &y1, &z1, &c, t, dt / 2, f_x0, f_y0, f_z0, f_c0 );
                               vis_RungeKutta( particles, model, i, &x1, &y1, &z1, &c, t + dt / 2, dt / 2, f_x0, f_y0, f_z0, f_c0 );
                           }
                        break;
                    }

                    if ( particles->IntegPolicy == particle_policy_fixed )
                    {
                        x1 = x0;
                        y1 = y0;
                        z1 = z0;
                        break;
                    }

                    if ( ABS(x0-x1) < CEPS && ABS(y0-y1) < CEPS && ABS(z0-z1) < CEPS ) break;

                    dt /= 2;

                    if ( BreakLoop ) break;
                }
                if ( BreakLoop ) break;

                t += dt;
                x = x1;
                y = y1;
                z = z1;

                if ( dt < 1.0E-9 )
                {
                    fprintf( stderr, "For Your record: stepping didn't succeed.\n" );
                    break;
                }
                if ( BreakLoop ) break;
            }
            if ( BreakLoop ) break;

            PartX[i] = x;
            PartY[i] = y;
            PartZ[i] = z;
            PartC[i] = c;
        }
        if ( BreakLoop ) break;

        if ( particles->Style == particle_style_vector )
        {
            LX = particles->X[i];
            LY = particles->Y[i];
            LZ = particles->Z[i];
            LC = particles->C[i];

            LX = ( 2.0*(LX-xmin) - (xmax-xmin) ) / s;
            LY = ( 2.0*(LY-ymin) - (ymax-ymin) ) / s;
            LZ = ( 2.0*(LZ-zmin) - (zmax-zmin) ) / s;

            x = ( 2.0*(x-xmin) - (xmax-xmin) ) / s;
            y = ( 2.0*(y-ymin) - (ymax-ymin) ) / s;
            z = ( 2.0*(z-zmin) - (zmax-zmin) ) / s;

#if 0
if ( i==185 )
{
extern double viewx,viewy,viewz,tox,toy,toz,upx,upy,upz;
viewx=LX;
viewy=LY;
viewz=LZ;
tox=x;
toy=y;
toz=z;
upx=0;
if ( ABS(LX-x)>ABS(LY-y) || ABS(LZ-z)>ABS(LY-y) ) { upy=1; upz=0; }
else { upy=0; upz=1; }
continue;
}
if ( (i%10) ) continue;
#endif


            pnt[0] = LX;
            pnt[1] = LY;
            pnt[2] = LZ;

            vec[0] = x - LX;
            vec[1] = y - LY;
            vec[2] = z - LZ;

            r = sqrt( vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2] );
            gra_arrow( pnt,vec,CScl*(c-CAdd),particles->LineStyle,
                   particles->ArrowStyle,0.1*particles->LineWidth*r );
        } else {
            x = ( 2.0*(x-xmin) - (xmax-xmin) ) / s;
            y = ( 2.0*(y-ymin) - (ymax-ymin) ) / s;
            z = ( 2.0*(z-zmin) - (zmax-zmin) ) / s;
            c = CScl*(c-CAdd);
            gra_sphere( x,y,z,c,particles->LineWidth*r*c );
        }

        if ( epMouseDown && ( i & 30 ) )
        {
            if ( RealTime() - gtime > TooLong2 )
                if ( ++epMouseDownTakesTooLong > 3 )
                {
                    if ( quick )
                        if ( particles->Style == particle_style_vector )
                        {
                             gra_end_lines( );
                        } else
                        {
                             gra_polygon_mode( GRA_FILL );
                        }
                    return FALSE;
                } else gtime = RealTime();
        }
    }

    particles->Advance = FALSE;

    if ( quick )
        if ( particles->Style == particle_style_vector )
        {
             gra_end_lines( );
        } else
        {
             gra_polygon_mode( GRA_FILL );
        }

    return TRUE;
}
/* Gets string representation of file type.  Returns the string. */
static var_t
filetype_builtin(const call_info_t *call_info)
{
	char *str_val = var_to_string(call_info->argv[0]);
	const int fnum = get_fnum(str_val);
	var_val_t var_val = { .string = "" };
	free(str_val);

	if(fnum >= 0)
	{
		const FileType type = curr_view->dir_entry[fnum].type;
		var_val.const_string = get_type_str(type);
	}
	return var_new(VTYPE_STRING, var_val);
}

/* Returns file type from position or -1 if the position has wrong value. */
static int
get_fnum(const char position[])
{
	if(strcmp(position, ".") == 0)
	{
		return curr_view->list_pos;
	}
	else
	{
		return -1;
	}
}

/* Checks current layout configuration.  Returns boolean value that reflects
 * state of specified layout type. */
static var_t
layoutis_builtin(const call_info_t *call_info)
{
	char *type;
	int result;

	type = var_to_string(call_info->argv[0]);
	if(strcmp(type, "only") == 0)
	{
		result = (curr_stats.number_of_windows == 1);
	}
	else if(strcmp(type, "split") == 0)
	{
		result = (curr_stats.number_of_windows == 2);
	}
	else if(strcmp(type, "vsplit") == 0)
	{
		result = (curr_stats.number_of_windows == 2 && curr_stats.split == VSPLIT);
	}
	else if(strcmp(type, "hsplit") == 0)
	{
		result = (curr_stats.number_of_windows == 2 && curr_stats.split == HSPLIT);
	}
	else
	{
		result = 0;
	}
	free(type);

	return var_from_bool(result);
}
Example #15
0
/* Evaluates invocation operation.  All operands are evaluated beforehand.
 * Returns zero on success, otherwise non-zero is returned. */
static int
eval_call_op(const char name[], int nops, expr_t ops[], var_t *result)
{
	int i;

	for(i = 0; i < nops; ++i)
	{
		if(eval_expr(&ops[i]) != 0)
		{
			return 1;
		}
	}

	if(strcmp(name, "==") == 0)
	{
		assert(nops == 2 && "Must be two arguments.");
		*result = var_from_bool(compare_variables(EQ, ops[0].value, ops[1].value));
	}
	else if(strcmp(name, "!=") == 0)
	{
		assert(nops == 2 && "Must be two arguments.");
		*result = var_from_bool(compare_variables(NE, ops[0].value, ops[1].value));
	}
	else if(strcmp(name, "<") == 0)
	{
		assert(nops == 2 && "Must be two arguments.");
		*result = var_from_bool(compare_variables(LT, ops[0].value, ops[1].value));
	}
	else if(strcmp(name, "<=") == 0)
	{
		assert(nops == 2 && "Must be two arguments.");
		*result = var_from_bool(compare_variables(LE, ops[0].value, ops[1].value));
	}
	else if(strcmp(name, ">") == 0)
	{
		assert(nops == 2 && "Must be two arguments.");
		*result = var_from_bool(compare_variables(GT, ops[0].value, ops[1].value));
	}
	else if(strcmp(name, ">=") == 0)
	{
		assert(nops == 2 && "Must be two arguments.");
		*result = var_from_bool(compare_variables(GE, ops[0].value, ops[1].value));
	}
	else if(strcmp(name, ".") == 0)
	{
		*result = eval_concat(nops, ops);
	}
	else if(strcmp(name, "!") == 0)
	{
		assert(nops == 1 && "Must be single argument.");
		*result = var_from_bool(!var_to_integer(ops[0].value));
	}
	else if(strcmp(name, "-") == 0 || strcmp(name, "+") == 0)
	{
		assert(nops == 1 && "Must be single argument.");
		var_val_t val = { .integer = var_to_integer(ops[0].value) };
		if(name[0] == '-')
		{
			val.integer = -val.integer;
		}
		*result = var_new(VTYPE_INT, val);
	}
	else
	{
Example #16
0
int
main(int argc, char *argv[])
{
	/* TODO: refactor main() function */

	static const int quit = 0;

	char dir[PATH_MAX];
	char **files = NULL;
	int nfiles = 0;

	if(get_cwd(dir, sizeof(dir)) == NULL)
	{
		perror("getcwd");
		return -1;
	}

	(void)vifm_chdir(dir);
	args_parse(&vifm_args, argc, argv, dir);
	args_process(&vifm_args, 1);

	if(strcmp(vifm_args.lwin_path, "-") == 0 ||
			strcmp(vifm_args.rwin_path, "-") == 0)
	{
		files = read_stream_lines(stdin, &nfiles, 1, NULL, NULL);
		if(reopen_term_stdin() != 0)
		{
			return EXIT_FAILURE;
		}
	}

	(void)setlocale(LC_ALL, "");
	srand(time(NULL));

	cfg_init();

	if(vifm_args.logging)
	{
		init_logger(1, vifm_args.startup_log_path);
	}

	init_filelists();
	regs_init();
	cfg_discover_paths();
	reinit_logger(cfg.log_file);

	/* Commands module also initializes bracket notation and variables. */
	init_commands();

	init_builtin_functions();
	update_path_env(1);

	if(init_status(&cfg) != 0)
	{
		puts("Error during session status initialization.");
		return -1;
	}

	/* Tell file type module what function to use to check availability of
	 * external programs. */
	ft_init(&external_command_exists);
	/* This should be called before loading any configuration file. */
	ft_reset(curr_stats.exec_env_type == EET_EMULATOR_WITH_X);

	init_option_handlers();

	if(!vifm_args.no_configs)
	{
		/* vifminfo must be processed this early so that it can restore last visited
		 * directory. */
		read_info_file(0);
	}

	ipc_init(vifm_args.server_name, &parse_received_arguments);
	/* Export chosen server name to parsing unit. */
	{
		var_val_t value = { .string = (char *)ipc_get_name() };
		var_t var = var_new(VTYPE_STRING, value);
		setvar("v:servername", var);
		var_free(var);
	}

	args_process(&vifm_args, 0);

	bg_init();

	fops_init(&enter_prompt_mode, &prompt_msg_custom);

	set_view_path(&lwin, vifm_args.lwin_path);
	set_view_path(&rwin, vifm_args.rwin_path);

	if(need_to_switch_active_pane(vifm_args.lwin_path, vifm_args.rwin_path))
	{
		swap_view_roles();
	}

	load_initial_directory(&lwin, dir);
	load_initial_directory(&rwin, dir);

	/* Force split view when two paths are specified on command-line. */
	if(vifm_args.lwin_path[0] != '\0' && vifm_args.rwin_path[0] != '\0')
	{
		curr_stats.number_of_windows = 2;
	}

	/* Prepare terminal for further operations. */
	curr_stats.original_stdout = reopen_term_stdout();
	if(curr_stats.original_stdout == NULL)
	{
		return -1;
	}

	if(!setup_ncurses_interface())
	{
		return -1;
	}

	{
		const colmgr_conf_t colmgr_conf = {
			.max_color_pairs = COLOR_PAIRS,
			.max_colors = COLORS,
			.init_pair = &init_pair,
			.pair_content = &pair_content,
			.pair_in_use = &pair_in_use,
			.move_pair = &move_pair,
		};
		colmgr_init(&colmgr_conf);
	}

	init_modes();
	init_undo_list(&undo_perform_func, NULL, &ui_cancellation_requested,
			&cfg.undo_levels);
	load_view_options(curr_view);

	curr_stats.load_stage = 1;

	if(!vifm_args.no_configs)
	{
		load_scheme();
		cfg_load();

		if(strcmp(vifm_args.lwin_path, "-") == 0)
		{
			flist_custom_set(&lwin, "-", dir, files, nfiles);
		}
		else if(strcmp(vifm_args.rwin_path, "-") == 0)
		{
			flist_custom_set(&rwin, "-", dir, files, nfiles);
		}
	}
	/* Load colors in any case to load color pairs. */
	cs_load_pairs();

	cs_write();
	setup_signals();

	/* Ensure trash directories exist, it might not have been called during
	 * configuration file sourcing if there is no `set trashdir=...` command. */
	(void)set_trash_dir(cfg.trash_dir);

	check_path_for_file(&lwin, vifm_args.lwin_path, vifm_args.lwin_handle);
	check_path_for_file(&rwin, vifm_args.rwin_path, vifm_args.rwin_handle);

	curr_stats.load_stage = 2;

	/* Update histories of the views to ensure that their current directories,
	 * which might have been set using command-line parameters, are stored in the
	 * history.  This is not done automatically as history manipulation should be
	 * postponed until views are fully loaded, otherwise there is no correct
	 * information about current file and relative cursor position. */
	flist_hist_save(&lwin, NULL, NULL, -1);
	flist_hist_save(&rwin, NULL, NULL, -1);

	/* Trigger auto-commands for initial directories. */
	vle_aucmd_execute("DirEnter", lwin.curr_dir, &lwin);
	vle_aucmd_execute("DirEnter", rwin.curr_dir, &rwin);

	update_screen(UT_FULL);
	modes_update();

	/* Run startup commands after loading file lists into views, so that commands
	 * like +1 work. */
	exec_startup_commands(&vifm_args);

	curr_stats.load_stage = 3;

	event_loop(&quit);

	return 0;
}

/* Checks whether pair is being used at the moment.  Returns non-zero if so and
 * zero otherwise. */
static int
pair_in_use(short int pair)
{
	int i;

	for(i = 0; i < MAXNUM_COLOR; ++i)
	{
		if(cfg.cs.pair[i] == pair || lwin.cs.pair[i] == pair ||
				rwin.cs.pair[i] == pair)
		{
			return 1;
		}
	}

	return 0;
}