     1   
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    23  
    24   
     2  
     3  
     4  
     5  
     6  
     7  
     8  
     9  
    10  
    11  
    12  
    13  
    14  
    15  
    16  typedef struct
    17  {
    18  int errnum;
    19  char errmess[252];
    20  } os_error;
    21  
    22  
    23  
    24  
    25  
    26  
    27  
    28  
    29  
    30   0  ||  1 
    31  
    31  
    32  
    33  
    34  
    35  
    36   
     8  
     8  
     8  
     8  
     8  
     8  
     8  
     9  
    10  
    11  
    12   
    13  
    14  
    15  
    17  
    18  
    19    
     1  ___toplevel 
     1  
     2  
     3   
     7  
     7  
     7  
     7  
     8  
     9  
    10  
    11  
    12  
    13  
    14  
    15  
    16  typedef struct {
    17     int r[10];             
    18  } _kernel_swi_regs;
    19  
    20  typedef struct {
    21     int load, exec;        
    22     int start, end;        
    23  } _kernel_osfile_block;
    24  
    25  typedef struct {
    26     void * dataptr;        
    27     int nbytes, fileptr;
    28     int buf_len;           
    29     char * wild_fld;       
    30  } _kernel_osgbpb_block;
    31  
    32  typedef struct {
    33     int errnum;            
    34     char errmess[252];     
    35  } _kernel_oserror;
    36  
    37  typedef struct stack_chunk {
    38     unsigned long sc_mark;        
    39     struct stack_chunk *sc_next, *sc_prev;
    40     unsigned long sc_size;
    41     int (*sc_deallocate)();
    42  } _kernel_stack_chunk;
    43  
    44  extern _kernel_stack_chunk *_kernel_current_stack_chunk(void);
    45  
    46  extern void _kernel_setreturncode(unsigned code);
    47  
    48  extern void _kernel_exit(int);
    49  
    50  extern void _kernel_raise_error(_kernel_oserror *);
    51   
    52  
    53  extern void _kernel_exittraphandler(void);
    54  
    55  
    56  
    57  
    58  
    59  
    60  
    61  
    62  
    63  
    64  
    65  
    66  extern int _kernel_hostos(void);
    67   
    70  
    70  
    70  
    71  extern int _kernel_fpavailable(void);
    72   
    75  
    75  
    75  
    76  
    77  extern _kernel_oserror *_kernel_swi(int no, _kernel_swi_regs *in,
    78                                     _kernel_swi_regs *out);
    79   
    85  
    85  
    85  
    85  
    85  
    85  
    86  extern _kernel_oserror *_kernel_swi_c(int no, _kernel_swi_regs *in,
    87                                        _kernel_swi_regs *out, int *carry);
    88   
    93  
    93  
    93  
    93  
    93  
    94  extern char *_kernel_command_string(void);
    95   
    98  
    98  
    98  
    99   
   108  
   108  
   108  
   108  
   108  
   108  
   108  
   108  
   108  
   109  
   110  
   111  extern int _kernel_osbyte(int op, int x, int y);
   112   
   122  
   122  
   122  
   122  
   122  
   122  
   122  
   122  
   122  
   122  
   123  extern int _kernel_osrdch(void);
   124   
   127  
   127  
   127  
   128  extern int _kernel_oswrch(int ch);
   129   
   133  
   133  
   133  
   133  
   134  extern int _kernel_osbget(unsigned handle);
   135   
   139  
   139  
   139  
   139  
   140  extern int _kernel_osbput(int ch, unsigned handle);
   141   
   145  
   145  
   145  
   145  
   146  extern int _kernel_osgbpb(int op, unsigned handle, _kernel_osgbpb_block *inout); 
   153  
   153  
   153  
   153  
   153  
   153  
   153  
   154  extern int _kernel_osword(int op, int *data);
   155   
   160  
   160  
   160  
   160  
   160  
   161  extern int _kernel_osfind(int op, char *name);
   162   
   167  
   167  
   167  
   167  
   167  
   168  extern int _kernel_osfile(int op, const char *name, _kernel_osfile_block *inout);
   169   
   173  
   173  
   173  
   173  
   174  extern int _kernel_osargs(int op, unsigned handle, int arg);
   175   
   181  
   181  
   181  
   181  
   181  
   181  
   182  extern int _kernel_oscli(const char *s);
   183   
   191  
   191  
   191  
   191  
   191  
   191  
   191  
   191  
   192  extern _kernel_oserror *_kernel_last_oserror(void);
   193   
   202  
   202  
   202  
   202  
   202  
   202  
   202  
   202  
   202  
   203  extern _kernel_oserror *_kernel_getenv(const char *name, char *buffer, unsigned size);
   204   
   209  
   209  
   209  
   209  
   209  
   210  extern _kernel_oserror *_kernel_setenv(const char *name, const char *value);
   211   
   215  
   215  
   215  
   215  
   216  extern int _kernel_system(const char *string, int chain);
   217   
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   232  
   233  
   234  extern unsigned _kernel_alloc(unsigned minwords, void **block);
   235   
   242  
   242  
   242  
   242  
   242  
   242  
   242  
   243  typedef void freeproc(void *);
   244  typedef void * allocproc(unsigned);
   245  
   246  extern void _kernel_register_allocs(allocproc *malloc, freeproc *free);
   247   
   254  
   254  
   254  
   254  
   254  
   254  
   254  
   255  typedef int _kernel_ExtendProc(int  , void**  );
   256  extern _kernel_ExtendProc *_kernel_register_slotextend(_kernel_ExtendProc *proc);
   257   
   264  
   264  
   264  
   264  
   264  
   264  
   264  
   265  extern int _kernel_escape_seen(void);
   266   
   273  
   273  
   273  
   273  
   273  
   273  
   273  
   274  typedef union {
   275      struct {int s:1, u:16, x: 15; unsigned mhi, mlo; } i;
   276      int w[3]; } _extended_fp_number;
   277  
   278  typedef struct {
   279     int r4, r5, r6, r7, r8, r9;
   280     int fp, sp, pc, sl;
   281     _extended_fp_number f4, f5, f6, f7; } _kernel_unwindblock;
   282  
   283  extern int _kernel_unwind(_kernel_unwindblock *inout, char **language);
   284   
   296  
   296  
   296  
   296  
   296  
   296  
   296  
   296  
   296  
   296  
   296  
   296  
   297  extern char *_kernel_procname(int pc);
   298   
   302  
   302  
   302  
   302  
   303  extern char *_kernel_language(int pc);
   304   
   308  
   308  
   308  
   308  
   309   
   319  
   319  
   319  
   319  
   319  
   319  
   319  
   319  
   319  
   319  
   320  extern unsigned _kernel_udiv(unsigned divisor, unsigned dividend);
   321  extern unsigned _kernel_urem(unsigned divisor, unsigned dividend);
   322  extern unsigned _kernel_udiv10(unsigned dividend);
   323  
   324  extern int _kernel_sdiv(int divisor, int dividend);
   325  extern int _kernel_srem(int divisor, int dividend);
   326  extern int _kernel_sdiv10(int dividend);
   327  
   328   
   331  
   331  
   331  
   332  typedef enum { NotHandled, Handled } _kernel_HandledOrNot;
   333  
   334  typedef struct {
   335     int regs [16];
   336  } _kernel_registerset;
   337  
   338  typedef struct {
   339     int regs [10];
   340  } _kernel_eventregisters;
   341  
   342  typedef void (*PROC) (void);
   343  typedef _kernel_HandledOrNot (*_kernel_trapproc) (int code, _kernel_registerset *regs);
   344  typedef _kernel_HandledOrNot (*_kernel_eventproc) (int code, _kernel_registerset *regs);
   345  
   346  typedef struct {
   347     int size;
   348     int codestart, codeend;
   349     char *name;
   350     PROC (*InitProc)(void);
   351     PROC FinaliseProc;
   352     _kernel_trapproc TrapProc;
   353     _kernel_trapproc UncaughtTrapProc;
   354     _kernel_eventproc EventProc;
   355     _kernel_eventproc UnhandledEventProc;
   356     void (*FastEventProc) (_kernel_eventregisters *);
   357     int (*UnwindProc) (_kernel_unwindblock *inout, char **language);
   358     char * (*NameProc) (int pc);
   359  } _kernel_languagedescription;
   360  
   361  typedef int _kernel_ccproc(int, int, int);
   362  
   363  extern int _kernel_call_client(int a1, int a2, int a3, _kernel_ccproc callee);
   364   
   369  
   369  
   369  
   369  
   369  
   370  extern int _kernel_client_is_module(void);
   371   
   375  
   375  
   375  
   375  
   376  extern int _kernel_processor_mode(void);
   377  
   378  extern void _kernel_irqs_on(void);
   379  
   380  extern void _kernel_irqs_off(void);
   381  
   382  extern int _kernel_irqs_disabled(void);
   383   
   384  
   385  extern void *_kernel_RMAalloc(size_t size);
   386  
   387  extern void *_kernel_RMAextend(void *p, size_t size);
   388  
   389  extern void _kernel_RMAfree(void *p);
   390  
   391  
   392   
   393  
    21  
    22  
    23  
    25  
    26   
    27  
    28  typedef void *dll;                       
    29  
    30  typedef struct                           
    31  {
    32    char *name;                            
    33    int version;                           
    34    char *entryNames;                      
    35    void *branchTable;                     
    36  }
    37  dll_table;
    38  
    39  typedef struct                           
    40  {
    41    dll d;                                 
    42    char *name;                            
    43    int version;                           
    44    char *author;                          
    45    unsigned instSize;                     
    46  }
    47  dll_infostr;
    48  
    49   
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    67  
    68  os_error *dll_find(const char *name,int version,dll *d);
    69  os_error *dll_findFromTable(const dll_table *table,int entries);
    70  os_error *dll_load(void *buffer,const char *name);
    71  os_error *dll_lose(dll d);
    72  os_error *dll_appDying(void);
    73  os_error *dll_giveCLibData(void *data);
    74  os_error *dll_findCLibData(void **p);
    75  os_error *dll_instanceVars(void *buffer,int *size,int *magic);
    76  os_error *dll_setInstanceVars(dll d,void *workspace);
    77  os_error *dll_appData(void);
    78  os_error *dll_readStackPtr(int *sp);
    79  os_error *dll_setStackPtr(int sp);
    80  os_error *dll_nameApp(const char *name);
    81  os_error *dll_info(dll d,dll_infostr *i);
    82  os_error *dll_findEntry(dll d,const char *name,void (**entry)());
    83  os_error *dll_saveHandle(int *handle);
    84  os_error *dll_restoreHandle(int *handle);
    85  os_error *dll_findInstanceVars(dll d,void **addr);
    86  os_error *dll_registerAppEntryTable(void (**btable)(),char *names);
    87  os_error *dll_findAppEntry(char *name,void (**func)());
    88  os_error *dll_setExtensionTable(void (**btable)(),char *names);
    89  
    90   
    91  
    92  
    93  
    94   
    95  
    96  
    97  
    98  void _dll_appspace(void);
    99  void _dll_clibdata(void);
   100  
   101  
   102  
   103  
   104  
   105  
   106  
   107  
   108  
   109  
   110   
   111  
   112  
   113  
   114  int _dll_system(const char *command);
   115  int _dll_ksystem(const char *command,int chain);
   116  os_error *_dll_oscli(const char *command);
   117  os_error *_dll_starttask(const char *command);
   118  
   119  
   120  
   121  
   122  
   123  
   124  
   125  
   126  
   127  
   128   
   129  
   130  dll _dll_loadExtension(const char *name);
   131  void _dll_freeExtension(dll d);
   132  
   133   
   134  
   135  
   136  
   137  int _dll_setjmp(void);
   138  void _dll_longjmped(int sp);
   139  
   140  
   141  
   142  
   143  
   144  
   145  
   146  
   147   
   148  
   149  
   150  
   151  void _dll_giveMemory(void);
   152  
   153  
   154  
   155  
   156  
   157  
   158  
   159   
   160  
   161  
   162  
   163  
   164  
   165  
   166  
   167  
   168  
   169  
   170  
   171  
   172  
   173  
   174  
   175  
   176  
   177  
   178  
   179  
   180  
   181  
   182  
   183  
   184  
    38  
    41  
    41  
    41  
    42  
    43  
    45  
    45  
    46  
    47   
     2  
     3  
     4  
     5  
     7  
     8  
     9  
    10  typedef enum {
    11  filing_NOTFOUND = 0,
    12  filing_FILE = 1,
    13  filing_DIRECTORY = 2,
    14  filing_IMAGEFILE = 3
    15  } filing_objtype;
    16  typedef struct {
    17  int loadaddr;
    18  int execaddr;
    19  int length;
    20  int attrib;
    21  filing_objtype objtype;
    22  char name[  32 ];
    23  } filing_direntry;
    24  typedef struct {
    25  int loadaddr;
    26  int execaddr;
    27  int length;
    28  int attrib;
    29  filing_objtype objtype;
    30  int SIN;
    31  char date[ 5];
    32  char name[  32 ];
    33  } filing_fulldirentry;
    34  typedef enum {
    35  readdirtype_DIRENTRY,
    36  readdirtype_FULLDIRENTRY,
    37  readdirtype_NAMEONLY
    38  } filing_readdirtype;
    39  typedef struct {
    40  char *dirname;
    41  void *buf;
    42  int size;
    43  filing_readdirtype type;
    44  union {
    45  filing_direntry *direntry;
    46  filing_fulldirentry *fulldirentry;
    47  char *name;
    48  void *act;
    49  } act;
    50  int offset;
    51  int read;
    52  char *match;
    53  } filing_dirdata;
    54  os_error *Filing_OpenDir( char *dirname, filing_dirdata *dirdata,
    55  int bufsize, filing_readdirtype type);
    56  void *Filing_ReadDir( filing_dirdata *dirdata);
    57   unsigned  Filing_CloseDir( filing_dirdata *dirdata);
    58  os_error *Filing_ReadDirNames( char *dirname, char *buf,
    59  int *number, int *offset,
    60  int size, char *match);
    61  os_error *Filing_ReadDirEntry( char *dirname, filing_direntry *buf,
    62  int *number, int *offset,
    63  int size, char *match);
    64  os_error *Filing_ReadFullDirEntry( char *dirname, filing_fulldirentry *buf,
    65  int *number, int *offset,
    66  int size, char *match);
    67  os_error *Filing_ReadCatalogue( char *filename, filing_objtype *objtype,
    68  int *loadaddr, int *execaddr, int *length,
    69  int *attrib, int *filetype);
    70  os_error *Filing_SingleFullDirEntry( char *filename,
    71  filing_fulldirentry *buf, int size);
    72  os_error *Filing_SingleFullDirEntry2( char *dirname,
    73  filing_fulldirentry *buf,
    74  int size, char *filename);
    75  char *Filing_GetPathname( char *filename, char *pathname);
    76  char *Filing_GetLeafname( char *filename, char *leafname);
    77  char *Filing_FindLeafname( char *filename);
    78  char *Filing_MakePath( char *newpath, char *dirname, char *leafname);
    79  typedef os_error *(Filing_ScanDir_StartDir) ( char *dirname,
    80  filing_fulldirentry *dirdata);
    81  typedef os_error *(Filing_ScanDir_FoundFile) ( char *dirname,
    82  filing_fulldirentry *filedata);
    83  typedef os_error *(Filing_ScanDir_EndDir) ( char *dirname,
    84  filing_fulldirentry *dirdata);
    85  os_error *Filing_ScanDir( char *dirname,
    86  Filing_ScanDir_StartDir *startdirproc,
    87  Filing_ScanDir_FoundFile *foundfileproc,
    88  Filing_ScanDir_EndDir *enddirproc);
    89  os_error *Filing_ScanDirByDir( char *dirname,
    90  Filing_ScanDir_StartDir *startdirproc,
    91  Filing_ScanDir_FoundFile *foundfileproc,
    92  Filing_ScanDir_EndDir *enddirproc);
    93  
    94   
     2  
     3  
     4  
     5  
     7  
     8  
    10  extern void Error_ReportInternal(int errornum, char *report, ...);
    11  extern void Error_ReportFatalInternal(int errornum, char *report, ...);
    12  extern void Error_Report(int errornum, char *report, ...);
    13  extern void Error_ReportFatal(int errornum, char *report, ...);
    14  extern  unsigned  Error_Check(os_error *error);
    15  extern void Error_CheckFatal(os_error *error);
    16  extern  unsigned  Error_OutOfMemory( unsigned  fatal, char *place);
    17  
    18  
    19  
    20  
    21  extern os_error *Error__Ref_global( void);
    22  
    23   1  && ! 0 
    24  
    24  
    25  
    26  
    27  
    28  
    35  
    35  
    35  
    35  
    35  
    35  
    35  
    36  
     2  
     3  
     4   
     5  
     6  
     7  
     8  
     9  
    10  
    11  
    32   
    35  
    35  
    35  
    36  
    37  
    38  
    39  
    40  
    41  
    42  
    43  
    44  
    45  os_error *Filing_OpenDir(char *dirname, filing_dirdata *dirdata,
    46                           int bufsize, filing_readdirtype type)
    47  {
    48   os_error *er;
    49   filing_objtype objtype;
    50  
    51  
    52  static  const struct { int errnum; char errmess[ 1 + sizeof(  "Not enough memory" )]; } __outofmemory_= {   (0x00+ 0x00801C00 )  ,  "Not enough memory" }; os_error * __outofmemory  = (os_error *) &__outofmemory_ ;
    53  
    54  
    55   dirdata->buf= 0 ;
    56   dirdata->dirname= 0 ;    
    57  
    58   if (er=Filing_ReadCatalogue(dirname,&objtype, 0 , 0 , 0 , 0 , 0 ),er!= 0 )
    59     return er;
    60   if (objtype==1) {
    61      (*Error__Ref_global()) .errnum= (0x01+ 0x00801C00 ) ;
    62     sprintf( (*Error__Ref_global()) .errmess,"Directory '%s' is actually a file!",dirname);
    63     return & (*Error__Ref_global()) ;
    64   }
    65   else if (objtype==0) {
    66      (*Error__Ref_global()) .errnum= (0x02+ 0x00801C00 ) ;
    67     sprintf( (*Error__Ref_global()) .errmess,"Directory '%s' doesn't exist!",dirname);
    68     return & (*Error__Ref_global()) ;
    69   }
    70  
    71   dirdata->dirname= malloc(( strlen(dirname)+1 )) ;
    72   if (dirdata->dirname== 0 )
    73     return __outofmemory;
    74   strcpy(dirdata->dirname,dirname);
    75  
    76   dirdata->buf= malloc(( bufsize )) ;
    77   if (dirdata->buf== 0 )
    78     return __outofmemory;
    79  
    80   dirdata->size=bufsize;
    81   dirdata->type=type;
    82   dirdata->offset=0;
    83   dirdata->read=0;
    84   dirdata->match= 0 ;   
    85                          
    86  
    87    
    88    
    89  
    90   
    95  
    95  
    95  
    95  
    95  
    96   return  0 ;
    97  }
    98  
    99  void *Filing_ReadDir(filing_dirdata *dirdata)
   100  {
   101   os_error *er;
   102  
   103   if (dirdata->read==0) {     
   104     if (dirdata->offset==-1) {     
   105       return  0 ;
   106     }
   107  
   108     dirdata->read=255;    
   109  
   110     switch(dirdata->type) {
   111       case readdirtype_DIRENTRY:
   112        er=Filing_ReadDirEntry(dirdata->dirname,(filing_direntry *)dirdata->buf,
   113                               &dirdata->read,&dirdata->offset,
   114                               dirdata->size,dirdata->match);
   115        if (er!= 0 ) {
   116          return  0 ;
   117        }
   118        if (dirdata->read==0) {
   119          dirdata->offset=-1;
   120          return  0 ;
   121        }
   122        dirdata->read--;
   123        dirdata->act.direntry=(filing_direntry *)dirdata->buf;
   124        break;
   125       case readdirtype_FULLDIRENTRY:
   126        er=Filing_ReadFullDirEntry(dirdata->dirname,(filing_fulldirentry *)dirdata->buf,
   127                                   &dirdata->read,&dirdata->offset,
   128                                   dirdata->size,dirdata->match);
   129        if (er!= 0 ) {
   130          return  0 ;
   131        }
   132        if (dirdata->read==0) {
   133          dirdata->offset=-1;
   134          return  0 ;
   135        }
   136        dirdata->read--;
   137        dirdata->act.fulldirentry=(filing_fulldirentry *)dirdata->buf;
   138        break;
   139       case readdirtype_NAMEONLY:
   140        er=Filing_ReadDirNames(dirdata->dirname,(char *)dirdata->buf,
   141                               &dirdata->read,&dirdata->offset,
   142                               dirdata->size,dirdata->match);
   143        if (er!= 0 ) {
   144          return  0 ;
   145        }
   146        if (dirdata->read==0) {
   147          dirdata->offset=-1;
   148          return  0 ;
   149        }
   150        dirdata->read--;
   151        dirdata->act.name=(char *)dirdata->buf;
   152        break;
   153     }
   154  
   155   }
   156   else {      
   157     switch(dirdata->type) {
   158       case readdirtype_DIRENTRY:
   159        dirdata->read--;
   160        dirdata->act.direntry=(filing_direntry *)(((int)(&(dirdata->act.direntry->name))+
   161                                                 strlen(dirdata->act.direntry->name)+4)&~3);
   162        break;
   163       case readdirtype_FULLDIRENTRY:
   164        dirdata->read--;
   165        dirdata->act.fulldirentry=(filing_fulldirentry *)(((int)(&(dirdata->act.fulldirentry->name))+
   166                                                         strlen(dirdata->act.fulldirentry->name)+4)&~3);
   167        break;
   168       case readdirtype_NAMEONLY:
   169        dirdata->read--;
   170   
   171        dirdata->act.name=(char *)(dirdata->act.name+strlen(dirdata->act.name)+1);
   172        break;
   173     }
   174  
   175   }
   176  
   177   return (void *)dirdata->act.act;
   178  }
   179  
   180   unsigned  Filing_CloseDir(filing_dirdata *dirdata)
   181  {
   182    unsigned  ret= 1 ;
   183  
   184   if (dirdata->buf!= 0 ) {
   185      free(( dirdata->buf )) ;
   186   }
   187   else {
   188     ret= 0 ;
   189   }
   190  
   191   if (dirdata->dirname!= 0 ) {
   192      free(( dirdata->dirname )) ;
   193   }
   194   else {
   195     ret= 0 ;
   196   }
   197  
   198   return ret;
   199  }
   200  
