int main(int argc, char *argv[]) {
int i, len;
char buf[1000];
FILE *f;
struct stack s;
char *tmp;
initStack(&s);
if (argc == 2) {
f =fopen(argv[1], "r"); //open with read only mod
if ( f == NULL) {
printf("file open fail, please check filename and privilege\n");
return 1;
}
while (fscanf(f, "%s", buf) != EOF) {
addStack(&s, buf);
}
while(!emptyStack(&s)) {
printf("%s\n", tmp=deleteStack(&s));
free(tmp); //用完再釋出記憶體空間
}
} else {
printf("please specify filename as the first argument\n");
}
return 0;
}
int main(int argc, char *argv[])
{
(void)argc; // we don't use argc, causes compiler not to warn us about it.
// The output of this program may change over a series of runs due to:
// https://en.wikipedia.org/wiki/Address_space_layout_randomization
int i = 10;
char *str1 = "hello world"; // string literals are stored in the text region of memory, not on the heap.
char str2[] = "hello world"; // stored on stack
// highest addresses contain memory used by the OS:
printAddress("getenv", getenv("PATH"));
printAddress("argv", argv);
// The stack grows downward (the first address below is higher than the second address)
printAddress("&i inside main (stack)", &i);
addStack();
printAddress("str2 inside main (stack)", str2);
// String literals are stored in the .text section of memory (at the bottom of the stack)
printAddress("str1 inside main (text)", str1);
/* malloc() usually uses the heap to allocate memory. It does so by calling sbrk() to move the "program break" which is the top of the heap. Moving the "program break" to a higher value will give your process more memory. malloc() does this for you. If change the program break with sbrk(), you might break other functions that actually use malloc(). */
printAddress("sbrk (heap)", sbrk(0));
void *m = malloc(1024);
printAddress("m (heap)", m);
// NOTE: malloc() may use a few bytes for its own bookkeeping,
printAddress("sbrk after malloc (heap)", sbrk(0));
free(m);
// free()'ing memory doesn't necessarily move sbrk back down.
printAddress("sbrk after free (heap)", sbrk(0));
// instead, memory might be reused for future malloc()'s:
m = malloc(10);
void *m2 = malloc(100);
printAddress("m (heap)", m);
printAddress("m2 (heap)", m2);
printAddress("sbrk after 2 more mallocs (heap)", sbrk(0));
free(m);
free(m2);
/* malloc() uses mmap() when large areas of space are requested. */
m = malloc(1024*128*50); // typically mmap is used for allocations larger than 128k
printAddress("m (that may have been allocated with mmap) (mmap)", m);
printAddress("sbrk after malloc (that may use mmap) (heap)", sbrk(0));
free(m);
printAddress("globalVar (text)", &globalVar);
printAddress("printAddress (text)", printAddress);
// since we dynamically link to printf, its isn't defined until
// the linker links this program to libc at runtime. The address
// that is printed out is the address of the PLT for
// printf---which will then in-turn call printf().
printAddress("printf PLT (text)", printf);
return EXIT_SUCCESS;
}
int main() {
DStack_L stackL(SIZE_STACK),
stackSec(SIZE_STACK);
if(fillingStack(stackL, stackSec) == false) {
std::cout << "IMPOSSIBLE";
return 0;
}
addStack(stackL, stackSec);
char ch;
while((ch = stackL.pop()) != '\n') {
std::cout << ch;
}
return 0;
}
void Resource::addStacks(Item* i){
addStack(i->getStack());
delete i;
}
DWORD LandScape::execV( LS_OPCODE _opcode, va_list _va )
{
// reset the return status - individual functions will alter this if need be
mExecStatus = EXEC_SUCCESS;
mExecString[0] = '\0';
switch( _opcode )
{
case LS_SEED: setSeed( va_arg(_va,DWORD) ); break;
case LS_LOAD: return load( va_arg(_va,char*) );
case LS_LOADM:
{
char * tmpCh = va_arg(_va,char*);
double tmpD = va_arg(_va,double);
return load(tmpCh, float(tmpD));
}
case LS_SAVE: return save( va_arg(_va,char*) );
case LS_CLEAR: clear(); break;
case LS_PUSH: push( va_arg(_va,int)); break;
case LS_POP: pop(); break;
case LS_GET: return (DWORD)get( va_arg(_va,int) );
case LS_SWAP: swap(); break;
case LS_DUP: dup(); break;
case LS_ADD: add( float(va_arg(_va,double)) ); break;
case LS_SUB: sub( float(va_arg(_va,double)) ); break;
case LS_MUL: mul( float(va_arg(_va,double)) ); break;
case LS_DIV: div( float(va_arg(_va,double)) ); break;
case LS_EXP: exp( float(va_arg(_va,double)) ); break;
case LS_NEG: neg(); break;
case LS_CLR: clr( float(va_arg(_va,double)) ); break;
case LS_DIFF: diff(); break;
case LS_NORMALIZE:
{
double i = va_arg(_va,double);
double j = va_arg(_va,double);
normalize( float(i), float(j) );
}
break;
case LS_ADDS: addStack(); break;
case LS_SUBS: subStack(); break;
case LS_FLOOR:
{
double i = va_arg(_va,double);
double j = va_arg(_va,double);
double k = va_arg(_va,double);
floor( float(i), float(j), float(k) );
}
break;
case LS_CEIL:
{
double i = va_arg(_va,double);
double j = va_arg(_va,double);
double k = va_arg(_va,double);
ceil( i, j, k );
}
break;
case LS_CLIPMIN: clipMin( float(va_arg(_va,double)) ); break;
case LS_CLIPMAX: clipMax( float(va_arg(_va,double)) ); break;
case LS_ROT: rot(); break;
case LS_FLIPX: flipX(); break;
case LS_FLIPY: flipY(); break;
case LS_TERRAIN:
{
int i = va_arg(_va,int);
double j = va_arg(_va,double);
if (i > 256)
{
terrain( 256, float(j) );
size(i);
}
else
terrain( i, float(j) );
}
break;
case LS_PLASMA:
{
int i = va_arg(_va,int);
double j = va_arg(_va,double);
if (i > 256)
{
plasma( 256, float(j) );
size(i);
}
else
plasma( i, float(j) );
}
break;
case LS_SIZE: size( va_arg(_va,int) ); break;
case LS_SLOPE:
{
double i = va_arg(_va,double);
int j = va_arg(_va,int);
slope( i, float(j) );
}
break;
case LS_SHAVE:
{
double i = va_arg(_va,double);
double j = va_arg(_va,double);
double k = va_arg(_va,double);
shaveArea( float(i), float(j), float(k) );
}
break;
case LS_CURVE:
{
double i = va_arg(_va,double);
int j = va_arg(_va,int);
curve( float(i), j );
}
break;
case LS_FFT:
if (stack.size() > 1)
fft( va_arg(_va,int) ); break;
case LS_FILL_N:
if (stack.size() > 1)
fillNormal( float(va_arg(_va,double)) ); break;
case LS_OVERLAY:
{
int i = va_arg(_va,int);
double j = va_arg(_va,double);
overlay( i, float(j) );
}
break;
case LS_ALPHABLEND:
{
int x = va_arg(_va, int);
int y = va_arg(_va, int);
alphablend(x, y);
}
break;
case LS_BLEND:
{
int i = va_arg(_va,int);
int j = va_arg(_va,int);
blend( i, j );
}
case LS_SMOOTH:
{
double i = va_arg(_va,double);
double j = va_arg(_va,double);
smooth( float(i), float(j) );
}
break;
case LS_TILE: tile(); break;
case LS_WRAP: wrap(); break;
case LS_CLAMP:
{
int i = va_arg(_va,int);
double j = va_arg(_va,double);
clamp(i, float(j));
}
break;
case LS_MASK:
{
int i = va_arg(_va,int);
double j = va_arg(_va,double);
mask(i, float(j));
}
break;
case LS_CRATER:
case LS_PEAK:
case LS_RING:
case LS_FILLBASIN:
case LS_LPFILTER:
case LS_HPFILTER:
case LS_BPFILTER:
case LS_BRFILTER:
case LS_FFLP:
case LS_FFHP:
case LS_FFBP:
case LS_FFBR:
default:
break;
}
return NULL;
}
void UndoManager::addNewUndoStack()
{
undoStacks.emplace_back(new QUndoStack);
addStack(undoStacks.back().get());
}
void Editor::stackAdded(QUndoStack *stack)
{
addStack(stack);
}
