From bug-octave-request at bevo dot che dot wisc dot edu Mon Dec 15 22:51:53 2003 Subject: assignment to structure elements fails From: "John W. Eaton" To: Paul Kienzle Cc: bug-octave at bevo dot che dot wisc dot edu Date: Mon, 15 Dec 2003 22:51:23 -0600 On 15-Dec-2003, Paul Kienzle wrote: | In octave-2.1.52 Debian and octave-cvs-2003-12-15, I can create | a structure element without specifying an index: | | octave:1> u.hour=1 | u = | { | hour = 1 | } | | I can modify that element: | | octave:2> u.hour=2 | u = | { | hour = 2 | } | | but I can't do the same for a structure returned from gmtime(): | | octave:3> t=gmtime(0); | octave:4> t.hour=1 | error: invalid structure assignment | error: assignment to structure element failed | error: assignment failed, or no method for `struct = scalar' | error: evaluating assignment expression near line 2, column 7 | | unless I use an explicit index number: | | octave:5> t(1).hour=2 | t = | { | hour = 2 | isdst = 0 | mday = 1 | min = 0 | mon = 0 | sec = 0 | usec = 0 | wday = 4 | yday = 0 | year = 70 | zone = GMT | } Hmm. The problem is that we have some code that does this: Octave_map m; m[key](0) = val; The non-const Octave_map::operator [] returns a reference to a cell array (the array part of the structure array corresponding to the given key) which is then indexed to assign val. But this can't update the size of the structure array, so the later assignment fails because of a dimension mismatch. Please try the following patch. It removes the definition of the Octave_map::operator[] (both const and non-const versions) and updates the rest of Octave to match. I see no really great way of fixing this problem other than to remove these functions and caution people that they should also not do things like m.contents(key)(0) = val; This is likely to break some user code but I see no other way of ensuring that the dimensions of all the Cell arrays inside an Octave_map remain consistent. Thanks, jwe 2003-12-15 John W. Eaton * oct-map.cc (Octave_map::assign): Use Octave_map::contents member function instead of operator []. * ov-struct.cc (octave_struct::subsasgn): Likewise. * DLD-FUNCTIONS/time.cc (extract_tm): Likewise. * DLD-FUNCTIONS/time.cc (mk_tm_map): Use Octave_map::assign member function instead of operator []. * DLD-FUNCTIONS/getrusage.cc (Fgetrusage): Likewise. * DLD-FUNCTIONS/getgrent.cc (mk_gr_map): Likewise. * DLD-FUNCTIONS/getpwent.cc (mk_pw_map): Likewise. * load-save.cc (do_load): Likewise. * ls-hdf5.cc (hdf5_read_next_data): Likewise. * ls-mat5.cc (read_mat5_binary_element): Likewise. * oct-map.cc (Octave_map::reshape): Likewise. * oct-map.cc (Octave_map::index): Likewise. * ov-fcn-handle.cc (Ffunctions): Likewise. * pt-idx.cc (make_arg_struct): Likewise. * sighandlers.cc (make_sig_struct): Likewise. * syscalls.cc (mk_stat_map): Likewise. * toplev.cc (Foctave_config_info): Likewise. * ls-hdf5.cc (add_hdf5_data): Temporary Octave_map is now const. * ls-mat5.cc (save_mat5_binary_element): Likewise. * oct-map.cc (Octave_map::assign (const std::string&, const octave_value&)): New function. * oct-map.h: Provide decl. (Octave_map::contents (const std::string&)): New function. (Octave_map::operator [] (const std::string&) const): Delete. (Octave_map::operator [] (const std::string&)): Delete. Index: src/load-save.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/load-save.cc,v retrieving revision 1.182 diff -u -r1.182 load-save.cc --- src/load-save.cc 25 Nov 2003 05:51:29 -0000 1.182 +++ src/load-save.cc 16 Dec 2003 04:44:49 -0000 at @ -471,7 +471,7 @@ if (format == LS_MAT_ASCII) retval = tc; else - retstruct[name] = tc; + retstruct.assign (name, tc); } else install_loaded_variable (force, name, tc, global, doc); Index: src/ls-hdf5.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/ls-hdf5.cc,v retrieving revision 1.2 diff -u -r1.2 ls-hdf5.cc --- src/ls-hdf5.cc 25 Nov 2003 06:05:20 -0000 1.2 +++ src/ls-hdf5.cc 16 Dec 2003 04:44:49 -0000 at @ -715,9 +715,9 @@ octave_value ov = dsub.tc; if (ov.is_list ()) - m [dsub.name] = ov.list_value (); + m.assign (dsub.name, octave_value (ov.list_value ())); else - m [dsub.name] = ov; + m.assign (dsub.name, ov); } if (have_h5giterate_bug) at @ -1165,8 +1165,8 @@ data_is_group = 1; // recursively add each element of the structure to this group - Octave_map m = tc.map_value (); - Octave_map::iterator i = m.begin (); + const Octave_map m = tc.map_value (); + Octave_map::const_iterator i = m.begin (); while (i != m.end ()) { // XXX FIXME XXX -- if the length of the structure array is Index: src/ls-mat5.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/ls-mat5.cc,v retrieving revision 1.2 diff -u -r1.2 ls-mat5.cc --- src/ls-mat5.cc 20 Nov 2003 04:55:21 -0000 1.2 +++ src/ls-mat5.cc 16 Dec 2003 04:44:50 -0000 at @ -425,8 +425,12 @@ { const char *key = elname + j*field_name_length; + Cell c (dim_vector (n, 1)); + for (int k = n-1; k >=0; k--) - m[key](k) = field_elts(j,k); + c(k) = field_elts(j,k); + + m.assign (key, c); } tc = m; at @ -851,21 +855,21 @@ { // an Octave structure */ // recursively write each element of the structure - Octave_map m = tc.map_value (); + const Octave_map m = tc.map_value (); { char buf[32]; FOUR_BYTE_INT maxfieldnamelength = 32; int fieldcnt = 0; - for (Octave_map::iterator i = m.begin (); i != m.end (); i++) + for (Octave_map::const_iterator i = m.begin (); i != m.end (); i++) fieldcnt++; write_mat5_tag (os, miINT32, 4); os.write ((char *)&maxfieldnamelength, 4); write_mat5_tag (os, miINT8, fieldcnt*32); - for (Octave_map::iterator i = m.begin (); i != m.end (); i++) + for (Octave_map::const_iterator i = m.begin (); i != m.end (); i++) { // write the name of each element std::string tstr = m.key (i); at @ -876,7 +880,7 @@ int len = m.numel (); - for (Octave_map::iterator i = m.begin (); i != m.end (); i++) + for (Octave_map::const_iterator i = m.begin (); i != m.end (); i++) { // write the data of each element Cell elts = m.contents (i); Index: src/oct-map.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/oct-map.cc,v retrieving revision 1.29 diff -u -r1.29 oct-map.cc --- src/oct-map.cc 15 Nov 2003 12:51:20 -0000 1.29 +++ src/oct-map.cc 16 Dec 2003 04:44:50 -0000 at @ -35,7 +35,7 @@ #include "utils.h" Cell -Octave_map::operator [] (const std::string& k) const +Octave_map::contents (const std::string& k) const { const_iterator p = seek (k); at @ -64,7 +64,7 @@ if (new_dims != dims ()) { for (const_iterator p = begin (); p != end (); p++) - retval[key(p)] = contents(p).reshape (new_dims); + retval.assign (key(p), contents(p).reshape (new_dims)); dimensions = new_dims; } at @ -126,7 +126,7 @@ { std::string k = t_keys[i]; - Cell t_rhs = rhs[k]; + Cell t_rhs = rhs.contents (k); assign (idx, k, t_rhs); at @ -207,6 +207,28 @@ } Octave_map& +Octave_map::assign (const std::string& k, const octave_value& rhs) +{ + if (empty ()) + { + map[k] = Cell (rhs); + + dimensions = dim_vector (1, 1); + } + else + { + dim_vector dv = dims (); + + if (dv.all_ones ()) + map[k] = Cell (rhs); + else + error ("invalid structure assignment"); + } + + return *this; +} + +Octave_map& Octave_map::assign (const std::string& k, const Cell& rhs) { if (empty ()) at @ -238,7 +260,7 @@ if (error_state) break; - retval[key(p)] = tmp; + retval.assign (key(p), tmp); } return error_state ? Octave_map () : retval; Index: src/oct-map.h =================================================================== RCS file: /usr/local/cvsroot/octave/src/oct-map.h,v retrieving revision 1.28 diff -u -r1.28 oct-map.h --- src/oct-map.h 10 Nov 2003 15:50:40 -0000 1.28 +++ src/oct-map.h 16 Dec 2003 04:44:50 -0000 at @ -76,10 +76,6 @@ int empty (void) const { return map.empty (); } - Cell& operator [] (const std::string& k) { return map[k]; } - - Cell operator [] (const std::string& k) const; - void del (const std::string& k) { iterator p = map.find (k); at @ -95,11 +91,10 @@ std::string key (const_iterator p) const { return p->first; } - Cell& contents (const_iterator p) - { return operator [] (key(p)); } + Cell contents (const std::string& k) const; Cell contents (const_iterator p) const - { return operator [] (key(p)); } + { return contents (key(p)); } const_iterator seek (const std::string& k) const { return map.find (k); } at @ -125,6 +120,8 @@ Octave_map& assign (const octave_value_list& idx, const std::string& k, const Cell& rhs); + Octave_map& assign (const std::string& k, const octave_value& rhs); + Octave_map& assign (const std::string& k, const Cell& rhs); Octave_map index (const octave_value_list& idx); Index: src/ov-fcn-handle.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/ov-fcn-handle.cc,v retrieving revision 1.6 diff -u -r1.6 ov-fcn-handle.cc --- src/ov-fcn-handle.cc 24 Nov 2003 21:24:37 -0000 1.6 +++ src/ov-fcn-handle.cc 16 Dec 2003 04:44:50 -0000 at @ -194,19 +194,19 @@ std::string fh_nm = fh->name (); - m ["function"](0) = fh_nm.substr (1); + m.assign ("function", fh_nm.substr (1)); if (fcn->is_nested_function ()) - m ["type"](0) = "subfunction"; + m.assign ("type", "subfunction"); else - m ["type"](0) = "simple"; + m.assign ("type", "simple"); std::string nm = fcn->fcn_file_name (); if (nm.empty ()) - m ["file"](0) = "built-in function"; + m.assign ("file", "built-in function"); else - m ["file"](0) = nm; + m.assign ("file", nm); retval = m; } Index: src/ov-struct.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/ov-struct.cc,v retrieving revision 1.36 diff -u -r1.36 ov-struct.cc --- src/ov-struct.cc 14 Nov 2003 19:49:56 -0000 1.36 +++ src/ov-struct.cc 16 Dec 2003 04:44:50 -0000 at @ -200,7 +200,7 @@ u = octave_value::empty_conv (type.substr (2), rhs); else { - Cell map_val = map[key]; + Cell map_val = map.contents (key); Cell map_elt = map_val.index (idx.front (), true); at @ -241,7 +241,7 @@ u = octave_value::empty_conv (type.substr (1), rhs); else { - Cell map_val = map[key]; + Cell map_val = map.contents (key); u = numeric_conv (map_val, type.substr (1)); } Index: src/pt-idx.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/pt-idx.cc,v retrieving revision 1.24 diff -u -r1.24 pt-idx.cc --- src/pt-idx.cc 26 Oct 2003 03:16:42 -0000 1.24 +++ src/pt-idx.cc 16 Dec 2003 04:44:50 -0000 at @ -202,6 +202,7 @@ { int n = args.size (); + // XXX FIXME XXX -- why not just make these Cell objects? octave_value_list subs_list (n, octave_value ()); octave_value_list type_list (n, octave_value ()); at @ -244,8 +245,8 @@ p_dyn_field++; } - m ["subs"] = subs_list; - m ["type"] = type_list; + m.assign ("subs", Cell (subs_list)); + m.assign ("type", Cell (type_list)); return m; } Index: src/sighandlers.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/sighandlers.cc,v retrieving revision 1.77 diff -u -r1.77 sighandlers.cc --- src/sighandlers.cc 9 Jul 2003 02:21:11 -0000 1.77 +++ src/sighandlers.cc 16 Dec 2003 04:44:50 -0000 at @ -546,143 +546,143 @@ Octave_map m; #ifdef SIGABRT - m ["ABRT"](0) = SIGABRT; + m.assign ("ABRT", SIGABRT); #endif #ifdef SIGALRM - m ["ALRM"](0) = SIGALRM; + m.assign ("ALRM", SIGALRM); #endif #ifdef SIGBUS - m ["BUS"](0) = SIGBUS; + m.assign ("BUS", SIGBUS); #endif #ifdef SIGCHLD - m ["CHLD"](0) = SIGCHLD; + m.assign ("CHLD", SIGCHLD); #endif #ifdef SIGCLD - m ["CLD"](0) = SIGCLD; + m.assign ("CLD", SIGCLD); #endif #ifdef SIGCONT - m ["CONT"](0) = SIGCONT; + m.assign ("CONT", SIGCONT); #endif #ifdef SIGEMT - m ["EMT"](0) = SIGEMT; + m.assign ("EMT", SIGEMT); #endif #ifdef SIGFPE - m ["FPE"](0) = SIGFPE; + m.assign ("FPE", SIGFPE); #endif #ifdef SIGHUP - m ["HUP"](0) = SIGHUP; + m.assign ("HUP", SIGHUP); #endif #ifdef SIGILL - m ["ILL"](0) = SIGILL; + m.assign ("ILL", SIGILL); #endif #ifdef SIGINFO - m ["INFO"](0) = SIGINFO; + m.assign ("INFO", SIGINFO); #endif #ifdef SIGINT - m ["INT"](0) = SIGINT; + m.assign ("INT", SIGINT); #endif #ifdef SIGIOT - m ["IOT"](0) = SIGIOT; + m.assign ("IOT", SIGIOT); #endif #ifdef SIGLOST - m ["LOST"](0) = SIGLOST; + m.assign ("LOST", SIGLOST); #endif #ifdef SIGPIPE - m ["PIPE"](0) = SIGPIPE; + m.assign ("PIPE", SIGPIPE); #endif #ifdef SIGPOLL - m ["POLL"](0) = SIGPOLL; + m.assign ("POLL", SIGPOLL); #endif #ifdef SIGPROF - m ["PROF"](0) = SIGPROF; + m.assign ("PROF", SIGPROF); #endif #ifdef SIGPWR - m ["PWR"](0) = SIGPWR; + m.assign ("PWR", SIGPWR); #endif #ifdef SIGQUIT - m ["QUIT"](0) = SIGQUIT; + m.assign ("QUIT", SIGQUIT); #endif #ifdef SIGSEGV - m ["SEGV"](0) = SIGSEGV; + m.assign ("SEGV", SIGSEGV); #endif #ifdef SIGSTOP - m ["STOP"](0) = SIGSTOP; + m.assign ("STOP", SIGSTOP); #endif #ifdef SIGSYS - m ["SYS"](0) = SIGSYS; + m.assign ("SYS", SIGSYS); #endif #ifdef SIGTERM - m ["TERM"](0) = SIGTERM; + m.assign ("TERM", SIGTERM); #endif #ifdef SIGTRAP - m ["TRAP"](0) = SIGTRAP; + m.assign ("TRAP", SIGTRAP); #endif #ifdef SIGTSTP - m ["TSTP"](0) = SIGTSTP; + m.assign ("TSTP", SIGTSTP); #endif #ifdef SIGTTIN - m ["TTIN"](0) = SIGTTIN; + m.assign ("TTIN", SIGTTIN); #endif #ifdef SIGTTOU - m ["TTOU"](0) = SIGTTOU; + m.assign ("TTOU", SIGTTOU); #endif #ifdef SIGURG - m ["URG"](0) = SIGURG; + m.assign ("URG", SIGURG); #endif #ifdef SIGUSR1 - m ["USR1"](0) = SIGUSR1; + m.assign ("USR1", SIGUSR1); #endif #ifdef SIGUSR2 - m ["USR2"](0) = SIGUSR2; + m.assign ("USR2", SIGUSR2); #endif #ifdef SIGVTALRM - m ["VTALRM"](0) = SIGVTALRM; + m.assign ("VTALRM", SIGVTALRM); #endif #ifdef SIGIO - m ["IO"](0) = SIGIO; + m.assign ("IO", SIGIO); #endif #ifdef SIGWINCH - m ["WINCH"](0) = SIGWINCH; + m.assign ("WINCH", SIGWINCH); #endif #ifdef SIGXCPU - m ["XCPU"](0) = SIGXCPU; + m.assign ("XCPU", SIGXCPU); #endif #ifdef SIGXFSZ - m ["XFSZ"](0) = SIGXFSZ; + m.assign ("XFSZ", SIGXFSZ); #endif return m; Index: src/syscalls.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/syscalls.cc,v retrieving revision 1.46 diff -u -r1.46 syscalls.cc --- src/syscalls.cc 26 Mar 2003 16:05:59 -0000 1.46 +++ src/syscalls.cc 16 Dec 2003 04:44:51 -0000 at @ -65,24 +65,24 @@ { Octave_map m; - m["dev"](0) = static_cast (fs.dev ()); - m["ino"](0) = fs.ino (); - m["modestr"](0) = fs.mode_as_string (); - m["nlink"](0) = fs.nlink (); - m["uid"](0) = fs.uid (); - m["gid"](0) = fs.gid (); + m.assign ("dev", static_cast (fs.dev ())); + m.assign ("ino", fs.ino ()); + m.assign ("modestr", fs.mode_as_string ()); + m.assign ("nlink", fs.nlink ()); + m.assign ("uid", fs.uid ()); + m.assign ("gid", fs.gid ()); #if defined (HAVE_STRUCT_STAT_ST_RDEV) - m["rdev"](0) = static_cast (fs.rdev ()); + m.assign ("rdev", static_cast (fs.rdev ())); #endif - m["size"](0) = fs.size (); - m["atime"](0) = fs.atime (); - m["mtime"](0) = fs.mtime (); - m["ctime"](0) = fs.ctime (); + m.assign ("size", fs.size ()); + m.assign ("atime", fs.atime ()); + m.assign ("mtime", fs.mtime ()); + m.assign ("ctime", fs.ctime ()); #if defined (HAVE_STRUCT_STAT_ST_BLKSIZE) - m["blksize"](0) = fs.blksize (); + m.assign ("blksize", fs.blksize ()); #endif #if defined (HAVE_STRUCT_STAT_ST_BLOCKS) - m["blocks"](0) = fs.blocks (); + m.assign ("blocks", fs.blocks ()); #endif return m; Index: src/toplev.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/toplev.cc,v retrieving revision 1.146 diff -u -r1.146 toplev.cc --- src/toplev.cc 3 Sep 2003 20:27:00 -0000 1.146 +++ src/toplev.cc 16 Dec 2003 04:44:51 -0000 at @ -670,10 +670,6 @@ bool octave_supports_dynamic_linking = false; #endif - // We do it this way instead of using a series of "m[KEY](0) = VAL" - // statements to avoid problems with gcc 2.96 (and possibly other - // compilers) that can't handle a long series of lines like that. - static bool initialized = false; static Octave_map m; at @ -786,7 +782,7 @@ if (! initialized) { - m ["dld"](0) = octave_value (octave_supports_dynamic_linking); + m.assign ("dld", octave_value (octave_supports_dynamic_linking)); int i = 0; at @ -795,7 +791,7 @@ const char *key = conf_info[i++]; if (key) - m [key](0) = octave_value (conf_info[i++]); + m.assign (key, octave_value (conf_info[i++])); else break; } at @ -810,7 +806,10 @@ std::string arg = args(0).string_value (); if (! error_state) - retval = m [arg.c_str ()](0); + { + Cell c = m.contents (arg.c_str ()); + retval = c(0); + } } else if (nargin == 0) retval = m; Index: src/DLD-FUNCTIONS/getgrent.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/DLD-FUNCTIONS/getgrent.cc,v retrieving revision 1.8 diff -u -r1.8 getgrent.cc --- src/DLD-FUNCTIONS/getgrent.cc 20 Dec 2002 22:43:55 -0000 1.8 +++ src/DLD-FUNCTIONS/getgrent.cc 16 Dec 2003 04:44:51 -0000 at @ -51,10 +51,10 @@ { Octave_map m; - m ["name"](0) = gr.name (); - m ["passwd"](0) = gr.passwd (); - m ["gid"](0) = static_cast (gr.gid ()); - m ["mem"](0) = gr.mem (); + m.assign ("name", gr.name ()); + m.assign ("passwd", gr.passwd ()); + m.assign ("gid", static_cast (gr.gid ())); + m.assign ("mem", octave_value (gr.mem ())); retval = m; } Index: src/DLD-FUNCTIONS/getpwent.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/DLD-FUNCTIONS/getpwent.cc,v retrieving revision 1.10 diff -u -r1.10 getpwent.cc --- src/DLD-FUNCTIONS/getpwent.cc 26 Apr 2003 04:50:38 -0000 1.10 +++ src/DLD-FUNCTIONS/getpwent.cc 16 Dec 2003 04:44:51 -0000 at @ -51,13 +51,13 @@ { Octave_map m; - m ["name"](0) = pw.name (); - m ["passwd"](0) = pw.passwd (); - m ["uid"](0) = static_cast (pw.uid ()); - m ["gid"](0) = static_cast (pw.gid ()); - m ["gecos"](0) = pw.gecos (); - m ["dir"](0) = pw.dir (); - m ["shell"](0) = pw.shell (); + m.assign ("name", pw.name ()); + m.assign ("passwd", pw.passwd ()); + m.assign ("uid", static_cast (pw.uid ())); + m.assign ("gid", static_cast (pw.gid ())); + m.assign ("gecos", pw.gecos ()); + m.assign ("dir", pw.dir ()); + m.assign ("shell", pw.shell ()); retval = m; } Index: src/DLD-FUNCTIONS/getrusage.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/DLD-FUNCTIONS/getrusage.cc,v retrieving revision 1.6 diff -u -r1.6 getrusage.cc --- src/DLD-FUNCTIONS/getrusage.cc 20 Dec 2002 22:43:55 -0000 1.6 +++ src/DLD-FUNCTIONS/getrusage.cc 16 Dec 2003 04:44:51 -0000 at @ -138,29 +138,29 @@ getrusage (RUSAGE_SELF, &ru); - tv_tmp ["sec"](0) = static_cast (ru.ru_utime.tv_sec); - tv_tmp ["usec"](0) = static_cast (ru.ru_utime.tv_usec); - m ["utime"](0) = octave_value (tv_tmp); - - tv_tmp ["sec"](0) = static_cast (ru.ru_stime.tv_sec); - tv_tmp ["usec"](0) = static_cast (ru.ru_stime.tv_usec); - m ["stime"](0) = octave_value (tv_tmp); + tv_tmp.assign ("sec", static_cast (ru.ru_utime.tv_sec)); + tv_tmp.assign ("usec", static_cast (ru.ru_utime.tv_usec)); + m.assign ("utime", octave_value (tv_tmp)); + + tv_tmp.assign ("sec", static_cast (ru.ru_stime.tv_sec)); + tv_tmp.assign ("usec", static_cast (ru.ru_stime.tv_usec)); + m.assign ("stime", octave_value (tv_tmp)); #if ! defined (RUSAGE_TIMES_ONLY) - m ["maxrss"](0) = static_cast (ru.ru_maxrss); - m ["ixrss"](0) = static_cast (ru.ru_ixrss); - m ["idrss"](0) = static_cast (ru.ru_idrss); - m ["isrss"](0) = static_cast (ru.ru_isrss); - m ["minflt"](0) = static_cast (ru.ru_minflt); - m ["majflt"](0) = static_cast (ru.ru_majflt); - m ["nswap"](0) = static_cast (ru.ru_nswap); - m ["inblock"](0) = static_cast (ru.ru_inblock); - m ["oublock"](0) = static_cast (ru.ru_oublock); - m ["msgsnd"](0) = static_cast (ru.ru_msgsnd); - m ["msgrcv"](0) = static_cast (ru.ru_msgrcv); - m ["nsignals"](0) = static_cast (ru.ru_nsignals); - m ["nvcsw"](0) = static_cast (ru.ru_nvcsw); - m ["nivcsw"](0) = static_cast (ru.ru_nivcsw); + m.assign ("maxrss", static_cast (ru.ru_maxrss)); + m.assign ("ixrss", static_cast (ru.ru_ixrss)); + m.assign ("idrss", static_cast (ru.ru_idrss)); + m.assign ("isrss", static_cast (ru.ru_isrss)); + m.assign ("minflt", static_cast (ru.ru_minflt)); + m.assign ("majflt", static_cast (ru.ru_majflt)); + m.assign ("nswap", static_cast (ru.ru_nswap)); + m.assign ("inblock", static_cast (ru.ru_inblock)); + m.assign ("oublock", static_cast (ru.ru_oublock)); + m.assign ("msgsnd", static_cast (ru.ru_msgsnd)); + m.assign ("msgrcv", static_cast (ru.ru_msgrcv)); + m.assign ("nsignals", static_cast (ru.ru_nsignals)); + m.assign ("nvcsw", static_cast (ru.ru_nvcsw)); + m.assign ("nivcsw", static_cast (ru.ru_nivcsw)); #endif #else at @ -178,46 +178,46 @@ fraction = ticks % HZ; seconds = ticks / HZ; - tv_tmp ["sec"](0) = static_cast (seconds); - tv_tmp ["usec"](0) = static_cast (fraction * 1e6 / HZ); - m ["utime"](0) = octave_value (tv_tmp); + tv_tmp.assign ("sec", static_cast (seconds)); + tv_tmp.assign ("usec", static_cast (fraction * 1e6 / HZ)); + m.assign ("utime", octave_value (tv_tmp)); ticks = t.tms_stime + t.tms_cstime; fraction = ticks % HZ; seconds = ticks / HZ; - tv_tmp ["sec"](0) = static_cast (seconds); - tv_tmp ["usec"](0) = static_cast (fraction * 1e6 / HZ); - m ["stime"](0) = octave_value (tv_tmp); + tv_tmp.assign ("sec", static_cast (seconds)); + tv_tmp.assign ("usec", static_cast (fraction * 1e6 / HZ)); + m.assign ("stime", octave_value (tv_tmp)); #else - tv_tmp ["sec"](0) = 0; - tv_tmp ["usec"](0) = 0; - m ["utime"](0) = octave_value (tv_tmp); - - tv_tmp ["sec"](0) = 0; - tv_tmp ["usec"](0) = 0; - m ["stime"](0) = octave_value (tv_tmp); + tv_tmp.assign ("sec", 0); + tv_tmp.assign ("usec", 0); + m.assign ("utime", octave_value (tv_tmp)); + + tv_tmp.assign ("sec", 0); + tv_tmp.assign ("usec", 0); + m.assign ("stime", octave_value (tv_tmp)); #endif double tmp = lo_ieee_nan_value (); - m ["maxrss"](0) = tmp; - m ["ixrss"](0) = tmp; - m ["idrss"](0) = tmp; - m ["isrss"](0) = tmp; - m ["minflt"](0) = tmp; - m ["majflt"](0) = tmp; - m ["nswap"](0) = tmp; - m ["inblock"](0) = tmp; - m ["oublock"](0) = tmp; - m ["msgsnd"](0) = tmp; - m ["msgrcv"](0) = tmp; - m ["nsignals"](0) = tmp; - m ["nvcsw"](0) = tmp; - m ["nivcsw"](0) = tmp; + m.assign ("maxrss", tmp); + m.assign ("ixrss", tmp); + m.assign ("idrss", tmp); + m.assign ("isrss", tmp); + m.assign ("minflt", tmp); + m.assign ("majflt", tmp); + m.assign ("nswap", tmp); + m.assign ("inblock", tmp); + m.assign ("oublock", tmp); + m.assign ("msgsnd", tmp); + m.assign ("msgrcv", tmp); + m.assign ("nsignals", tmp); + m.assign ("nvcsw", tmp); + m.assign ("nivcsw", tmp); #endif Index: src/DLD-FUNCTIONS/time.cc =================================================================== RCS file: /usr/local/cvsroot/octave/src/DLD-FUNCTIONS/time.cc,v retrieving revision 1.15 diff -u -r1.15 time.cc --- src/DLD-FUNCTIONS/time.cc 14 Mar 2003 01:17:18 -0000 1.15 +++ src/DLD-FUNCTIONS/time.cc 16 Dec 2003 04:44:52 -0000 at @ -40,17 +40,17 @@ { Octave_map m; - m ["usec"](0) = static_cast (t.usec ()); - m ["sec"](0) = static_cast (t.sec ()); - m ["min"](0) = static_cast (t.min ()); - m ["hour"](0) = static_cast (t.hour ()); - m ["mday"](0) = static_cast (t.mday ()); - m ["mon"](0) = static_cast (t.mon ()); - m ["year"](0) = static_cast (t.year ()); - m ["wday"](0) = static_cast (t.wday ()); - m ["yday"](0) = static_cast (t.yday ()); - m ["isdst"](0) = static_cast (t.isdst ()); - m ["zone"](0) = t.zone (); + m.assign ("usec", static_cast (t.usec ())); + m.assign ("sec", static_cast (t.sec ())); + m.assign ("min", static_cast (t.min ())); + m.assign ("hour", static_cast (t.hour ())); + m.assign ("mday", static_cast (t.mday ())); + m.assign ("mon", static_cast (t.mon ())); + m.assign ("year", static_cast (t.year ())); + m.assign ("wday", static_cast (t.wday ())); + m.assign ("yday", static_cast (t.yday ())); + m.assign ("isdst", static_cast (t.isdst ())); + m.assign ("zone", t.zone ()); return m; } at @ -60,17 +60,17 @@ { octave_base_tm tm; - tm.usec (m ["usec"](0) . int_value ()); - tm.sec (m ["sec"](0) . int_value ()); - tm.min (m ["min"](0) . int_value ()); - tm.hour (m ["hour"](0) . int_value ()); - tm.mday (m ["mday"](0) . int_value ()); - tm.mon (m ["mon"](0) . int_value ()); - tm.year (m ["year"](0) . int_value ()); - tm.wday (m ["wday"](0) . int_value ()); - tm.yday (m ["yday"](0) . int_value ()); - tm.isdst (m ["isdst"](0) . int_value ()); - tm.zone (m ["zone"](0) . string_value ()); + tm.usec (m.contents ("usec")(0) . int_value ()); + tm.sec (m.contents ("sec")(0) . int_value ()); + tm.min (m.contents ("min")(0) . int_value ()); + tm.hour (m.contents ("hour")(0) . int_value ()); + tm.mday (m.contents ("mday")(0) . int_value ()); + tm.mon (m.contents ("mon")(0) . int_value ()); + tm.year (m.contents ("year")(0) . int_value ()); + tm.wday (m.contents ("wday")(0) . int_value ()); + tm.yday (m.contents ("yday")(0) . int_value ()); + tm.isdst (m.contents ("isdst")(0) . int_value ()); + tm.zone (m.contents ("zone")(0) . string_value ()); return tm; } ------------------------------------------------------------- Octave is freely available under the terms of the GNU GPL. Octave's home on the web: http://www.octave.org How to fund new projects: http://www.octave.org/funding.html Subscription information: http://www.octave.org/archive.html -------------------------------------------------------------