At 14:32 -0700 2/22/05, Larry Simonsen wrote:
>i am migrating an application which is off support from one 3000 to
>another (918 to a400).
>the application runs fine on the 918 but on the a400 (after using buldacct
>to migrate format, adding volume set information) i get an open error. the
>problem is i do not know the file it is trying to open.
>i have located the location of the fopen but this is in NM and i do not
>know how to locate and display the parameters including name. can someone
>please help pint me to which register has the pointers in it and what the
>offsets might be. also format for display of memory would be helpful.
As a first step, from Stan Sieler's / Lund's cseq, here is the
info for both HPFOPEN and FOPEN:
Procedure HPFOPEN (
Parm_0 : (# actual parameters) {R26}
filenum : var int32 ; {R25}
status : anyvar int32 ; {R24} := nil
itemnum01 : int32 ; {R23} := 0
itemval01 : anyvar record ; {SP-$0034, @32 -> 8208} := nil
itemnum02 : int32 ; {SP-$0038} := 0
itemval02 : anyvar record ; {SP-$003c, @32 -> 8208} := nil
itemnum03 : int32 ; {SP-$0040} := 0
itemval03 : anyvar record ; {SP-$0044, @32 -> 8208} := nil
itemnum04 : int32 ; {SP-$0048} := 0
itemval04 : anyvar record ; {SP-$004c, @32 -> 8208} := nil
itemnum05 : int32 ; {SP-$0050} := 0
itemval05 : anyvar record ; {SP-$0054, @32 -> 8208} := nil
itemnum06 : int32 ; {SP-$0058} := 0
itemval06 : anyvar record ; {SP-$005c, @32 -> 8208} := nil
itemnum07 : int32 ; {SP-$0060} := 0
itemval07 : anyvar record ; {SP-$0064, @32 -> 8208} := nil
itemnum08 : int32 ; {SP-$0068} := 0
itemval08 : anyvar record ; {SP-$006c, @32 -> 8208} := nil
itemnum09 : int32 ; {SP-$0070} := 0
itemval09 : anyvar record ; {SP-$0074, @32 -> 8208} := nil
itemnum10 : int32 ; {SP-$0078} := 0
itemval10 : anyvar record ; {SP-$007c, @32 -> 8208} := nil
itemnum11 : int32 ; {SP-$0080} := 0
itemval11 : anyvar record ; {SP-$0084, @32 -> 8208} := nil
itemnum12 : int32 ; {SP-$0088} := 0
itemval12 : anyvar record ; {SP-$008c, @32 -> 8208} := nil
itemnum13 : int32 ; {SP-$0090} := 0
itemval13 : anyvar record ; {SP-$0094, @32 -> 8208} := nil
itemnum14 : int32 ; {SP-$0098} := 0
itemval14 : anyvar record ; {SP-$009c, @32 -> 8208} := nil
itemnum15 : int32 ; {SP-$00a0} := 0
itemval15 : anyvar record ; {SP-$00a4, @32 -> 8208} := nil
Parm_33 : int32 ; {SP-$00a8} := 0
Parm_34 : anyvar record ; {SP-$00ac, @32 -> 8208} := nil
Parm_35 : int32 ; {SP-$00b0} := 0
Parm_36 : anyvar record ; {SP-$00b4, @32 -> 8208} := nil
Parm_37 : int32 ; {SP-$00b8} := 0
Parm_38 : anyvar record ; {SP-$00bc, @32 -> 8208} := nil
Parm_39 : int32 ; {SP-$00c0} := 0
Parm_40 : anyvar record ; {SP-$00c4, @32 -> 8208} := nil
Parm_41 : int32 ; {SP-$00c8} := 0
Parm_42 : anyvar record ; {SP-$00cc, @32 -> 8208} := nil
Parm_43 : int32 ; {SP-$00d0} := 0
Parm_44 : anyvar record ; {SP-$00d4, @32 -> 8208} := nil
Parm_45 : int32 ; {SP-$00d8} := 0
Parm_46 : anyvar record ; {SP-$00dc, @32 -> 8208} := nil
Parm_47 : int32 ; {SP-$00e0} := 0
Parm_48 : anyvar record ; {SP-$00e4, @32 -> 8208} := nil
Parm_49 : int32 ; {SP-$00e8} := 0
Parm_50 : anyvar record ; {SP-$00ec, @32 -> 8208} := nil
Parm_51 : int32 ; {SP-$00f0} := 0
Parm_52 : anyvar record ; {SP-$00f4, @32 -> 8208} := nil
Parm_53 : int32 ; {SP-$00f8} := 0
Parm_54 : anyvar record ; {SP-$00fc, @32 -> 8208} := nil
Parm_55 : int32 ; {SP-$0100} := 0
Parm_56 : anyvar record ; {SP-$0104, @32 -> 8208} := nil
Parm_57 : int32 ; {SP-$0108} := 0
Parm_58 : anyvar record ; {SP-$010c, @32 -> 8208} := nil
Parm_59 : int32 ; {SP-$0110} := 0
Parm_60 : anyvar record ; {SP-$0114, @32 -> 8208} := nil
Parm_61 : int32 ; {SP-$0118} := 0
Parm_62 : anyvar record ; {SP-$011c, @32 -> 8208} := nil
Parm_63 : int32 ; {SP-$0120} := 0
Parm_64 : anyvar record ; {SP-$0124, @32 -> 8208} := nil
Parm_65 : int32 ; {SP-$0128} := 0
Parm_66 : anyvar record ; {SP-$012c, @32 -> 8208} := nil
Parm_67 : int32 ; {SP-$0130} := 0
Parm_68 : anyvar record ; {SP-$0134, @32 -> 8208} := nil
Parm_69 : int32 ; {SP-$0138} := 0
Parm_70 : anyvar record ; {SP-$013c, @32 -> 8208} := nil
Parm_71 : int32 ; {SP-$0140} := 0
Parm_72 : anyvar record ; {SP-$0144, @32 -> 8208} := nil
Parm_73 : int32 ; {SP-$0148} := 0
Parm_74 : anyvar record ; {SP-$014c, @32 -> 8208} := nil
Parm_75 : int32 ; {SP-$0150} := 0
Parm_76 : anyvar record ; {SP-$0154, @32 -> 8208} := nil
Parm_77 : int32 ; {SP-$0158} := 0
Parm_78 : anyvar record ; {SP-$015c, @32 -> 8208} := nil
Parm_79 : int32 ; {SP-$0160} := 0
Parm_80 : anyvar record ; {SP-$0164, @32 -> 8208} := nil
Parm_81 : int32 ; {SP-$0168} := 0
Parm_82 : anyvar record ; {SP-$016c, @32 -> 8208} := nil
Parm_83 : int32 ; {SP-$0170} := 0
Parm_84 : anyvar record ) {SP-$0174, @32 -> 8208} := nil
{(up to 41 itemnum/itemval pairs) }
{ }
{Note: most parameters of type "ca" must start }
{ with some character, followed by the text/data, }
{ and then be terminated by the same character. }
{ E.g.: -disc- (6 characters) }
{ or: ~disc~ }
{ }
{item#s sizes meanings: (some "deduced"/"undoc") }
{ ## $$$ }
{ 0 end of list (can override r26) }
{ 1 ? "parse string" (undocumented) }
{ 2 ca -filename- }
{ 3 i32 domain: 0=new, 1=perm, }
{ 2=temp, 3=old }
{ 4=make PERM at open! }
{ 4 - (apparently not a valid option) }
{ 5 i32 Designator: 0=(name) }
{ 1=$stdlist, 2=$newpass }
{ 3=$oldpass, 4=$stdin }
{ 5=$stdinx, 6=$null, 7 = $stderr }
{ 6 i32 format: 0=f, 1=v, 2=u }
{ 0 = fixed }
{ 1 = variable }
{ 2 = undefined }
{ 4 = "root" (undoc) }
{ 6 = "acct" (undoc) }
{ 7 = "group" (undoc) }
{ 9 = byte stream (see opt 77 too!) }
{ 10 = "hpdir" }
{ 7 i32 CCTL 0=cctl, 1=nocctl }
{ 8 ca tape label }
{ 9 i32 fileeq 1=disable fileequate }
{ 10 $0a i32 file type: 0=standard, }
{ 1=old KSAM, 2=RIO, 3=NM KSAM, }
{ 4=circ, 5=spool, 6=MSG, }
{ 9=DIR, 13=fifo, 14=symlink }
{ 11 $0b i32 access type: 0=read, }
{ 1=write, 2=writesave }
{ 3=append, 4=IO, 5=update }
{ 6=execute, 7=executeRead }
{ 8=NoAccessCheck, 9=DirectoryRead }
{ 12 $0c i32 Locking: 0=nolock, 1=lock }
{ 13 $0d i32 Exclusive: }
{ 0 = read or read-share }
{ 1 = exclusive, }
{ 2 = read-share (SEMI) }
{ 3 = share (SHR) }
{ 14 $0e i32 multiaccess: 0=nomulti, }
{ 1=multi, 2=gmulti }
{ 15 $0f i32 multiRecord: 0=none,1=MR }
{ 16 $10 i32 nowait: 0=wait, 1=nowait }
{ 17 $11 i32 copy mode: 1=COPY }
{ 18 $12 @i32 Short Mapped (itemval is address of }
{ a 32-bit pointer) }
{ 19 $13 i32 record size (bytes) }
{ 20 $14 ca -devicename- (i.e.: delimited on both sides) }
{ 21 $15 @i64 Long Mapped (itemval is address of }
{ a 64-bit pointer) }
{ 22 $16 ca -volumeclass- }
{ 23 $17 ca -volumename- }
{ 24 $18 i32 density (e.g.: 6250) }
{ 25 $19 ca printer environment (~text~) }
{ 26 $1a ca remote environment (~text~) }
{ 27 $1b i32 output priority (1=low, 13=high) }
{ 28 $1c ca48 spooled message (~text~) }
{ 29 $1d i32 (temp) priv level (0..3) }
{ 30 $1e i32 labeled tape type (0=ANSI, 1=IBM) }
{ 31 $1f ca labeled tape expiration (~mm/dd/yy~) }
{ 32 $20 ca labeled tape sequence (~text~) }
{ 33 $21 i32 # userlabels }
{ 34 $22 i32 # spooler copies }
{ 35 $23 i32 filesize (#records, usually) }
{ (is #blocks for variable-recsize files) }
{ 36 $24 i32 initial allocation (#records) }
{ 37 $25 i32 filecode (-32768..32767) }
{ 38 $26 i32 file priv level (0..3) }
{ 39 $27 i32 will_access: 0=seq, 1=random }
{ 40 $28 i32 block factor }
{ 41 $29 i32 Name semantics }
{ 0 = MPE-escaped }
{ 1 = MPE-only }
{ 2 = Posix }
{ 3 = Program (undoc) }
{ 4 = Session (undoc) }
{ 42 $2a ca8 ~Device class~ (up to 8 + 2 chars) }
{ 43 $2b ca20 UFID (20 bytes) }
{ 44 $2c i32 #buffers (1..31, or less for some) }
{ 45 $2d ca2 fill character (e.g., ' ') }
{ 46 $2e i32 buffering: 0=buf, 1=NOBUF }
{ 47 $2f i32 # extents (1..32) }
{ 48 $30 i32 reverse VT }
{ 49 $31 i32 pin# for owner of file (PM needed!) }
{ (undocumented, unsupported?) }
{ 50 $32 i32 final disposition }
{ 0 = no change }
{ 1 = perm }
{ 2 = temp job (rewound) }
{ 3 = temp job (not rewound) }
{ 4 = purge }
{ 5 = convert perm -> temp }
{ 51 $33 str filename in a Pascal/XL string }
{ NOTE: if used in Pascal, with a }
{ string variable, the address passed }
{ in is actually: addr (string[1]). }
{ The intrinsic compensates by }
{ subtracting 4 from the address to get }
{ the address of the length portion. }
{ So, be careful from other languages! }
{ 52 $34 ca -file equation text- }
{ 53 $35 i32 ASCII/binary (0=binary, 1=ASCII) }
{ 54 $36 ca KSAM keys definition (KSAM/XL or }
{ KSAM/3000) }
{ 55 $39 ca Raw mode (ca = record as follows) }
{ ca256 file label }
{ i4 ptr to intrinsic interface extens }
{ i4 len of intrinsic interface extens }
{ i4 ptr to type mgr extensions }
{ i4 len of type mgr extensions }
{ i4 ptr to storage mgr extensions }
{ i4 len of storage mgr extensions }
{ 56 $38 i32 user object class (0..10) }
{ Many of the following are undocumented. }
{ 57 $39 i32 Variable access rights }
{ (0 = no, 1 = yes) }
{ 58 $3a i32? Unprotected (PM) (0 = no, 1 = yes) }
{ 59 $3b i32 System Object Class (0..799) }
{ (if virt addr already allocated, }
{ item 59 appears to be ignored) }
{ 60 $3c i32 Use File PID (0=no, 1=yes) }
{ 61 $3d ? Access Rights }
{ 62 $3e i32? Unprotected Variable Access Rights }
{ (0 = no, 1 = yes) }
{ 63 $3f i32 Must Allocate Secondary Storage }
{ (0 = no, 1 = yes) }
{ 64 $40 ca ACD (text<cr>) }
{ 65 $41 i32? Close Priv }
{ 66 $42 i32? Link Device }
{ 67 $43 i32 Internal Spool Files (0..127) }
{ 68 $44 i32 Link Spool File (0=no, 1=yes) }
{ 69 $45 i32 Private Spool File (0=no, 1=yes) }
{ 70 $46 i32 Keep Spool File (0=nokeep, 1=keep) }
{ 71 $47 i32? Spool File Type: }
{ 0 = output, 1 = input }
{ 2 = job, 3 = data }
{ 72 $48 i32 Suppress Page Eject (1 = suppress) }
{ 73 $49 ? Resv Device Ticket }
{ 74 $4a i32 Header/Trailer ("Inherit Printer Env") }
{ 0 = enable header, enable trailer }
{ 1 = disable header, enable trailer }
{ 2 = enable header, disable trailer }
{ 3 = disable header, disable trailer }
{ 75 $4b ? Type Manager Address }
{ 76 $4c ? Form ID }
{ 77 $4d i32 Read (*and* Write) Format: }
{ 0 = use standard record view }
{ 1 = HPDIRREAD returnd priv info }
{ (UFID & Link ID of files) }
{ (caller must be in "system code") }
{ 2 = access as byte stream }
{ 3 = (like 1 + "split") (undoc) }
{ Note: to successfully create byte stream }
{ files *without* linefeeds, open with }
{ opt 77=2 and opt 6=9. SS }
{ 78 $4e i32? "Raw operation" (undocumented) }
{ 0 = raw create (undocumented) }
{ 1 = raw recover (undocumented) }
{ 79 $4f i32? POSIX Non-Block mode (0=false,1=true) }
{ 80 $50 i32? MPE/iX Device Type (undoc) }
{ 0 = disc }
{ 7 = streams }
{ 81 $51 i32 Symbolic Link traversal }
{ 0 = follow symbolic links }
{ 1 = don't follow symbolic links }
{ (only applies to final component }
{ of a path; will open the link, }
{ not what it "points" to.) }
{--- new in 5.5---- }
{ 82 $54 i32 Reserved File Descriptor }
{ 0 = use default fd }
{ 1 = use reserved fd }
{ 2 = don't use reserved fd }
{ 83 $53 i32 Override Protection (0=no, 1=yes) }
{ 84 $52 i32 Standard Access }
{ 0 = use standard access }
{ 1 = ignore standard access }
{--- new in 6.0---- }
{ 85 $55 i32 HSM_AUTO (0=auto, 1=noauto) }
{ 86 $56 i32 HSM_REMAIN (0=change, 1=remain) }
{--- new in 6.5---- }
{ 87 $57 @i64 Large Mapped (itemval is address of }
{ a 64-bit pointer) }
extensible 1
uncheckable_anyvar
________________________________________________________________________
Function FOPEN (
filename : anyvar record ; {R26} := nil
foptions : uint16 ; {R25} := 0
aoptions : uint16 ; {R24} := 0
recsize : int16 ; {R23} := 0
device : anyvar record ; {SP-$0034} := nil
formmsg : anyvar record ; {SP-$0038} := nil
userlabels : int16 ; {SP-$003a} := 0
blockfactor : int16 ; {SP-$003e} := 0
numbuffers : int16 ; {SP-$0042} := 0
filesize : int32 ; {SP-$0048} := 0
numextents : int16 ; {SP-$004a} := 0
initialalloc : int16 ; {SP-$004e} := 0
filecode : int16 ) {SP-$0052} := 0
:= file# : int16 {R28}
{ CCE: Filed opened }
{ CCL: File not opened...do: FCHECK (0, err) for why. }
{if ok, file# is > 0 (0 indicates error) }
{filename: terminate with blank or null. }
{foptions: (16-bits) }
{ 00:02 (reserved) }
{ 02:03 file type: 0=standard, 1=KSAM/V }
{ 2=RIO, 3=KSAM/XL, 4=CIR, }
{ 5=NM Spool, 6=MSG, 7=KSAM64 }
{ 05:01 1=Disallow File Equates, 0=Allow }
{ 06:01 1=Labelled tape }
{ 07:01 1=CCTL }
{ 08:02 Record format: 0=fixed, 1=Var, }
{ 2=Undefined (useful for tapes) }
{ 10:03 Designator: 0=use filename, }
{ 1=$STDLIST, 2=$NEWPASS, 3=$OLDPASS }
{ 4=$STDIN (don't use), 5=$STDINX, }
{ 6=$NULL. }
{ 13:01 1=ASCII, 0=Binary }
{ 14:02 Domain: 0=new, 1=OldPerm, 2=OldTemp, }
{ 3=Old (Temp first, Perm second) }
{aoptions: (16 bits) }
{ 00:03 (reserved) }
{ 03:01 1=COPY mode }
{ 04:01 1=NOWAIT }
{ 05:02 Multiaccess: 0=NOMULTI,1=MULTI,2=GMULTI }
{ 07:01 1=NOBUF }
{ 08:02 Exclusive: 0=default, 1=EXClusive, }
{ 2=SEMI (read-share), 3=SHR }
{ 10:01 1=LOCK }
{ 11:01 1=MR, 0=NOMR. Note: Intrinsics manual }
{ incorrectly calls this [NO]MULTI. }
{ 12:04 Access type: }
{ 0 = IN (read) }
{ 1 = OUT (write, resets EOF to 0) }
{ 2 = WriteSAVE (don't reset EOF to 0) }
{ 3 = APPEND }
{ 4 = INOUT (read/write) }
{ 5 = UPDATE }
{ 6 = eXecute (needs PM) }
{ 7 = load program (needs PM) }
{ 8 = no acc check (needs PM) }
{ 9 = dir read (needs PM) }
{recsize: < 0 = bytes, > 0 = 16-bit words }
{device: terminate with a blank or null. }
{formmsg: up to 49 bytes, terminate with period }
{userlabels: 0..254 }
{blockfactor: 1..255 }
{numbuffers: }
{ 04:07 = # spooler output priority (1..13) }
{ 04:07 = # spoolfile copies (0..127) }
{ 11:05 = # buffers (1..31, or less for }
{ Cir, RIO, MSG, KSAM/V, KSAM/XL) }
{filesize: default = 1023 }
{numextents: only 1 or >1 are meaningful }
{initialalloc: only meaningful if = numextents }
{filecode: if < 0, must be in PM. }
uncheckable_anyvar
_______________
| |
| |
| r | Alfredo http://www.adager.com
| e |
| g | F. Alfredo Rego
| a | Manager, R & D Labs
| d | Adager Corporation
| A | Sun Valley, Idaho 83353-3000 U.S.A.
| |
|_______________|
* To join/leave the list, search archives, change list settings, *
* etc., please visit http://raven.utc.edu/archives/hp3000-l.html *
|
