static Object P_Chown(Object fn, Object uid, Object gid) {
#ifndef WIN32
    if (chown(Get_Strsym(fn), Get_Integer(uid), Get_Integer(gid)) == -1)
        Raise_System_Error1("~s: ~E", fn);
#endif
    return Void;
}

static Object P_Create_Pixmap (Object d, Object w, Object h, Object depth) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);

    return Make_Pixmap (dpy, XCreatePixmap (dpy, dr, Get_Integer (w),
                                            Get_Integer (h), Get_Integer (depth)));
}

static Object P_Create_Cursor (Object srcp, Object maskp, Object x, Object y,
                               Object f, Object b) {
    Pixmap sp = Get_Pixmap (srcp), mp;
    Display *d = PIXMAP(srcp)->dpy;

    mp = EQ(maskp, Sym_None) ? None : Get_Pixmap (maskp);
    return Make_Cursor (d, XCreatePixmapCursor (d, sp, mp,
        Get_Color (f), Get_Color (b), Get_Integer (x), Get_Integer (y)));
}

static Object P_Create_Glyph_Cursor (Object srcf, Object srcc, Object maskf,
                                     Object maskc, Object f, Object b) {
    Font sf = Get_Font (srcf), mf;
    Display *d = FONT(srcf)->dpy;

    mf = EQ(maskf, Sym_None) ? None : Get_Font (maskf);
    return Make_Cursor (d, XCreateGlyphCursor (d, sf, mf,
        Get_Integer (srcc), mf == None ? 0 : Get_Integer (maskc),
        Get_Color (f), Get_Color (b)));
}

static Object P_Create_Bitmap_From_Data (Object win, Object data, Object pw,
        Object ph) {
    register unsigned int w, h;

    Check_Type (win, T_Window);
    Check_Type (data, T_String);
    w = Get_Integer (pw);
    h = Get_Integer (ph);
    if (w * h > 8 * STRING(data)->size)
        Primitive_Error ("bitmap too small");
    return Make_Pixmap (WINDOW(win)->dpy,
                        XCreateBitmapFromData (WINDOW(win)->dpy, WINDOW(win)->win,
                                STRING(data)->data, w, h));
}

static Object P_Create_Window (Object parent, Object x, Object y, Object width,
                               Object height, Object border_width,
                               Object attr) {
    unsigned long mask;
    Window win;

    Check_Type (parent, T_Window);
    mask = Vector_To_Record (attr, Set_Attr_Size, Sym_Set_Attr, Set_Attr_Rec);
    if ((win = XCreateWindow (WINDOW(parent)->dpy, WINDOW(parent)->win,
            Get_Integer (x), Get_Integer (y), Get_Integer (width),
            Get_Integer (height), Get_Integer (border_width),
            CopyFromParent, CopyFromParent, CopyFromParent, mask, &SWA)) == 0)
        Primitive_Error ("cannot create window");
    return Make_Window (1, WINDOW(parent)->dpy, win);
}

static Object P_Mkdir(Object fn, Object mode) {
#ifndef WIN32
    if (mkdir(Get_Strsym(fn), Get_Integer(mode)) == -1)
        Raise_System_Error1("~s: ~E", fn);
#endif
    return Void;
}

void IntControl::Read_Deletes (void)
{
    int node;

    //---- store the delete data ----

    Show_Message ("Reading %s -- Record", delete_file.File_Type ());
    Set_Progress ();

    while (delete_file.Read ()) {
        Show_Progress ();

        Get_Integer (delete_file.Record (), &node);
        if (node == 0) continue;

        if (!delete_node.Add (node)) {
            Error ("Adding Delete Node Record");
        }
    }
    End_Progress ();

    delete_file.Close ();

    Print (2, "Number of %s Records = %d", delete_file.File_Type (), Progress_Count ());
}

static Object P_Write_Bitmap_File (int argc, Object *argv) {
    Pixmap pm;
    int ret, xhot = -1, yhot = -1;

    pm = Get_Pixmap (argv[1]);
    if (argc == 5)
        Primitive_Error ("both x-hot and y-hot must be specified");
    if (argc == 6) {
        xhot = Get_Integer (argv[4]);
        yhot = Get_Integer (argv[5]);
    }
    Disable_Interrupts;
    ret = XWriteBitmapFile (PIXMAP(argv[1])->dpy, Get_Strsym (argv[0]), pm,
                            Get_Integer (argv[2]), Get_Integer (argv[3]), xhot, yhot);
    Enable_Interrupts;
    return Bits_To_Symbols ((unsigned long)ret, 0, Bitmapstatus_Syms);
}

GLOBAL int Expr_Eval_Int(const char *str, const parser_extra* f, int *result)
{
	int err;
	expr_val e;

	e = Expr_Eval(str, f, &err);
	if (err == EXPR_EVAL_SUCCESS) *result = Get_Integer(e);

	return err;
}

static Object P_Translate_Coordinates (Object src, Object x, Object y,
                                       Object dst) {
    int rx, ry;
    Window child;
    Object l, t, z;
    GC_Node3;

    Check_Type (src, T_Window);
    Check_Type (dst, T_Window);
    if (!XTranslateCoordinates (WINDOW(src)->dpy, WINDOW(src)->win,
            WINDOW(dst)->win, Get_Integer (x), Get_Integer (y), &rx, &ry,
            &child))
        return False;
    l = t = P_Make_List (Make_Integer (3), Null);
    GC_Link3 (l, t, dst);
    Car (t) = Make_Integer (rx); t = Cdr (t);
    Car (t) = Make_Integer (ry), t = Cdr (t);
    z = Make_Window (0, WINDOW(dst)->dpy, child);
    Car (t) = z;
    GC_Unlink;
    return l;
}

void CheckSurvey::Survey_Weights (void)
{
	int id, count;
	double weight;
	char *str_ptr;

	Household_Data *household_ptr;

	count = 0;

	//---- read the survey household weights ----

	Show_Message ("Reading %s -- Record", weight_file.File_Type ());
	Set_Progress (50000);
	
	while (weight_file.Read ()) {
		str_ptr = weight_file.Record ();

		//---- check the household id ----

		str_ptr = Get_Integer (str_ptr, &id);
		if (id <= 0) continue;

		Show_Progress ();

		household_ptr = survey_hh_data.Get (id);
		if (household_ptr == NULL) continue;

		Get_Double (str_ptr, &weight);

		household_ptr->Location ((int) (weight + random.Probability ()));
		count++;
	}
	End_Progress ();
	weight_file.Close ();

	Print (2, "Number of %s Records = %d", weight_file.File_Type (), Progress_Count ());

	if (count != Progress_Count ()) {
		Print (1, "Number of Household Weights Kept = %d", count);
	}
}

void PlanSum::Read_HHList (void)
{
	int nfile, hhold;

	//---- read the household list files ----

	for (nfile=0; ; nfile++) {
		if (!hhlist_file.Open (nfile)) break;

		if (hhlist_file.Extend ()) {
			Show_Message ("Reading %s %s -- Record", hhlist_file.File_Type (), hhlist_file.Extension ());
		} else {
			Show_Message ("Reading %s -- Record", hhlist_file.File_Type ());
		}
		Set_Progress ();

		//---- store the household list ----

		while (hhlist_file.Read ()) {
			Show_Progress ();

			Get_Integer (hhlist_file.Record (), &hhold);

			if (hhold <= 0) continue;

			if (!hhold_list.Add (hhold)) {
				Error ("Adding Household %d", hhold);
			}
		}
		End_Progress ();

		hhlist_file.Close ();
	}
	hhold = hhold_list.Num_Records ();

	hhold_list.Max_Records (hhold);
	
	Print (2, "Number of Household List Records = %d", hhold);
}

	int    Dir (void)                 { return (Get_Integer (dir)); }

	int    Link (void)                { return (Get_Integer (link)); }

	int    Route (void)               { return (Get_Integer (route)); }

	int    Lane (void)                { return (Get_Integer (lane)); }

	int    Mode (void)                { return (Get_Integer (mode)); }

	int    Trip (void)                { return (Get_Integer (trip)); }

	int    Person (void)              { return (Get_Integer (person)); }