int main(void) { ARP2_SysCallBase = OpenResource(ARP2_SYSCALL_NAME); if (ARP2_SysCallBase != NULL) { LONG fd = arp2sys_open("/etc/passwd", O_RDONLY, 0); PrintFault(IoErr(), "arp2sys_open"); Printf("Opened file %ld\n", fd); if (fd != -1) { char buf[512]; LONG count = arp2sys_read(fd, buf, sizeof (buf) - 1); buf[511] = 0; PrintFault(IoErr(), "arp2sys_read"); Printf("Read %ld bytes.\n", count); PutStr(buf); PutStr("\n"); } arp2sys_close(fd); PrintFault(IoErr(), "arp2sys_close"); Printf("Closed file %ld\n", fd); } return 0; }
LONG setup(char *name, STRPTR args) { BOOL retval = RETURN_FAIL; IPTR myargs[]={0,0,0,0}; struct RDArgs *rdargs; struct RDArgs rda = {{args, strlen(args), 0}, 0, 0, 0, NULL, 0}; rda.RDA_Source.CS_Buffer[rda.RDA_Source.CS_Length]='\n'; rdargs = ReadArgs(setuptemplate,myargs, &rda); if (rdargs) { printf ( "setup\n\tdevice=%s unit=%ld\n", (STRPTR)myargs[0], *(LONG *)myargs[1] ); if (myargs[2]) { printf("\ttable in partition=%s\n", (STRPTR)myargs[2]); } else printf("\ttable in whole HD\n"); if (myargs[3]) { printf("\tscipt is %s\n", (STRPTR)myargs[3]); } else printf("\tinteractive\n"); FreeArgs(rdargs); } else PrintFault(IoErr(), name); return retval; }
int main() { struct Process *child; struct TagItem tags[] = { { NP_Entry, (IPTR) entry }, { NP_Cli, (IPTR) TRUE }, { NP_Name, (IPTR) "test" }, { NP_NotifyOnDeath, (IPTR) TRUE }, { TAG_DONE, 0 } }; child = CreateNewProc(tags); if(child) { ULONG childid = GetETask((struct Task*) child)->et_UniqueID; Printf("Waiting for child with id %d\n", childid); ChildWait(childid); Printf("Child exited, freeing child\n"); ChildFree(childid); } else PrintFault(IoErr(), "Couldn't create child process"); return 0; }
void TxCom(char *com, char *a1, char *a2, char *a3, char *a4, char *a5, char *a6) { int i; ubyte txBuf[MAXMSGSIZE]; int header = 0x82; /* Long message by default */ int data1 = 0x01; int data2 = 0x02; int data3 = 0x03; int data4 = 0x04; word res; if (a1[0]) sscanf(a1, "%x", &header); if (a2[0]) sscanf(a2, "%x", &data1); if (a3[0]) sscanf(a3, "%x", &data2); if (a4[0]) sscanf(a4, "%x", &data3); if (a5[0]) sscanf(a5, "%x", &data4); txBuf[0] = header & 0xFF; txBuf[1] = data1 & 0xFF; txBuf[2] = data2 & 0xFF; txBuf[3] = data3 & 0xFF; txBuf[4] = data4 & 0xFF; for (i = 5; i < MAXMSGSIZE; ++i) txBuf[i] = i; /* put known values in buf */ PrintMessage(txBuf); res = ML_Transmit(txBuf); if (res < 0) PrintFault("ML_Transmit", res); }
/*** Functions **************************************************************/ int main(void) { int rc = RETURN_OK; struct RDArgs *rdargs = NULL; IPTR args[ARG_COUNT] = { 0 }; if ((rdargs = ReadArgs("FILE/M/A,VERBOSE/S", args, NULL)) != NULL) { CONST_STRPTR *files = (CONST_STRPTR *) args[ARG_FILE], file; while ((file = *files++) != NULL) { if (identify(file, args[ARG_VERBOSE]) != RETURN_OK) { rc = RETURN_WARN; } } FreeArgs(rdargs); } else { PrintFault(IoErr(), ERROR_HEADER); rc = RETURN_FAIL; } return rc; }
int main(void) { IPTR args[NOOFARGS] = { (IPTR)NULL, (IPTR)0 }; struct RDArgs *rda; int result; int error = RETURN_OK; ULONG buffers = 0; rda = ReadArgs(ARG_TEMPLATE, args, NULL); if (rda != NULL) { STRPTR drive = (STRPTR)args[ARG_DRIVE]; ULONG *bufsptr = (ULONG *)args[ARG_BUFFERS]; if (bufsptr != NULL) { buffers = *bufsptr; } result = AddBuffers(drive, buffers); if (result == -1) { Printf("%s has %ld buffers\n", drive, IoErr()); } else if (result > 0) { Printf("%s has %ld buffers\n", drive, (LONG)result); } else { PrintFault(IoErr(), "AddBuffers"); error = RETURN_FAIL; } FreeArgs(rda); } else { PrintFault(IoErr(), "AddBuffers"); error = RETURN_FAIL; } return error; }
int identify(CONST_STRPTR filename, BOOL verbose) { int rc = RETURN_OK; BPTR lock = Lock(filename, ACCESS_READ); if (lock != NULL) { struct DataType *dt = ObtainDataType(DTST_FILE, lock, TAG_DONE); if (dt != NULL) { struct DataTypeHeader *dth = dt->dtn_Header; if (!verbose) { Printf ( "%s:\t%s/%s\n", filename, gid2string(dth->dth_GroupID), dth->dth_Name ); } else { ULONG gid = AROS_LONG2BE(dth->dth_GroupID), id = AROS_LONG2BE(dth->dth_ID); Printf ( "File: %s\n" "Type: %s/%s\t(GID: %.4s, ID: %.4s)\n" "DT Basename: %s\n\n", filename, gid2string(dth->dth_GroupID), dth->dth_Name, (CONST_STRPTR) &gid, (CONST_STRPTR) &id, dth->dth_BaseName ); } } else { FPrintf(Error(), ERROR_HEADER": Could not obtain datatype for file.\n"); rc = RETURN_FAIL; } UnLock(lock); } else { PrintFault(IoErr(), ERROR_HEADER); rc = RETURN_FAIL; } return rc; }
void RemHandlerCom(char *com, char *a1, char *a2, char *a3, char *a4, char *a5, char *a6) { int addr; word res; if (a1[0] == 0) { printf("must give handler address\n"); return; } sscanf(a1, "%x", &addr); res = ML_DetachHandler((ML_MsgHandler *)addr); if (res < 0) PrintFault("ML_RemHandler", res); }
void WaitRxCom(char *com, char *a1, char *a2, char *a3, char *a4, char *a5, char *a6) { word handle = lastRxHandle; word res; word timeout = -1; if (a1[0]) sscanf(a1, "%d", &timeout); printf("waiting on handle 0x%lx, timeout %ld\n", handle, timeout); res = ML_WaitForRx(handle, timeout); if (res < 0) PrintFault("ML_WaitForRx", res); else PrintMessage(buffer); }
void SetUpRxCom(char *com, char *a1, char *a2, char *a3, char *a4, char *a5, char *a6) { int type = 0x84; word res; if (a1[0]) sscanf(a1, "%x", &type); printf("setting up rx for msg type 0x%x\n", type); res = ML_SetUpRx(buffer, type); if (res < 0) PrintFault("ML_SetUpRx", res); else { lastRxHandle = res; printf("handle 0x%lx\n", res); } }
int main() { struct Process *child; struct TagItem tags[] = { { NP_Entry, (IPTR) entry }, { NP_Cli, (IPTR) TRUE }, { NP_Name, (IPTR) "test" }, { NP_NotifyOnDeath, (IPTR) TRUE }, { TAG_DONE, 0 } }; child = CreateNewProc(tags); if(child) { ULONG childstatus; ULONG childid = GetETask((struct Task*) child)->et_UniqueID; Printf("Checking status value for non-existing child id\n"); childstatus = ChildStatus(-1); assert(childstatus == CHILD_NOTFOUND); Printf("Result: CHILD_NOTFOUND\n"); Printf("Checking status value for running child id\n"); childstatus = ChildStatus(childid); assert(childstatus == CHILD_ACTIVE); Printf("Result: CHILD_ACTIVE\n"); ChildWait(childid); Printf("Checking status value for died child id\n"); childstatus = ChildStatus(childid); assert(childstatus == CHILD_EXITED); Printf("Result: CHILD_EXITED\n"); ChildFree(childid); Printf("Checking status value for freed child id\n"); childstatus = ChildStatus(childid); assert(childstatus == CHILD_NOTFOUND); Printf("Result: CHILD_NOTFOUND\n"); } else PrintFault(IoErr(), "Couldn't create child process"); return 0; }
/* * matchwild - pushes filenames which match the given pattern. * it also returns a count of the matches found. */ int matchwild(char *pattern) { static char *special = "#?*%([|"; /* )] */ struct AnchorPath *APath; int matches = 0; LONG error; /* Check if correct OS */ if (isOldDOS()) return; /* Check if pattern is special */ if (!(strpbrk(pattern, special))) return; APath = AllocMem(sizeof(struct AnchorPath) + BLKSIZE, MEMF_CLEAR); if (!(APath)) return; APath->ap_Strlen = BLKSIZE; APath->ap_BreakBits = SIGBREAKF_CTRL_C; if ((error = MatchFirst((UBYTE *) pattern, APath)) == 0) { do { ++matches; push(strdup((char *) APath->ap_Buf)); } while ((error = MatchNext(APath)) == 0); } MatchEnd(APath); if (error != ERROR_NO_MORE_ENTRIES) { PrintFault(error, NULL); } FreeMem(APath, sizeof(struct AnchorPath) + BLKSIZE); return matches; }
void PrintError(char * msg) { PrintFault(IoErr(), "IoErr"); if( G->CliUsage ) { Printf("\n +++ Error: %s\n", (long) msg ); } else { STATIC UBYTE okm[] = "Ok"; static struct IntuiText body = { 0,0,0, 15,5, NULL, NULL, NULL }; static struct IntuiText ok = { 0,0,0, 6,3, NULL, okm, NULL }; if(((struct Process *)FindTask(NULL))->pr_WindowPtr != (APTR)-1L) { body.IText = (UBYTE *)msg; AutoRequest(NULL,&body,NULL,&ok,0,0,640,72); } } }
void TxManyCom(char *com, char *a1, char *a2, char *a3, char *a4, char *a5, char *a6) { int i; int times = 100; /* Number of times to send message */ ubyte txBuf[MAXMSGSIZE]; int header = 0x82; /* Long message by default */ int data1 = 0x01; int data2 = 0x02; int data3 = 0x03; int data4 = 0x04; word res; if (a1[0]) sscanf(a1, "%d", ×); if (a2[0]) sscanf(a2, "%x", &header); if (a3[0]) sscanf(a3, "%x", &data1); if (a4[0]) sscanf(a4, "%x", &data2); if (a5[0]) sscanf(a5, "%x", &data3); if (a6[0]) sscanf(a6, "%x", &data4); txBuf[0] = header & 0xFF; txBuf[1] = data1 & 0xFF; txBuf[2] = data2 & 0xFF; txBuf[3] = data3 & 0xFF; txBuf[4] = data4 & 0xFF; for (i = 5; i < MAXMSGSIZE; ++i) txBuf[i] = i; /* put known values in buf */ printf("sending %d times: ", times); PrintMessage(txBuf); for (i = 0; i < times; ++i) { txBuf[5] = i & 0xFF; /* Increment the byte after the last settable one */ res = ML_Transmit(txBuf); if (res < 0) { PrintFault("ML_Transmit", res); break; } } }
/****** SmartReadArgs/SmartReadArgs ****************************************** * NAME * SmartReadArgs -- Workbench/CLI transparent ReadArgs(). * SYNOPSIS * error = SmartReadArgs(wb_startup, smart_args); * * LONG SmartReadArgs(struct WBStartup *, struct SmartArgs *); * FUNCTION * This function is a CLI/Workbench transparent interface to ReadArgs(). * * In case of a Workbench start, it analyzes the WBStartup message and * possible tooltypes. These are converted to a text string that can be * passed to ReadArgs() like before. * * Tooltypes that are not part of the template are ignored. This includes * tooltypes being disabled with "(...)", NewIcons image data on systems * without NewIcons installed and all this лл Icon by some idiot ╗╗ crap. * * If the application was stared from CLI, it simply calls ReadArgs() * without the conversion step. * * If all went well you get a return value of zero. This means the passed * arguments fit the template and are ready to use. Otherwise you get a * IoErr()-like return code. * INPUTS * wb_startup - Workbench startup message. Refer to your compiler manual * to learn how to obtain it. If this is NULL, the program was * started from CLI. * smart_args - structure which holds all information used by * SmartReadArgs(). You have to setup the following fields before the * call: * * sa_Template - The template passed to ReadArgs() * sa_Parameter - ReadArgs() LONG WORD array to hold the arguments * sa_FileParameter - number of Argument in the template to use * for the files passed via WBStartup->sm_ArgList or -1, that * means you don't want any files * sa_Window - Window description string to open when the program * is started from the workbench. NULL means no window. If the * icon has a WINDOW tooltype, this value is ignored. * sa_RDArgs - RDArgs structure to use for ReadArgs() call. This * can be used to provide extended help. * sa_Buffer - Pointer to a buffer to use for the Workbench startup * or NULL, that means SmartReadArgs() allocates a buffer for you * sa_BufferSize - Size of the optional buffer. If it is smaller than * SA_MINIMUM_BUFFER_SIZE it will be adjusted. * * All other fields should be set to NULL. * RESULTS * Zero for success. You can check the sa_Flags field for the * SAF_WORKBENCH flag to learn how the program was started. * * Otherwise an IoErr()-like error code is returned. This can be passed * directly to PrintFault() or similar. * NOTES * Always call SmartFreeArgs(), even if SmartReadArgs() failed! See example * below. * * This function requires "dos.library", "icon.library" and * "utility.library" to be opened by the application. Normally this * already has been done by the compiler startup code. * * There is a not widely known feature of ReadArgs(): with templates like * "FROM/M/A,TO/A", you can select the files from workbench performing the * following steps: * * - Select the program * - Select the FROM files * - Select and double click the TO file * * This is available because ReadArgs() grabs the last string from a * multi-argument FROM and uses it as the TO parameter, if none is passed * explicitely. * BUGS * There are some known problems when used with GCC, mostly related to the * fact that I never bothered creating a useable developer environment * around it (and I'm not sure if this is even possible >:) ...): * * - Debugging output shows up in the console instead of SER:. Does * debug.lib exist for gcc? (Wasn't there this strange hunk2gcc * converter?) * - "Read from 0" Enforcer hit in SmartReadArgs(). Couldn't figure out * the exact location yet because of the asynchronous debugging output * mentioned above. * * For someone with a reasonable experience with GCC, it should be easy to * fix this. * * The SAS/c implementation does not have these problems. * SEE ALSO * SmartFreeArgs(), dos.library/ReadArgs(), icon.library/GetDiskObjectNew() * EXAMPLE * The main archiev comes with a "test.c" and a couple of icons to start * the corresponding executable "test". Take a look at the source code and * play with it. * * See below for a smaller code segment that expects the "dos.library", * "icon.library" and "utility.library" to be open already. * SOURCE */ int main(int argc, STRPTR argv[]) { struct SmartArgs smart_args = {NULL}; LONG argument[2]; LONG error; /* Obtain WBStartup; depends on your compiler environment */ struct WBStartup *wb_startup = NULL; #ifdef __GNUC__ wb_startup = _WBenchMsg; #else if (argc == 0) { wb_startup = (struct WBStartup *) argv; } #endif smart_args.sa_Template = "FILES/M/A,VERBOSE"; smart_args.sa_Parameter = argument; smart_args.sa_FileParameter = 0; smart_args.sa_Window = "CON:////My WB-Window/AUTO/CLOSE/WAIT"; error = SmartReadArgs(wb_startup, &smart_args); if (error == 0) { /* do something */ } else { PrintFault(error, "MyProgram"); } SmartFreeArgs(&smart_args); return ((error == 0) ? RETURN_OK : RETURN_FAIL); }
void RegHandlerCom(char *com, char *a1, char *a2, char *a3, char *a4, char *a5, char *a6) { ML_MsgHandler *handler; int type = 0x80; word res; if (a1[0]) sscanf(a1, "%x", &type); handler = (ML_MsgHandler *)Malloc(sizeof(ML_MsgHandler)); if (handler == 0) { printf("Malloc failed\n"); return; } printf("setting up handler (at 0x%x) for message type 0x%02x\n", (int)handler, type); handler->msgType = type & 0xFF; handler->func = HandlerFunc; /* Shared by all handlers */ handler->arg = &handlerArg; /* Shared (unsafely!) by all handlers */ res = ML_RegisterHandler(handler); if (res < 0) PrintFault("ML_RegisterHandler", res); }
void main(int argc, char *argv[]) { BYTE *p1=buffer1,*p2=buffer2,*tmp; ULONG signals; if(AHImp=CreateMsgPort()) { if(AHIio=(struct AHIRequest *)CreateIORequest(AHImp,sizeof(struct AHIRequest))) { AHIio->ahir_Version = 4; AHIDevice=OpenDevice(AHINAME,0,(struct IORequest *)AHIio,NULL); } } if(AHIDevice) { Printf("Unable to open %s/0 version 4\n",AHINAME); cleanup(RETURN_FAIL); } // Initialize the first read AHIio->ahir_Std.io_Command=CMD_READ; AHIio->ahir_Std.io_Data=&buffer1; AHIio->ahir_Std.io_Length=BUFFERSIZE; AHIio->ahir_Std.io_Offset=0; AHIio->ahir_Frequency=FREQUENCY; AHIio->ahir_Type=TYPE; if(!DoIO((struct IORequest *) AHIio)) { // The first buffer is now filled SetIoErr(NULL); for(;;) { ULONG length; length=AHIio->ahir_Std.io_Actual; // Initialize the second read (note that io_Offset is not cleared!) AHIio->ahir_Std.io_Data=p2; AHIio->ahir_Std.io_Length=BUFFERSIZE; AHIio->ahir_Frequency=FREQUENCY; AHIio->ahir_Type=TYPE; SendIO((struct IORequest *) AHIio); // While the second read is in progress, save the first buffer to stdout if(Write(Output(),p1,length) != length) { break; } signals=Wait(SIGBREAKF_CTRL_C | (1L << AHImp->mp_SigBit)); if(signals & SIGBREAKF_CTRL_C) { SetIoErr(ERROR_BREAK); break; } // Remove the reply if(WaitIO((struct IORequest *) AHIio)) { SetIoErr(ERROR_READ_PROTECTED); break; } // Swap buffer pointers and repeat tmp=p1; p1=p2; p2=tmp; } // Abort any pending iorequests AbortIO((struct IORequest *) AHIio); WaitIO((struct IORequest *) AHIio); } if(IoErr()) { PrintFault(IoErr(), argv[0] ); // Oh, common! It's not MY fault that this // routine prints to stdout instead of stderr! cleanup(RETURN_ERROR); } cleanup(RETURN_OK); }
int main (int argc, char ** argv) { struct MainLevel demo = { (BYTE)0x88, 0xFF, (WORD)0x8844, 0xFF77, (LONG)0x88442211, 0xFF773311, 1.5, 1.75, "Hallo", { (BYTE)0x88, (LONG)0x88442211 }, /* ... */ }; BYTE b = (BYTE)0x88; WORD w = (WORD)0x8844; LONG l = (LONG)0x88442211; FLOAT f = 1.5; DOUBLE d = 1.75; STRPTR s = "Hallo"; struct Level1 l1 = { (BYTE)0x88, (LONG)0x88442211 }; BPTR fh; struct MainLevel * readback; demo.ml_BytePtr = &b; demo.ml_WordPtr = &w; demo.ml_LongPtr = &l; demo.ml_FloatPtr = &f; demo.ml_DoublePtr = &d; demo.ml_StringPtr = &s; demo.ml_Level1Ptr = &l1; fh = Open ("writestruct.dat", MODE_NEWFILE); if (!fh) { PrintFault (IoErr(), "Can't open file\n"); return 10; } /* This writes the following data stream: 0000 88 ml_Byte 0001 ff ml_Ubyte 0002 88 44 ml_Word 0004 ff 77 ml_UWord 0006 88 44 22 11 ml_Long 000a ff 77 33 11 ml_ULong 000e 3f c0 00 00 ml_Float 0012 3f fc 00 00 00 00 00 00 ml_Double 001a 01:48 61 6c 6c 6f 00 ml_String 0021 88 ml_Level1.l1_Byte 0022 88 44 22 11 ml_Level1.l1_Long 0026 01:88 ml_BytePtr 0028 01:88 44 ml_WordPtr 002b 01:88 44 22 11 ml_LongPtr 0030 01:3f c0 00 00 ml_FloatPtr 0035 01:3f fc 00 00 00 00 00 00 ml_DoublePtr 003e 01:01:48 61 6c 6c 6f 00 ml_StringPtr - Note two 01 ! 0046 01:88 88 44 22 11 ml_Level1Ptr */ if (!WriteStruct (&dsh, &demo, fh, MainDesc)) { PrintFault (IoErr(), "Failed to write to file\n"); } if (!Close (fh)) { PrintFault (IoErr(), "Failed to close file\n"); } /* Read the structure back */ fh = Open ("writestruct.dat", MODE_OLDFILE); if (!fh) { PrintFault (IoErr(), "Can't open file for reading\n"); return 10; } if (!ReadStruct (&dsh, (APTR *)&readback, fh, MainDesc)) { PrintFault (IoErr(), "Failed to read from file\n"); } else { UBYTE * ptr; int t; ptr = (UBYTE *)readback; t = 0; kprintf ("readback = %p\n", readback); kprintf ("%02X (88) %02X (FF)\n" , (UBYTE)readback->ml_Byte , readback->ml_UByte ); kprintf ("%04X (8844) %04X (FF77)\n" , (UWORD)readback->ml_Word , readback->ml_UWord ); kprintf ("%08lX (88442211) %08lX (FF773311)\n" , readback->ml_Long , readback->ml_ULong ); kprintf ("%08lX (3FC00000) %08lX:%08lX (3FFC0000:00000000)\n" , *(ULONG *)&readback->ml_Float , ((ULONG *)&readback->ml_Double)[1] , ((ULONG *)&readback->ml_Double)[0] ); kprintf ("%s (Hallo)\n" , readback->ml_String ); kprintf ("{ %02X %08X } ({ 88 88442211 })\n" , (UBYTE)readback->ml_Level1.l1_Byte , readback->ml_Level1.l1_Long ); kprintf ("%02X (88)\n" , (UBYTE)*readback->ml_BytePtr ); kprintf ("%04X (8844)\n" , (UWORD)*readback->ml_WordPtr ); kprintf ("%08lX (88442211)\n" , *readback->ml_LongPtr ); kprintf ("%08lX (3FC00000) %08lX:%08lX (3FFC0000:00000000)\n" , *(ULONG *)readback->ml_FloatPtr , ((ULONG *)readback->ml_DoublePtr)[1] , ((ULONG *)readback->ml_DoublePtr)[0] ); kprintf ("%s (Hallo)\n" , *readback->ml_StringPtr ); kprintf ("{ %02X %08X } ({ 88 88442211 })\n" , (UBYTE)readback->ml_Level1Ptr->l1_Byte , readback->ml_Level1Ptr->l1_Long ); FreeStruct (readback, MainDesc); } if (!Close (fh)) { PrintFault (IoErr(), "Failed to close file after reading\n"); } return 0; } /* main */
int main (void) { IPTR args[ARG_NUM] = { (IPTR) NULL, (IPTR) NULL, (IPTR) NULL, FALSE, FALSE}; struct RDArgs *rda; ULONG error = 0; locale = OpenLocale(NULL); if (!locale) { PutStr("Could not open locale!\n"); return -1; } rda = ReadArgs(TEMPLATE, args, NULL); if (rda) { BPTR lock_in; lock_in = Lock((STRPTR)args[ARG_FROM], ACCESS_READ); if (lock_in) { BPTR file_out = Open((STRPTR)args[ARG_TO], MODE_NEWFILE); if (NULL != file_out) { struct FileInfoBlock fib; UBYTE * data = NULL; BOOL success = Examine(lock_in, &fib); /* ** Read the input file into memory */ if (fib.fib_Size && DOSTRUE == success) data = AllocVec(fib.fib_Size, MEMF_ANY); if (data) { ULONG read = Read(lock_in, data, fib.fib_Size); if (-1 != read) { struct sorted_data * sd; sd = sort(data, fib.fib_Size, (STRPTR)args[ARG_COLSTART], (BOOL)args[ARG_CASE], (BOOL)args[ARG_NUMERIC]); error = write_data(sd, file_out); } FreeVec(data); }/* if (data) */ Close(file_out); } /* if (file_out) */ UnLock(lock_in); } /* if (lock_in) */ FreeArgs(rda); } else error=RETURN_FAIL; if (error) PrintFault(IoErr(), "Sort"); return error; }
int main( void ) { struct RDArgs *rdargs; int rc = RETURN_OK; rdargs = ReadArgs( TEMPLATE , (LONG *) &args, NULL ); if( rdargs != NULL ) { /* Refresh database */ if( args.refresh && !args.remove ) { OpenAHI(); if( !AHI_LoadModeFile( "DEVS:AudioModes" ) && !args.quiet ) { PrintFault( IoErr(), "DEVS:AudioModes" ); rc = RETURN_ERROR; } } /* Load mode files */ if( args.files != NULL && !args.remove ) { int i = 0; OpenAHI(); while( args.files[i] ) { if( !AHI_LoadModeFile( args.files[i] ) && !args.quiet ) { PrintFault( IoErr(), args.files[i] ); rc = RETURN_ERROR; } i++; } } /* Remove database */ if( args.remove ) { if( args.files || args.refresh ) { PutStr( "The REMOVE switch cannot be used together with FILES or REFRESH.\n" ); rc = RETURN_FAIL; } else { ULONG id; OpenAHI(); for( id = AHI_NextAudioID( AHI_INVALID_ID ); id != AHI_INVALID_ID; id = AHI_NextAudioID( AHI_INVALID_ID ) ) { AHI_RemoveAudioMode( id ); } } } /* Make display mode doublescan (allowing > 28 kHz sample rates) */ if( args.dblscan ) { ULONG id; ULONG bestid = INVALID_ID; int minper = MAXINT; struct Screen *screen = NULL; static const struct ColorSpec colorspecs[] = { { 0, 0, 0, 0 }, { 1, 0, 0, 0 }, {-1, 0, 0, 0 } }; union { struct MonitorInfo mon; struct DisplayInfo dis; } buffer; for( id = NextDisplayInfo( INVALID_ID ); id != (ULONG) INVALID_ID; id = NextDisplayInfo( id ) ) { int period; if( GetDisplayInfoData( NULL, (UBYTE*) &buffer.dis, sizeof(buffer.dis), DTAG_DISP, id ) ) { if( !(buffer.dis.PropertyFlags & (DIPF_IS_ECS | DIPF_IS_AA ) ) ) { continue; } } if( GetDisplayInfoData( NULL, (UBYTE*) &buffer.mon, sizeof(buffer.mon), DTAG_MNTR, id ) ) { period = buffer.mon.TotalColorClocks * buffer.mon.TotalRows / ( 2 * ( buffer.mon.TotalRows - buffer.mon.MinRow + 1 ) ); if( period < minper ) { minper = period; bestid = id; } } } if( bestid != (ULONG) INVALID_ID && minper < 100 ) { screen = OpenScreenTags( NULL, SA_DisplayID, bestid, SA_Colors, (ULONG) &colorspecs, TAG_DONE ); } else if( ( GfxBase->ChipRevBits0 & (GFXF_HR_DENISE | GFXF_AA_LISA ) ) != 0 ) { /* No suitable screen mode found, let's bang the hardware... Using code from Sebastiano Vigna <*****@*****.**>. */ extern struct Custom custom; custom.bplcon0 = 0x8211; custom.ddfstrt = 0x0018; custom.ddfstop = 0x0058; custom.hbstrt = 0x0009; custom.hsstop = 0x0017; custom.hbstop = 0x0021; custom.htotal = 0x0071; custom.vbstrt = 0x0000; custom.vsstrt = 0x0003; custom.vsstop = 0x0005; custom.vbstop = 0x001D; custom.vtotal = 0x020E; custom.beamcon0 = 0x0B88; custom.bplcon1 = 0x0000; custom.bplcon2 = 0x027F; custom.bplcon3 = 0x00A3; custom.bplcon4 = 0x0011; } if( screen != NULL ) { CloseScreen( screen ); } } FreeArgs( rdargs ); } cleanup( rc ); }
/* * Read in file and generate executable tree */ void parse_file(ScriptArg *first) { ScriptArg *current; int count, i, j, ready; char **mclip; ready = FALSE; current = first; do { count = Read(inputfile, &buffer[0], 1); if (count == 0) { PrintFault(IoErr(), INSTALLER_NAME); show_parseerror("End of File", line); cleanup(); exit(-1); } if (!isspace(buffer[0])) { switch (buffer[0]) { case SEMICOLON: /* A comment, ok - Go on with next line */ do { count = Read(inputfile, &buffer[0], 1); } while (buffer[0] != LINEFEED && count != 0); line++; break; case LBRACK: /* Open bracket: recurse into next level */ current->cmd = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (current->cmd == NULL) { end_alloc(); } /* Set initial values */ current->cmd->parent = current; current->cmd->arg = NULL; current->cmd->cmd = NULL; current->cmd->next = NULL; current->cmd->intval = 0; current->cmd->ignore = 0; parse_file(current->cmd); current->next = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (current->next == NULL) { end_alloc(); } current->next->parent = current->parent; /* Set initial values */ current = current->next; current->arg = NULL; current->cmd = NULL; current->next = NULL; current->intval = 0; current->ignore = 0; break; case RBRACK: /* All args collected return to lower level */ /* We have allocated one ScriptArg too much */ current = current->parent->cmd; if (current->next != NULL) { while (current->next->next != NULL) { current = current->next; } FreeVec(current->next); current->next = NULL; } else { /* This is an empty bracket */ show_parseerror("There is an empty bracket.", line); cleanup(); exit(-1); } ready = TRUE; break; default: /* This is the real string */ i = 0; if (buffer[0] == DQUOTE || buffer[0] == SQUOTE) { int masquerade = FALSE; do { if (masquerade == TRUE) { switch (buffer[i]) { case 'n': /* NEWLINE */ buffer[i-1] = 0x0a; break; case 'r': /* RETURN */ buffer[i-1] = 0x0d; break; case 't': /* TAB */ buffer[i-1] = 0x09; break; case SQUOTE: /* SQUOTE */ buffer[i-1] = SQUOTE; break; case DQUOTE: /* DQUOTE */ buffer[i-1] = DQUOTE; break; case BACKSLASH: /* BACKSLASH */ buffer[i-1] = BACKSLASH; break; #warning TODO: convert missing '\\' masqueraded symbols case 'h': /* H.TAB */ case 'v': /* V.TAB */ case 'b': /* BACKSPACE */ case 'f': /* FORMFEED */ case 'x': /* HEX number */ case 'o': /* \\ooo OCTAL number ('o' is just to remember) */ default: i++; break; } masquerade = FALSE; } else { if (buffer[i] == BACKSLASH) masquerade = TRUE; i++; } if (i == MAXARGSIZE) { show_parseerror("Argument length overflow!" ,line); cleanup(); exit(-1); } count = Read(inputfile, &buffer[i], 1); } while (masquerade || (buffer[i] != buffer[0] && count != 0)); current->arg = AllocVec(sizeof(char)*(i+2), MEMF_PUBLIC); if (current->arg == NULL) { end_alloc(); } buffer[i+1] = 0; strncpy (current->arg, buffer, i+2); } else { do { i++; count = Read(inputfile, &buffer[i], 1); } while (!isspace(buffer[i]) && buffer[i]!=LBRACK && buffer[i]!=RBRACK && buffer[i]!=SEMICOLON && count != 0 && i < MAXARGSIZE); if (buffer[i] == LINEFEED) { line++; } if (i == MAXARGSIZE) { show_parseerror("Argument length overflow!", line); cleanup(); exit(-1); } if (buffer[i] == SEMICOLON) { do { count = Read(inputfile, &buffer[i], 1); } while (buffer[i] != LINEFEED && count != 0); line++; } if (buffer[i] == LBRACK || buffer[i] == RBRACK) { Seek(inputfile, -1 , OFFSET_CURRENT); } buffer[i] = 0; switch (buffer[0]) { case DOLLAR: /* HEX number */ current->intval = strtol(&buffer[1], NULL, 16); break; case PERCENT: /* binary number */ current->intval = strtol(&buffer[1], NULL, 2); break; default: /* number or variable */ if (isdigit(buffer[0]) || ((buffer[0] == PLUS || buffer[0] == MINUS) && isdigit(buffer[1]))) { current->intval = atol(buffer); } else { current->arg = AllocVec(sizeof(char)*(i+1), MEMF_PUBLIC); if (current->arg == NULL) { end_alloc(); } strncpy(current->arg, buffer, i+1); } if (current == current->parent->cmd && strcasecmp(buffer, "procedure") == 0) { ScriptArg *proc, *uproc; int finish; /* Save procedure in ProcedureList */ proc = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (proc == NULL) { end_alloc(); } uproc = proc; proc->parent = NULL; proc->next = NULL; proc->arg = NULL; proc->intval = 0; proc->ignore = 0; proc->cmd = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (proc->cmd == NULL) { end_alloc(); } proc->cmd->parent = proc; proc->cmd->next = NULL; proc->cmd->arg = NULL; proc->cmd->intval = 0; proc->cmd->ignore = 0; proc = proc->cmd; proc->cmd = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (proc->cmd == NULL) { end_alloc(); } proc->cmd->parent = proc; proc->cmd->next = NULL; proc->cmd->arg = NULL; proc->cmd->intval = 0; proc->cmd->ignore = 0; proc->cmd->cmd = NULL; /* parse procedure name and args */ mclip = NULL; j = 0; finish = FALSE; do { /* goto next argument */ do { count = Read(inputfile, &buffer[0], 1); if (buffer[0] == LINEFEED) { line++; } if (buffer[0] == RBRACK) { if (j > 0) { show_parseerror("Procedure has no body!", line); } else { show_parseerror("Procedure has no name!", line); } cleanup(); exit(-1); } if (buffer[0] == SQUOTE || buffer[0] == DQUOTE) { show_parseerror("Procedure has a quoted argument!", line); cleanup(); exit(-1); } if (buffer[0] == SEMICOLON && count != 0) { do { count = Read(inputfile, &buffer[0], 1); } while (buffer[0] != LINEFEED && count != 0); line++; } } while (isspace(buffer[0]) && count != 0); if (buffer[0] != LBRACK) { i = 0; /* read in string */ do { i++; count = Read(inputfile, &buffer[i], 1); } while (!isspace(buffer[i]) && buffer[i]!=LBRACK && buffer[i]!=RBRACK && buffer[i]!=SEMICOLON && count != 0 && i < MAXARGSIZE); if (i == MAXARGSIZE) { show_parseerror("Argument length overflow!", line); cleanup(); exit(-1); } if (buffer[i] == LINEFEED) { line++; } if (buffer[i] == LBRACK || buffer[i] == RBRACK || buffer[i] == SEMICOLON) { Seek(inputfile, -1 , OFFSET_CURRENT); } buffer[i] = 0; j++; mclip = ReAllocVec(mclip, sizeof(char *) * j, MEMF_PUBLIC); if (mclip == NULL) { end_alloc(); } mclip[j-1] = StrDup(buffer); if (mclip[j-1] == NULL) { end_alloc(); } } else { /* Exit if procedure has no name or name is string/digit or bracket follows */ if (j == 0) { show_parseerror("Argument to procedure is a command!\n", line); cleanup(); exit(-1); } /* Next string is body-command */ finish = TRUE; } } while (!finish); /* Procedure body */ parse_file(proc->cmd); finish = FALSE; do { do { count = Read(inputfile, &buffer[0], 1); if (buffer[0] == LINEFEED) { line++; } } while (isspace(buffer[0]) && count != 0); if (buffer[0] == SEMICOLON) { do { count = Read(inputfile, &buffer[0], 1); } while (buffer[0] != LINEFEED && count != 0); line++; } else if (buffer[0] == LBRACK) { proc->next = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (proc->next == NULL) { end_alloc(); } proc->next->parent = proc->parent; proc->next->next = NULL; proc->next->arg = NULL; proc->next->intval = 0; proc->next->ignore = 0; proc = proc->next; proc->cmd = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (proc->cmd == NULL) { end_alloc(); } proc->cmd->parent = proc; proc->cmd->next = NULL; proc->cmd->arg = NULL; proc->cmd->intval = 0; proc->cmd->ignore = 0; proc->cmd->cmd = NULL; parse_file(proc->cmd); } else if (buffer[0] == RBRACK) { finish = TRUE; } else { show_parseerror("Procedure has rubbish in its body!", line); cleanup(); exit(-1); } } while (!finish); current->next = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (current->next == NULL) { end_alloc(); } current->next->parent = current->parent; current = current->next; current->arg = mclip[0]; current->cmd = NULL; current->next = NULL; current->intval = set_procedure(mclip, j, uproc); current->ignore = 0; #ifdef DEBUG printf("\n\n"); printcode(uproc, 0); #endif /* DEBUG */ buffer[0] = 0; ready = TRUE; } if (current->arg == current->parent->cmd->arg && strcasecmp(buffer, "welcome") == 0) { preferences.welcome = TRUE; } break; } } current->next = AllocVec(sizeof(ScriptArg), MEMF_PUBLIC); if (current->next == NULL) { end_alloc(); } current->next->parent = current->parent; current = current->next; /* Set initial values */ current->arg = NULL; current->cmd = NULL; current->next = NULL; current->intval = 0; current->ignore = 0; break; } } else { if (buffer[0] == LINEFEED) { line++; } } if (count == 0) { PrintFault(IoErr(), INSTALLER_NAME); show_parseerror("End of File", line); cleanup(); exit(-1); } } while (!ready); }
int main(int argc, char **argv) { ULONG ret = RETURN_FAIL; OOP_AttrBase HiddGCAttrBase; OOP_AttrBase HiddGfxAttrBase; OOP_AttrBase HiddBitMapAttrBase; OOP_Object *gfxHidd; OOP_Object *bitMap; OOP_Object *gc; STRPTR hiddName = "graphics.hidd"; ULONG width = 320; ULONG height = 200; ULONG depth = 8; ULONG format = vHidd_BitMap_Format_Planar; WORD x; char wait; struct Args { STRPTR hiddName; IPTR *width; IPTR *height; IPTR *depth; IPTR *chunky; ULONG displayable; }; struct Args args = {hiddName, &width, &height, &depth, 0, 0}; struct RDArgs *rda; if(ght_OpenLibs(LibsArray)) { rda = ReadArgs("HIDD/K,WIDTH/N/K,HEIGHT/N/K,DEPTH/N/K,CHUNKY/S,DISPLAYABLE=DP/S", (IPTR *)&args, NULL); if (rda != NULL) { if(args.chunky != 0) format = vHidd_BitMap_Format_Chunky; if(args.displayable != 0) args.displayable = (ULONG) TRUE; HIDDGraphicsBase = OpenLibrary(args.hiddName, 0); if(HIDDGraphicsBase) { ret = RETURN_ERROR; HiddGfxAttrBase = OOP_ObtainAttrBase(IID_Hidd_Gfx); HiddBitMapAttrBase = OOP_ObtainAttrBase(IID_Hidd_BitMap); HiddGCAttrBase = OOP_ObtainAttrBase(IID_Hidd_GC); if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase) { gfxHidd = OOP_NewObject(NULL, args.hiddName, NULL); if(gfxHidd) { struct TagItem bm_tags[] = { {aHidd_BitMap_Width, (IPTR) *args.width}, {aHidd_BitMap_Height, (IPTR) *args.height}, {aHidd_BitMap_Depth, (IPTR) *args.depth}, {aHidd_BitMap_Format, (IPTR) format}, {aHidd_BitMap_Displayable, (IPTR) args.displayable}, {TAG_DONE, 0UL} }; bitMap = HIDD_Gfx_NewBitMap(gfxHidd, bm_tags); if(bitMap) { struct TagItem gc_tags[] = { {aHidd_GC_BitMap, (IPTR) bitMap}, {TAG_DONE, 0UL} }; gc = HIDD_Gfx_NewGC(gfxHidd, gc_tags); if(gc) { OOP_SetAttrsTags(gc, aHidd_GC_Foreground, 15, TAG_END); for(x = 10; x < 30; x++) { OOP_SetAttrsTags(gc, aHidd_GC_ColorMask, ~0, TAG_END); HIDD_BM_DrawPixel(gc, x, 10); OOP_SetAttrsTags(gc, aHidd_GC_ColorMask, ~0 - 7, TAG_END); HIDD_BM_DrawPixel(gc, x, 12); OOP_SetAttrsTags(gc, aHidd_GC_ColorMask, 0, TAG_END); HIDD_BM_DrawPixel(gc, x, 14); } printf("Press enter to continue"); scanf("%c", &wait); HIDD_Gfx_DisposeGC(gfxHidd, gc); ret = RETURN_OK; } HIDD_Gfx_DisposeBitMap(gfxHidd, bitMap); } if(gfxHidd) OOP_DisposeObject(gfxHidd); } } /* if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase) */ if(HiddGfxAttrBase) OOP_ReleaseAttrBase(IID_Hidd_Gfx); if(HiddBitMapAttrBase) OOP_ReleaseAttrBase(IID_Hidd_BitMap); if(HiddGCAttrBase) OOP_ReleaseAttrBase(IID_Hidd_GC); CloseLibrary(HIDDGraphicsBase); } /* if(HIDDGraphicsBase) */ FreeArgs(rda); } else { PrintFault(IoErr(), ""); } /* if (rda != NULL) */ } /* if OpenLibs() */ ght_CloseLibs(LibsArray); return(ret); }
int main(void) { IPTR args[NOOFARGS] = { (IPTR)FALSE, (IPTR)FALSE, (IPTR)FALSE, (IPTR)FALSE, (IPTR)FALSE }; struct RDArgs *rda; LONG error = 0; BOOL bPrintErr = TRUE; rda = ReadArgs(ARG_TEMPLATE, args, NULL); if (rda != NULL) { UWORD typeCount = 0; BOOL aChip = (BOOL)args[ARG_CHIP]; BOOL aFast = (BOOL)args[ARG_FAST]; BOOL aTotal = (BOOL)args[ARG_TOTAL]; BOOL aFlush = (BOOL)args[ARG_FLUSH]; aHuman = (BOOL)args[ARG_HUMAN]; if (aChip) { typeCount++; } if (aFast) { typeCount++; } if (aTotal) { typeCount++; } ULONG chip[4], fast[4], total[4]; if (typeCount > 1) { FPuts(Output(), "Only one of CHIP, FAST or TOTAL allowed\n"); bPrintErr = FALSE; FreeArgs(rda); return RETURN_FAIL; } else { if (aFlush) { APTR Mem; Mem = AllocMem(0x7ffffff0, MEMF_PUBLIC); if (Mem) FreeMem(Mem, 0x7ffffff0); } if(aChip) { chip[0] = AvailMem(MEMF_CHIP); if (printm(NULL, chip, 1) < 0) { error = RETURN_ERROR; } } else if(aFast) { fast[0] = AvailMem(MEMF_FAST); if (printm(NULL, fast, 1) < 0) { error = RETURN_ERROR; } } else if (aTotal) { total[0] = AvailMem(MEMF_ANY); if (printm(NULL, total, 1) < 0) { error = RETURN_ERROR; } } else { Forbid(); chip[0] = AvailMem(MEMF_CHIP); chip[2] = AvailMem(MEMF_CHIP | MEMF_TOTAL); chip[3] = AvailMem(MEMF_CHIP | MEMF_LARGEST); chip[1] = chip[2] - chip[0]; fast[0] = AvailMem(MEMF_FAST); fast[2] = AvailMem(MEMF_FAST | MEMF_TOTAL); fast[3] = AvailMem(MEMF_FAST | MEMF_LARGEST); fast[1] = fast[2] - fast[0]; total[0] = AvailMem(MEMF_ANY); total[2] = AvailMem(MEMF_ANY | MEMF_TOTAL); total[3] = AvailMem(MEMF_ANY | MEMF_LARGEST); total[1] = total[2] - total[0]; Permit(); if (PutStr("Type Available In-Use Maximum Largest\n") < 0 || printm("chip", chip, 4) < 0 || printm("fast", fast, 4) < 0 || printm("total", total, 4) < 0) { error = RETURN_ERROR; } } } FreeArgs(rda); } else { error = RETURN_FAIL; } if(error != RETURN_OK && bPrintErr) { PrintFault(IoErr(), "Avail"); } return error; }
int main(int argc, char *argv[]) { BYTE *p1=buffer1,*p2=buffer2; void *tmp; ULONG signals,length; struct AHIRequest *link = NULL; LONG priority = 0; BYTE pri; if(argc == 2) { StrToLong(argv[1], &priority); } pri = priority; Printf("Sound priority: %ld\n", pri); if((AHImp=CreateMsgPort()) != NULL) { if((AHIio=(struct AHIRequest *)CreateIORequest(AHImp,sizeof(struct AHIRequest))) != NULL) { AHIio->ahir_Version = 4; AHIDevice=OpenDevice(AHINAME,0,(struct IORequest *)AHIio,0); } } if(AHIDevice) { Printf("Unable to open %s/0 version 4\n",AHINAME); cleanup(RETURN_FAIL); } // Make a copy of the request (for double buffering) AHIiocopy = AllocMem(sizeof(struct AHIRequest), MEMF_ANY); if(! AHIiocopy) { cleanup(RETURN_FAIL); } CopyMem(AHIio, AHIiocopy, sizeof(struct AHIRequest)); AHIios[0]=AHIio; AHIios[1]=AHIiocopy; SetIoErr(0); for(;;) { // Fill buffer length = Read(Input(),p1,BUFFERSIZE); // Play buffer AHIios[0]->ahir_Std.io_Message.mn_Node.ln_Pri = pri; AHIios[0]->ahir_Std.io_Command = CMD_WRITE; AHIios[0]->ahir_Std.io_Data = p1; AHIios[0]->ahir_Std.io_Length = length; AHIios[0]->ahir_Std.io_Offset = 0; AHIios[0]->ahir_Frequency = FREQUENCY; AHIios[0]->ahir_Type = TYPE; AHIios[0]->ahir_Volume = 0x10000; // Full volume AHIios[0]->ahir_Position = 0x8000; // Centered AHIios[0]->ahir_Link = link; SendIO((struct IORequest *) AHIios[0]); if(link) { // Wait until the last buffer is finished (== the new buffer is started) signals=Wait(SIGBREAKF_CTRL_C | (1L << AHImp->mp_SigBit)); // Check for Ctrl-C and abort if pressed if(signals & SIGBREAKF_CTRL_C) { SetIoErr(ERROR_BREAK); break; } // Remove the reply and abort on error if(WaitIO((struct IORequest *) link)) { SetIoErr(ERROR_WRITE_PROTECTED); break; } } // Check for end-of-sound, and wait until it is finished before aborting if(length != BUFFERSIZE) { WaitIO((struct IORequest *) AHIios[0]); break; } link = AHIios[0]; // Swap buffer and request pointers, and restart tmp = p1; p1 = p2; p2 = tmp; tmp = AHIios[0]; AHIios[0] = AHIios[1]; AHIios[1] = tmp; } // Abort any pending iorequests AbortIO((struct IORequest *) AHIios[0]); WaitIO((struct IORequest *) AHIios[0]); if(link) { // Only if the second request was started AbortIO((struct IORequest *) AHIios[1]); WaitIO((struct IORequest *) AHIios[1]); } if(IoErr()) { PrintFault(IoErr(), argv[0] ); cleanup(RETURN_ERROR); } cleanup(RETURN_OK); return RETURN_OK; // Make compiler happy }
int main( VOID ) { LONG arg[5] = {0}; struct RDArgs *args = NULL; int rc = 10; if((G = (struct GlobalData*)AllocMem(sizeof(struct GlobalData),MEMF_PUBLIC|MEMF_CLEAR))) { /* Initialize 'GlobalData' */ G->WbStartup = ((_WBenchMsg != NULL) ? TRUE : FALSE); if((IntuitionBase = OpenLibrary("intuition.library", 0))) { if((DOSBase = OpenLibrary("dos.library", 0))) { args = ReadArgs( TEMPLATE, (long*)arg, NULL); if(!args) { if((rc = _7zUI ( )) != 0 ) { /* failed creating MUI App */ if( G->WbStartup ) DisplayBeep(NULL); PrintFault(IoErr(),0L); } } else { int mode = 1; BPTR WhereToExtract = 0, OldCurrentdir = 0; G->CliUsage = TRUE; if( TOFOLDER ) { MakeDir( TOFOLDER ); mode=SwitchCurrentdir(TOFOLDER, &WhereToExtract, &OldCurrentdir ); } if( mode ) { mode = LIST_ARG ? 1 : TEST_ARG ? 2:3; rc = _7zArchive( ARCHIVE_ARG, mode ); if( TOFOLDER ) SwitchCurrentdir(NULL, &WhereToExtract, &OldCurrentdir); } FreeArgs( args ); } CloseLibrary( DOSBase ); } CloseLibrary( IntuitionBase ); } FreeMem( G, sizeof(struct GlobalData)); } return rc; }
int main(void) { struct DateTime curr; char day[LEN_DATSTRING]; char time[LEN_DATSTRING]; char date[LEN_DATSTRING]; struct DateStamp stamp; curr.dat_Format = FORMAT_DOS; curr.dat_Flags = 0; curr.dat_StrDay = day; curr.dat_StrDate = date; curr.dat_StrTime = time; DateStamp(&curr.dat_Stamp); DateToStr(&curr); Printf("Current time: %s, %s, %s\n", day, date, time); BPTR fh = Open("__TEST__", MODE_NEWFILE); if (fh != BNULL) { struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL); if (fib != NULL) { if (ExamineFH(fh, fib)) { curr.dat_Stamp = fib->fib_Date; DateToStr(&curr); Printf("File modification time: %s, %s, %s\n", day, date, time); } else PrintFault(IoErr(), "Examine failed"); Printf("Waiting 5 seconds\n"); Delay(5*50); DateStamp(&stamp); Printf("Calling SetFileDate\n"); if(SetFileDate("__TEST__", &stamp)) { if (ExamineFH(fh, fib)) { curr.dat_Stamp = fib->fib_Date; DateToStr(&curr); Printf("New file modification time: %s, %s, %s\n", day, date, time); } else PrintFault(IoErr(), "Examine failed"); } else PrintFault(IoErr(), "SetFileDate"); FreeDosObject(DOS_FIB, fib); } else PrintFault(IoErr(), "Couldn't alloc FileInfoBlock"); Close(fh); DeleteFile("__TEST__"); } else PrintFault(IoErr(), "Couldn't create file"); return 0; }
int main(int argc, char **argv) { ULONG ret = RETURN_FAIL; OOP_AttrBase HiddGfxAttrBase = 0; OOP_AttrBase HiddGCAttrBase = 0; OOP_AttrBase HiddBitMapAttrBase = 0; OOP_Object *gfxHidd; OOP_Object *bitMap; OOP_Object *gc; STRPTR hiddName = "graphics.hidd"; ULONG fg = 1; ULONG bg = 2; /* ReadArgs() declarations */ /* each entry must have a size of 4 bytes */ struct Args { STRPTR hiddName; IPTR *fg; IPTR *bg; }; struct Args args = {hiddName, &fg, &bg}; struct RDArgs *rda; if(ght_OpenLibs(LibsArray)) { rda = ReadArgs("HIDD/K,FG/N/K,BG/N/K", (IPTR *)&args, NULL); if (rda != NULL) { HIDDGraphicsBase = OpenLibrary(args.hiddName, 0); if(HIDDGraphicsBase) { ret = RETURN_ERROR; HiddGfxAttrBase = OOP_ObtainAttrBase(IID_Hidd_Gfx); HiddBitMapAttrBase = OOP_ObtainAttrBase(IID_Hidd_BitMap); HiddGCAttrBase = OOP_ObtainAttrBase(IID_Hidd_GC); if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase) { gfxHidd = OOP_NewObject(NULL, args.hiddName, NULL); if(gfxHidd) { bitMap = HIDD_Gfx_NewBitMap(gfxHidd, NULL); if(bitMap) { struct TagItem gc_tags[] = { {aHidd_GC_BitMap, (IPTR) bitMap}, {aHidd_GC_Foreground, (IPTR) *args.fg}, {aHidd_GC_Background, (IPTR) *args.bg}, {TAG_DONE, 0UL} }; gc = HIDD_Gfx_NewGC(gfxHidd, gc_tags); if(gc) { printf("GC created:\n"); printf(" fg : %li\n", ght_GetAttr(gc, aHidd_GC_Foreground)); printf(" bg : %li\n", ght_GetAttr(gc, aHidd_GC_Background)); printf(" drMode: %li\n", ght_GetAttr(gc, aHidd_GC_DrawMode)); printf(" bitMap: %li\n", ght_GetAttr(gc, aHidd_GC_BitMap)); HIDD_Gfx_DisposeGC(gfxHidd, gc); ret = RETURN_OK; } HIDD_Gfx_DisposeBitMap(gfxHidd, bitMap); } if(gfxHidd) OOP_DisposeObject(gfxHidd); } /* if(gfxHidd) */ } /* if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase) */ if(HiddGCAttrBase) OOP_ReleaseAttrBase(IID_Hidd_GC); if(HiddBitMapAttrBase) OOP_ReleaseAttrBase(IID_Hidd_BitMap); if(HiddGfxAttrBase) OOP_ReleaseAttrBase(IID_Hidd_Gfx); CloseLibrary(HIDDGraphicsBase); } /* if(HIDDGraphicsBase) */ FreeArgs(rda); } else { PrintFault(IoErr(), ""); } /* if (rda != NULL) */ } /* if OpenLibs() */ ght_CloseLibs(LibsArray); return(ret); }
int main ( int argc, char *argv[] ) { struct RDArgs *rda = NULL; ULONG sigs; globalEvents = -1; globalCurrentTool = LUNA_TOOL_BRUSH; // Init brush brushTool.antialias = TRUE; // TODO: load from config set toolbox cycle! brushTool.width = 1; brushTool.height = 1; brushTool.feather = TRUE; // TODO: load from config and set toolbox cycle! // Set the colors prevColor = 0; currColor = 0; globalColor = 0; BOOL keyIsDown = FALSE; keyboardEnabled = TRUE; // Starts up the application #ifdef __amigaos4__ MUIMasterBase = OpenLibrary("muimaster.library", 0); if (!MUIMasterBase) { printf("Error opening muimaster library\n"); exit(0); }; IMUIMaster = (struct MUIMasterIFace *) GetInterface(MUIMasterBase, "main", 1, NULL); if (!MUIMasterBase && !IMUIMaster) { printf("Error opening muimaster library\n"); exit(0); }; CyberGfxBase = OpenLibrary("cybergraphics.library", 0); if (!CyberGfxBase) { printf("Error opening cybergraphics library\n"); exit(0); }; ICyberGfx = (struct CyberGfxIFace *) GetInterface(CyberGfxBase, "main", 1, NULL); if (!CyberGfxBase && !ICyberGfx) { printf("Error opening muimaster library\n"); exit(0); }; #endif struct MsgPort *port; Forbid(); port = FindPort("LUNAPAINT"); Permit(); if ( port == NULL) { Locale_Initialize(); Init_Application ( ); } else { // Double Start // TODO: open projects when clicking on icons from there goto quit; } if (argc) { IPTR args[ ARG_CNT ] = {0}; rda = ReadArgs ( ARG_TEMPLATE, args, NULL ); if ( ! rda ) { PrintFault( IoErr ( ), argv[0] ); goto exit; } if ( args[ARG_FILE] ) { STRPTR *file = (STRPTR *)args[ARG_FILE]; while ( *file ) { LoadProject ( *file, FALSE ); file++; } } } // Main loop while ( getSignals ( &sigs ) ) { // Check for signals from GUI if ( checkSignalBreak ( &sigs ) ) break; if ( keyboardEnabled ) { // Execute keyboard events on key press if ( evalRawKey >= IECODE_ASCII_FIRST && evalRawKey < IECODE_ASCII_LAST ) { if ( !keyIsDown ) { keyIsDown = TRUE; checkKeyboardShortcuts ( evalRawKey ); } } } // We always register keyup strokes if ( evalRawKey & IECODE_UP_PREFIX ) keyIsDown = FALSE; // Execute pending events if ( globalActiveWindow && globalActiveCanvas ) doEvents ( ); // Reset events globalEvents = -1; // Mouse clicks if ( mouseClickCount > 0 ) mouseClickCount--; // Delayed canvas redraw if ( redrawTimes == 1 ) { if ( globalActiveWindow ) DoMethod ( globalActiveWindow->area, MUIM_Draw ); redrawTimes--; } if ( redrawTimes > 0 ) redrawTimes--; } // Exists the application and cleans up reserved resources exit: Exit_Application ( ); Locale_Deinitialize(); #ifdef __amigaos4__ if(MUIMasterBase && IMUIMaster) DropInterface((struct Interface *)IMUIMaster); if (MUIMasterBase) CloseLibrary(MUIMasterBase); if(CyberGfxBase && ICyberGfx) DropInterface((struct Interface *)ICyberGfx); if(CyberGfxBase) CloseLibrary(CyberGfxBase); #endif if (rda) FreeArgs(rda); quit: return 0; }
int main(void) { struct AnchorPath aPath; struct RDArgs *rda; IPTR args[5] = { NULL, NULL, NULL, NULL, FALSE }; struct DateTime dt; LONG error = 0; BPTR oldCurDir; LONG retval = RETURN_OK; BOOL timeError = FALSE; /* Error in time/date specification? */ rda = ReadArgs("FILE/A,WEEKDAY,DATE,TIME,ALL/S", args, NULL); if(rda == NULL) { PrintFault(IoErr(), "SetDate"); return RETURN_FAIL; } /* Use the current time as default (if no DATE, TIME or WEEKDAY is defined) */ DateStamp(&dt.dat_Stamp); dt.dat_Flags = DTF_FUTURE; dt.dat_Format = FORMAT_DOS; dt.dat_StrDate = (TEXT *)args[ARG_DATE]; dt.dat_StrTime = (TEXT *)args[ARG_TIME]; /* Change the defaults according to the user's specifications */ if(StrToDate(&dt)) { dt.dat_StrDate = (TEXT *)args[ARG_WEEKDAY]; if(!StrToDate(&dt)) timeError = TRUE; } else timeError = TRUE; if(timeError) { PutStr("SetDate: Illegal DATE or TIME string\n"); return RETURN_FAIL; } aPath.ap_Flags = (BOOL)args[ARG_ALL] ? APF_DOWILD : 0; aPath.ap_BreakBits = SIGBREAKF_CTRL_C; aPath.ap_Strlen = 0; /* Save the current dir */ oldCurDir = CurrentDir(NULL); CurrentDir(oldCurDir); error = MatchFirst((STRPTR)args[ARG_FILE], &aPath); while(error == 0) { CurrentDir(aPath.ap_Current->an_Lock); // VPrintf("%s", (IPTR *)&aPath.ap_Info.fib_FileName); SetFileDate(aPath.ap_Info.fib_FileName, &dt.dat_Stamp); error = MatchNext(&aPath); } MatchEnd(&aPath); /* Restore the current dir */ CurrentDir(oldCurDir); FreeArgs(rda); if(error != ERROR_NO_MORE_ENTRIES) { if(error == ERROR_BREAK) retval = RETURN_WARN; else retval = RETURN_FAIL; PrintFault(IoErr(), "SetDate"); } return retval; }
int main( void ) { struct RDArgs *rdargs; int rc = RETURN_OK; GfxBase = (struct GfxBase *) OpenLibrary( GRAPHICSNAME, 37 ); IntuitionBase = (struct IntuitionBase *) OpenLibrary( "intuition.library", 37 ); if( GfxBase == NULL ) { Printf( "Unable to open %s version %ld\n", (ULONG) GRAPHICSNAME, 37 ); cleanup(); return RETURN_FAIL; } if( IntuitionBase == NULL ) { Printf( "Unable to open %s version %ld\n", (ULONG) "intuition.library", 37 ); cleanup(); return RETURN_FAIL; } rdargs = ReadArgs( TEMPLATE , (LONG *) &args, NULL ); if( rdargs != NULL ) { /* Refresh database */ if( args.refresh && !args.remove ) { ULONG id; OpenAHI(); /* First, empty the database */ for( id = AHI_NextAudioID( AHI_INVALID_ID ); id != (ULONG) AHI_INVALID_ID; id = AHI_NextAudioID( AHI_INVALID_ID ) ) { AHI_RemoveAudioMode( id ); } /* Now add all modes */ if( !AHI_LoadModeFile( "DEVS:AudioModes" ) ) { if( IS_MORPHOS ) { ULONG res; /* Be quiet here. - Piru */ APTR *windowptr = &((struct Process *) FindTask(NULL))->pr_WindowPtr; APTR oldwindowptr = *windowptr; *windowptr = (APTR) -1; res = AHI_LoadModeFile( "MOSSYS:DEVS/AudioModes" ); *windowptr = oldwindowptr; if( !res ) { if( !args.quiet ) { PrintFault( IoErr(), "AudioModes" ); } rc = RETURN_ERROR; } } else { if ( !args.quiet ) { PrintFault( IoErr(), "DEVS:AudioModes" ); } rc = RETURN_ERROR; } } } /* Load mode files */ if( args.files != NULL && !args.remove ) { int i = 0; OpenAHI(); while( args.files[i] ) { if( !AHI_LoadModeFile( args.files[i] ) && !args.quiet ) { PrintFault( IoErr(), args.files[i] ); rc = RETURN_ERROR; } i++; } } /* Remove database */ if( args.remove ) { if( args.files || args.refresh ) { PutStr( "The REMOVE switch cannot be used together with FILES or REFRESH.\n" ); rc = RETURN_FAIL; } else { ULONG id; OpenAHI(); for( id = AHI_NextAudioID( AHI_INVALID_ID ); id != (ULONG) AHI_INVALID_ID; id = AHI_NextAudioID( AHI_INVALID_ID ) ) { AHI_RemoveAudioMode( id ); } } } /* Make display mode doublescan (allowing > 28 kHz sample rates) */ if( args.dblscan ) { ULONG id; ULONG bestid = INVALID_ID; int minper = INT_MAX; struct Screen *screen = NULL; static const struct ColorSpec colorspecs[] = { { 0, 0, 0, 0 }, { 1, 0, 0, 0 }, {-1, 0, 0, 0 } }; union { struct MonitorInfo mon; struct DisplayInfo dis; } buffer; for( id = NextDisplayInfo( INVALID_ID ); id != (ULONG) INVALID_ID; id = NextDisplayInfo( id ) ) { int period; if( GetDisplayInfoData( NULL, (UBYTE*) &buffer.dis, sizeof(buffer.dis), DTAG_DISP, id ) ) { if( !(buffer.dis.PropertyFlags & (DIPF_IS_ECS | DIPF_IS_AA ) ) ) { continue; } } if( GetDisplayInfoData( NULL, (UBYTE*) &buffer.mon, sizeof(buffer.mon), DTAG_MNTR, id ) ) { period = buffer.mon.TotalColorClocks * buffer.mon.TotalRows / ( 2 * ( buffer.mon.TotalRows - buffer.mon.MinRow + 1 ) ); if( period < minper ) { minper = period; bestid = id; } } } if( bestid != (ULONG) INVALID_ID && minper < 100 ) { screen = OpenScreenTags( NULL, SA_DisplayID, bestid, SA_Colors, (ULONG) &colorspecs, TAG_DONE ); } else if( ( GfxBase->ChipRevBits0 & (GFXF_HR_DENISE | GFXF_AA_LISA ) ) != 0 ) { /* No suitable screen mode found, let's bang the hardware... Using code from Sebastiano Vigna <*****@*****.**>. */ struct Custom *custom = (struct Custom *) 0xdff000; custom->bplcon0 = 0x8211; custom->ddfstrt = 0x0018; custom->ddfstop = 0x0058; custom->hbstrt = 0x0009; custom->hsstop = 0x0017; custom->hbstop = 0x0021; custom->htotal = 0x0071; custom->vbstrt = 0x0000; custom->vsstrt = 0x0003; custom->vsstop = 0x0005; custom->vbstop = 0x001D; custom->vtotal = 0x020E; custom->beamcon0 = 0x0B88; custom->bplcon1 = 0x0000; custom->bplcon2 = 0x027F; custom->bplcon3 = 0x00A3; custom->bplcon4 = 0x0011; } if( screen != NULL ) { CloseScreen( screen ); } } FreeArgs( rdargs ); } cleanup(); return rc; }