TweetFollow Us on Twitter

Lexical Analysis
Volume Number:6
Issue Number:5
Column Tag:Language Translation

Ambiguities and Lexical Analysis

By Clifford Story, Mount Prospect, IL

Part III. Ambiguities, Etc.

A. Introduction

This is the third part in my series on Language Translation. Language translation has three phases: lexical analysis, parsing, and code generation. The first two parts have dealt with building parsers using YACC; this is the final installment on that subject.

That will take up only about half the article. The remainder will begin the new topic of lexical analysis by presenting a skeleton filter tool.

B. Parsing

I now conclude parsing with a couple of miscellaneous topics. The first is a simple way to handle ambiguities in a grammar. Then comes the horrible question of error detection and reporting.

B(1). Ambiguities

Parser ambiguities, you may recall, are spots in the parse table where YACC’s generation algorithm would place a shift and a reduction, or two reductions. A naive grammar would generate an ambiguity when considering the input string

2 + 3 * 4

since it isn’t clear whether this means (2 + 3) * 4 or 2 + (3 * 4).

We faced this problem in the first part and solved it by re-writing the grammar to eliminate the ambiguity. YACC offers another way of handling ambiguities (also known as shift/reduce and reduce/reduce conflicts).

B(1)(a). YACC’s Default Rule

First, something you should know: YACC will work through any conflicts that it finds and produce a non-ambiguous grammar for you. It resolves conflicts automatically, and will only issues warnings, not errors.

Unfortunately, it does this by making assumptions about what you intended, and these assumptions need not be correct. You can get a grammar that simply does not do what you meant it to do, despite the lack of error messages. In my opinion, this is a design flaw in YACC; conflicts should be fatal errors.

Even worse, MACYACC (see the first part for a review) uses an inordinately complicated rule for resolving conflicts. Unix YACC uses a very simple rule, so you can guess what it’s going to do. MACYACC, no such luck.

Therefore, YOU SHOULD ALWAYS REACT TO CONFLICT WARNINGS AS IF THEY WERE FATAL ERRORS!

B(1)(b). Operator Precedence

Remember, conflicts arise when the parser doesn’t know which operation to perform first, as in the 2 + 3 * 4 example. We intelligent humans know that multiplication comes before addition: multiplication has a higher precedence than addition. The conflict is easily and correctly resolved if YACC knows the order of precedence among all operators in the grammar.

All that need be done is tell YACC:

/* 1 */

%left ‘+’ ‘-’
%left ‘*’ ‘/’

Multiplication and division have the same precedence (because they are on the same line), and higher precedence than addition and subtraction (because their line is after addition and subtraction’s line). That solves the problem (read on for an explanation of the “left” business).

But what about strings like

2 - 3 + 4

Is that 2 - (3 + 4) or (2 - 3) + 4? The above rules don’t seem to say, since subtraction and addition have the same precedence.

B(1)(c). What is Associativity?

Good question. In a string of the form

... • ID • ...

where ‘•’ is an operator and ‘ID’ an identifier, the • to the left of the ID will have a higher precedence than the • to the right if • is left-associative; and conversely. Thus,

2 - 3 - 4

is conventionally -5 because subtraction is left-associative. If it were right-associative, 2 - 3 - 4 would equal 2 - (3 - 4), or 3. Just about everything is left-associative.

So associativity defines order of evaluation among operators on the same level of operator precedence. And the line

%left ‘+’ ‘-’

says that addition and subtraction are left-associative among one another.

YACC also includes keywords %right, which means just what you might think, and %nonassoc, which means constructs of the form

... • ID • ...

are illegal (think of logical operators).

B(1)(d). The Lonely Minus...

There’s one more thing to worry about: unary operators. The classic example is the minus sign. Do you remember my asking why a hex calculator was easier to write than a decimal calculator? The answer is that a hex calculator doesn’t have to deal with unary minus...

The problem arises because the minus sign is used for both unary and binary operators (negation and subtraction). When we assign it a precedence in the %left statement, we’re thinking about subtraction, so we give it a lower precedence than multiplication and division. But negation should have the same precedence as multiplication and division.

The solution is to give a grammar rule a precedence. This can be done with the %prec keyword:

expr : ‘-’ expr %prec ‘*’

gives this rule the same precedence as multiplication. Thus, unary minus will have the right precedence, and everything is at last conflict-free.

B(1)(e).  An Example

%token  NUM
%left   ‘+’ ‘-’
%left   ‘*’ ‘/’
%left   MINUS

%%

prob  : expr ‘\n’
 {
 printf(“\t= %d\n”, $1);
 return(0);
 }
 
 ;

expr  : expr ‘+’ expr
 {
 $$ = $1 + $3;
 }
 
 | expr ‘-’ expr
 {
 $$ = $1 - $3;
 }
 
 | expr ‘*’ expr
 {
 $$ = $1 * $3;
 }
 
 | expr ‘/’ expr
 {
 $$ = $1 / $3;
 }
 
 | ‘-’ expr %prec MINUS
 {
 $$ = - $2;
 }
 
 | ‘(‘ expr ‘)’
 {
 $$ = $2;
 }
 
 | NUM
 {
 $$ = $1;
 }
 
 ;

%%

/***************************************/
#include “stdio.h”
#include “ctype.h”
#include “string.h”
/***************************************/
char    *input;
char    *token;
/***************************************/

#define yyerror(x)
 {
 printf(“\t%s [%s]\n”, x, token);
 return(0);
 }

yyparse();
int yylex();
 
/***************************************/
void main(int argc, char *argv[])
 {
 
 char   thestring[256];
 
 if (argc < 1)
 printf(“\tImpossible error!\n”);
 else if (argc > 2)
 printf(“\tHey!  One at a time!\n”);
 else if (argc == 2)
 {
 input = argv[1];
 yyparse();
 }
 else
 {
 printf(“? “);
 while (strlen(gets(thestring)) > 2)
 {
 input = &thestring[2];
 yyparse();
 printf(“? “);
 }
 }
 }
 
/***************************************/
int yylex()
 {
 
 token = strtok(input, “ “);
 input = 0;
 
 if (token == 0)
 return(‘\n’);
 else if (sscanf(token, “%d”, &yylval) == 1)
 return(NUM);
 else
 return(token[0]);
 
 }
/***************************************/

B(2). Catching Errors

You may have noticed that Pascal compilers write real error messages, while C compilers write error messages more cryptic than C itself. There’s a reason for this: Pascal compilers use recursive-descent parsers, while C compilers use table-driven parsers. Recursive-descent parsers are the sort of parsers a person might naturally write: get the next token; if it’s a ‘+’, do this, else get the next token and do that, and so on. A location in the code of the parser corresponds to a particular grammar structure in the input string, so it’s easy to insert appropriate error messages. Table-driven parsers make things more difficult. Ever seen an error message to the effect “Need an lval”? That’s a sign of the parser, not the language; from the YACC global yylval, you can probably guess what an lval is.

So writing meaningful error messages in a YACC-generated parser is a real problem.

B(2)(a). Semantic Errors

Semantic errors are easy. These are illegal operations, like division by zero, and other violations of data types (overflow, writing past the end of an array, and so forth).

The decimal calculator provides the opportunity to divide by zero. Let’s catch this error, and issue an error message instead. Division occurs in only one grammar rule:

/* 3 */

expr  | expr ‘/’ expr
 {
 $$ = $1 / $3;
 }

Just insert an operand check in the generated code:

/* 4 */

expr  | expr ‘/’ expr
 {
 if ($3 != 0)
 $$ = $1 / $3;
 else
 {
 printf(“Divide by zero!\n”);
 return(0);
 }
 }

I’m using a cheap trick here; the return(0) means abort. This is ok, because the calculator evaluates one expression at a time, and an error should cause an abort. But if this were a compiler, detecting a single error should not kill the compile; I want to know about ALL the errors.

B(2)(b). Illegal Characters

The language’s character set has nothing to do with the grammar, and hence nothing to do with the parser. It is entirely in the control of the lexical analyzer. And, of course, it’s easy for the lexical analyzer to catch illegal characters. But how can it report them?

Here’s my solution. First, I declare a new token at the top of the input file:

/* 5 */

%token  ILLEGAL

None of the grammar rules use this token, so should the lexical analyzer return it, the parser must sense an error.

Now, to get an error message out of this! I’m going to continue to declare the yyerror routine as a macro, so it can use the parser’s local variables and also abort the parser. Then I’m going to create a new error routine that yyerror will call, passing a couple of those interesting locals. The two I want are ‘tmpstate’, the current state of the parser, and ‘pcyytoken’, the type of the last token returned by yylex(). The declarations look like this:

/* 6 */

#define yyerror(x)
 {
 errordisplay(tmpstate, pcyytoken);
 return(0);
 }
void errordisplay(int state,
 int tokentype);

Then, in the errordisplay() routine, if ‘tokentype’ equals ILLEGAL, I print an appropriate message.

B(2)(c). Syntactic Errors

Errors of syntax are the hard ones (and my development of this topic has not been helped by my outliner’s just destroying my first approach to it. Especially since I wrote the outliner... A word of advice to aspiring Mac programmers: do not neglect the grow zone routine.) The problem is that these errors are detected by a table that we didn’t write, instead of nice readable code that we did.

But we can still zero in on the specific error. We begin with the .out file. If there’s an error in state 0, we know why: the parser was expecting a number, a -, or a (, but it got something else instead. So instead of saying just “syntax error”, we say “Expecting a number, - or (!”. We can do the same for each state, and write errordisplay() as follows:

/* 7 */

void errordisplay(int state,
 int tokentype)
 {
 
 if (tokentype == ILLEGAL)
 printf(“\tIllegal character!\n”);
 else switch (state)
 {
 
 case 0:
 case 3:
 case 4:
 case 7:
 case 8:
 case 9:
 case 10:
 printf(“\tExpecting a number,”
 “‘-’ or ‘(’!\n”);
 break;
 
 case 2:
 printf(“\tExpecting an “
 “operator or end “
 “of input!\n”);
 break;
 
 case 12:
 printf(“\tExpecting an “
 “operator or ‘)’!\n”);
 break;
 
 case 13:
 case 14:
 printf(“\tExpecting a ‘*’ “
 or ‘/’!\n”);
 break;
 
 default:
 printf(“\tImpossible error!  “
 “State = %d, token = %d\n”,
 state, tokentype);
 break;
 
 }
 
 }

All right, but we can do better than that. For example, since the parser is in state 0 only when it is reading the first token, an error in state zero means that the token is wrong for the beginning of input, so we might write something more to the point, like “An expression must begin with a number, - or (!”. Similarly, we can look closer at the other states and get a better idea of just what is going on in each. We can use the token type to further focus on the error. And so on.

And we can also keep track of just where in the input we are, so we can point to the location of the error:

? 2 - 3 4
        ^

Expecting an operator or end of input!

B(3). Last Words on YACC

And that’s it for YACC. Which is not to say that nothing in the remainder of the series will rely on YACC; on the contrary. But I will assume that my audience is now familiar with the tool and introduce grammar descriptions and such without apology.

The next topic is lexical analysis. And since I’ve got some space left this month, I’ll launch into it with a skeleton filter program.

C. Lexical Analysis

Next time, I will move on to lexical analysis, and replace my calculator example with a file filter. Filter programs are somewhat unusual in the Macintosh world, so perhaps a definition is appropriate: a filter program is one that reads one filter, massages it in some way, and writes the result. Such programs are common under Unix, where simple programs can be strung together in batch files with IO redirection and piping to create much more powerful utilities. For an example, see the discussion of Steve Johnson’s spell utility on page 139 of Jon Bentley’s Programming Pearls.

The calculator example I’ve used so far is not a filter, since it works from direct user input on the command line. It looks like the rest of this series will use filters, however; first with the lexical analysis examples, and then with the inline assembler. What I’m going to do now is develop a basic identity filter, to settle some issues once and for all, so I can then ignore them and concentrate on language translation.

C(1). Command Line

The first problem is reading the command line. I want the tool to read either one or more files named on the command line, or standard input if there aren’t any named input files. I want it to write to a named output file, or to standard output if none is named. And I want to be able to set a language type (for reasons that won’t become clear until next month) with command line options.

Recall that MPW passes the command line as an array of strings. The first string, argv[0], is the name of the tool, and the rest are the individual arguments.

C(1)(a). Input Files

Input files are specified on the command line by name alone, with no special flags. If a name appears unaccompanied by any flag, it is by default an input file. The tool can read arbitrarily many input files; if none are specified, then it reads standard input (which can come from IO redirection).

So I’m going to have an integer variable called “input” which I will initialize to the standard input unit. Then I’ll walk through the argument list, and if I find an input file, I will open it (using the “input” variable for its unit), append it to my input buffer, and close it. If, after reading the entire command line, “input” is still equal to standard input, then I know that no input files were named, and so I’ll read standard input into the buffer.

C(1)(b). Options

Options are command arguments that begin with a hyphen (this doesn’t have to be so; I have written a tool with an almost natural-language command line but -options are customary and easy to parse).

There are two kinds of options: the output file, and true options (the name of the output file isn’t a true option, of course, but it’s specified with option syntax).

C(1)(b)(i). Output File

The tool can write one output file, or write to standard output. A named output file is specified with a “-o” option followed by the name of the file.

Similarly to output, I have an integer variable called “output”, initially set to the standard output unit. If an output file is named on the command line, then I open it, and set “output” to its unit number. If “output” isn’t standard output, then I know an output file is already open, so I print a warning and ignore the new file.

C(1)(b)(ii). Language

I won’t be using the language option this month but I might as well get it in here anyway. The language can be either Pascal or C. Pascal is the default; it is reset by the first named input file with either a “.p” or “.c” extension, and this can be overridden with either a “-p” or “-c” command option.

First, I’ll declare a special type, “codetype”:

/* 8 */

typedef enum
 {
 nocode,
 pascalcode,
 ccode
 } codetype;

and a variable, “language” of type codetype, initially “nocode”. This indicates that the language has not been set.

As I walk though the command line, if I find an input file, “language” is still “nocode”, and the file name ends in either “.p” or “.c”, then I’ll set “language” accordingly. Thus, only the first such file can set the language.

If, on the other hand, I find a “-p” or “-c” option, I will set “language” accordingly, regardless of any previous setting. The options override filename conventions. (I don’t check for multiple options; the last one controls.)

Finally, if “language” is still “nocode” after reading the entire command line, then I set it to the default, Pascal.

C(2). IO Buffering

In the interests of speed, I’ll buffer both input and output. If you don’t think this makes a difference, just re-write the tool without buffering!

Input buffering is easy: I just read input, in 1K chunks, into a single buffer, which I can re-size as necessary to accommodate the amount to read. The MPW interface doesn’t provide any way to get the file size before reading it (not surprising, I guess; what’s the “size” of standard input?).

Output buffering is a bit more complex. This is an identity filter, so I just copy the input without modification to the output buffer. When the output buffer fills up, I write 1K of it to the output file, and shift what’s left to the front of the buffer.

C(3). The Program

Here’s the code. The file “managers” is a load file containing all the C include files; this makes compilation of the program faster.

/* 9 */

// Filter.c - Skeleton MPW filter tool
 
#pragma load “managers”
 
// Constants and Macros
 
#define nil 0
 
#define stdinfd  0
#define stdoutfd 1
#define stderrfd 2
 
#define stdunit(x) ((x >= stdinfd) && (x <= stderrfd))
#define notstdunit(x)(x > stderrfd)

#define nombuffsize1024
#define truebuffsize 1200
 
// Types
typedef enum {false, true} logical;

typedef enum
 {
 nocode,
 pascalcode, 
 ccode
 } codetype;
 
// Prototypes
 void initmac();
 int openoutput(char *thename, int output);
 int readinput(int input, Handle inbuffer, int buffersize);
 int filter(char *inbuffer, int buffersize, int output, 
 codetype language);
 int writeoutput(int output, char *outbuffer, int buffersize);
 
// main
// ----
// the “main” routine reads and
// interprets the command line,
// concatenates input files into an
// input buffer, opens the output
// file, and calls the “filter”
// routine to write the output.
 
int main(int argc, char *argv[])
 {
 int    index;
 int    input;
 int    output;
 codetype language;
 Handle inbuffer;
 int    buffersize;
 char   *thetail;
 
 initmac();
 
// “input” is the fd of the input file,
// initially stdin “output” is the fd
// of the output file, initially
// stdout “language” is the language
// to parse, initially unknown
 
 input = stdinfd;
 output = stdoutfd;
 language = nocode;
 
// “inbuffer” is the input buffer,
// initially empty but able to grow
// “buffersize” is the size of “inbuffer”
 
 inbuffer = NewHandle(0);
 buffersize = 0;
 
// command line interpreter: loop through command options
 
 for (index = 1; index < argc; index++)
 {
 if (argv[index][0] == ‘-’)
 {
 switch (argv[index][1])
 {
 
// “-p” and “-c” options set language
// type; these override any previous setting
 
 case ‘P’:
 case ‘p’:
 language = pascalcode;
 break;
 
 case ‘C’:
 case ‘c’:
 language = ccode;
 break;
 
 case ‘O’:
 case ‘o’:
 output = openoutput(
 argv[++index], output);
 if (output < 0)
 {
 fprintf(stderr, “Error - Unable”
 “ to open output  file %s!\n”,
 argv[index]);
 exit(2);
 }
 break;
 
 default:
 fprintf(stderr, “Error - Unknown option %s\n”,
  argv[index]);
 exit(2);
 break;
 
 }
 
 }
 else
 {
 
// if “language” has not changed since
// initialization, set “language”
// according to file name (the first
// input file thus determines language type)
 
 if (language == nocode)
 {
 thetail = argv[index] + strlen(argv[index]) - 2;
 if (strcmp(thetail, “.p”) == 0)
 language = pascalcode;
 else if (strcmp(thetail, “.c”) == 0)
 language = ccode;
 }
 
// open the input file (after this step,
// “input” will NOT contain a standard
// unit number) and read it into the input buffer
 
 input = open(argv[index], O_RDONLY);
 if (input < 0)
 {
 fprintf(stderr, “Error - Unable to open input”
 “file %s!\n”, argv[index]);
 exit(2);
 }
 
 buffersize = readinput(input, inbuffer, buffersize);
 if (buffersize < 0)
 {
 fprintf(stderr, “Error -  Reading from %s!\n”,
 argv[index]);
 exit(2);
 }
 
 close(input);
 
 }
 }
 
// if “input” is still a standard unit
// number, then no input file was
// opened, and input must be from standard input
 
 if (stdunit(input))
 {
 buffersize = readinput(input,
 inbuffer, buffersize);
 if (buffersize < 0)
 {
 fprintf(stderr, “Error - Reading from standard”
 “ input!\n”);
 exit(2);
 }
 }
 
// if “language” is still unknown, set it to Pascal
 
 if (language == nocode)
 language = pascalcode;
 
// the routine “filter” does the real work of the program
 
 HLock(inbuffer);
 filter(*inbuffer, buffersize, output, language);
 HUnlock(inbuffer);
 
// wrapup:  close “output” first if the program opened it
 
 DisposHandle(inbuffer);
 
 if (notstdunit(output))
 close(output);
 
 exit(0);
 }
 
// initmac
// ------
// initialize any necessary managers and whatnot.
 
void initmac()
 {
 
 InitGraf((Ptr)&qd.thePort);
 SetFScaleDisable(true);
 
 InitCursorCtl(nil);
 }
 
// openoutput
// ----------
// open the output file.  returns the
// fd or, if an error occurs, the
// error flag.
 
int openoutput(char *thename, int output)
 {
 FInfo  theinfo;
 
// if “output” is not a standard unit,
// then an output file must have already be open
 
 if (notstdunit(output))
 {
 fprintf(stderr, “Warning - additional output file %s”
 “ ignored!\n”, thename);
 return(output);
 }

// open the output file for writing
// (O_WRONLY), creating it if
// necessary (O_CREAT) and
// zeroing it otherwise (O_TRUNC)
 
 output = open(thename, O_WRONLY + O_CREAT + O_TRUNC);
 if (output < 0)
 return(output);

// if the file was created by “open”, it
// will be untyped, so set the type to TEXT and MPS
 
 if (getfinfo(thename, 0, &theinfo))
 {
 fprintf(stderr, “Warning - unable to get info for output file %s!\n”, 
thename);
 return(output);
 }
 
 theinfo.fdType = ‘TEXT’;
 theinfo.fdCreator = ‘MPS ‘;
 
 if (setfinfo(thename, 0, &theinfo))
 fprintf(stderr, “Warning - unable to set info for output file %s!\n”, 
thename);
 
 return(output);
 }
 
// readinput
// --------
// this routine appends an input file
// to the input buffer and returns
// the new size of the buffer or, if
// a read error occurs, the error flag.
 
int readinput(int input, Handle inbuffer, int buffersize)
 {
 int    readsize;
 
 SetHandleSize(inbuffer, buffersize + 1024);
 HLock(inbuffer);
 
 while ((readsize = read(input,
 *inbuffer + buffersize, 1024)) > 0)
 {
 buffersize += readsize;
 HUnlock(inbuffer);
 SetHandleSize(inbuffer, buffersize + 1024);
 HLock(inbuffer);
 }
 
 if (readsize < 0)
 return(readsize);
 
 HUnlock(inbuffer);
 SetHandleSize(inbuffer, buffersize + 1024);
 
 return(buffersize);
 }
 
// filter
// ------
// this routine does the main work of
// the program, which in this case
// consists of simply writing the
// input buffer to the output file.
 
int filter(char *inbuffer, int buffersize, int output,
 codetype language)
 {
#pragma unused(language)
 
 int    inposition;
 int    outposition;
 char   outbuffer[truebuffsize];
 unsigned char thechar;
 int    writesize;
 
// “inposition” keeps track of the
// current position in the input
// buffer, initially at the beginning
// “outposition” keeps track of the
// current position in the output
// buffer, initially at the beginning
 
 inposition = 0;
 outposition = 0;
 
 while (inposition < buffersize)
 {
// copy input to the output buffer, one character at a time
 thechar = *(inbuffer + inposition++);
 outbuffer[outposition++] = thechar;
 
// when the output buffer fills up, write it to output
 if (outposition >= nombuffsize)
 outposition = writeoutput(
 output, outbuffer, 
 outposition);
 if (outposition < 0)
 return(outposition);
 
 }
 
// write whatever is left in the buffer
// directly to output
 
 writesize = write(output, outbuffer, outposition);
 return(writesize);
 }
 
// writeoutput
// ----------
// this routine flushes the output 
// buffer by writing it to the output
// file.  It returns the new size of
// the buffer or, if a write error
// occurs, the error flag.
 
int writeoutput(int output, char *outbuffer, int buffersize)
 {
 int    writesize;
 
 writesize = write(output, outbuffer, nombuffsize);
 
 if (writesize < 0)
 return(writesize);
 
 buffersize -= writesize;
 BlockMove(outbuffer + writesize, outbuffer, buffersize);
 
 return(buffersize);
 }

D. Conclusion

Next time I’ll expand the Filter tool by adding a state machine to control the transfer of data from the input buffer to the output buffer. I’ll assume you’ve got the code just above, and won’t repeat it, except for the “filter” routine. So hang on to this issue of MacTutor!

 
AAPL
$119.00
Apple Inc.
+1.40
MSFT
$47.75
Microsoft Corpora
+0.28
GOOG
$540.37
Google Inc.
-0.71

MacTech Search:
Community Search:

Software Updates via MacUpdate

HoudahSpot 3.9.6 - Advanced file search...
HoudahSpot is a powerful file search tool built upon MacOS X Spotlight. Spotlight unleashed Create detailed queries to locate the exact file you need Narrow down searches. Zero in on files Save... Read more
RapidWeaver 6.0.3 - Create template-base...
RapidWeaver is a next-generation Web design application to help you easily create professional-looking Web sites in minutes. No knowledge of complex code is required, RapidWeaver will take care of... Read more
iPhoto Library Manager 4.1.10 - Manage m...
iPhoto Library Manager lets you organize your photos into multiple iPhoto libraries. Separate your high school and college photos from your latest summer vacation pictures. Or keep some photo... Read more
iExplorer 3.5.1.9 - View and transfer al...
iExplorer is an iPhone browser for Mac lets you view the files on your iOS device. By using a drag and drop interface, you can quickly copy files and folders between your Mac and your iPhone or... Read more
MacUpdate Desktop 6.0.3 - Discover and i...
MacUpdate Desktop 6 brings seamless 1-click installs and version updates to your Mac. With a free MacUpdate account and MacUpdate Desktop 6, Mac users can now install almost any Mac app on macupdate.... Read more
SteerMouse 4.2.2 - Powerful third-party...
SteerMouse is an advanced driver for USB and Bluetooth mice. It also supports Apple Mighty Mouse very well. SteerMouse can assign various functions to buttons that Apple's software does not allow,... Read more
iMazing 1.1 - Complete iOS device manage...
iMazing (was DiskAid) is the ultimate iOS device manager with capabilities far beyond what iTunes offers. With iMazing and your iOS device (iPhone, iPad, or iPod), you can: Copy music to and from... Read more
PopChar X 7.0 - Floating window shows av...
PopChar X helps you get the most out of your font collection. With its crystal-clear interface, PopChar X provides a frustration-free way to access any font's special characters. Expanded... Read more
Carbon Copy Cloner 4.0.3 - Easy-to-use b...
Carbon Copy Cloner backups are better than ordinary backups. Suppose the unthinkable happens while you're under deadline to finish a project: your Mac is unresponsive and all you hear is an ominous,... Read more
ForeverSave 2.1.3 - Universal auto-save...
ForeverSave auto-saves all documents you're working on while simultaneously doing backup versioning in the background. Lost data can be quickly restored at any time. Losing data, caused by... Read more

Latest Forum Discussions

See All

Make Way for Fat Chicken, from the Maker...
Make Way for Fat Chicken, from the Makers of Scrap Squad Posted by Jessica Fisher on November 26th, 2014 [ permalink ] Relevant Games has announced they will be releasing their reverse tower defense game, | Read more »
Tripnary Review
Tripnary Review By Jennifer Allen on November 26th, 2014 Our Rating: :: TRAVEL BUCKET LISTiPhone App - Designed for the iPhone, compatible with the iPad Want to create a travel bucket list? Tripnary is a fun way to do exactly that... | Read more »
Ossian Studios’ RPG, The Shadow Sun, is...
Ossian Studios’ RPG, The Shadow Sun, is Now Available for $4.99 Posted by Jessica Fisher on November 26th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Mmmm, Tasty – Having the Angry Birds for...
The very first Angry Birds debuted on iOS back in 2009. When you sit back and tally up the number of Angry Birds games out there and the impact they’ve had on pop culture as a whole, you just need to ask yourself: “How would the birds taste... | Read more »
Rescue Quest Review
Rescue Quest Review By Jennifer Allen on November 26th, 2014 Our Rating: :: PATH BASED MATCH-3Universal App - Designed for iPhone and iPad Guide a wizard to safety by matching gems. Rescue Quest might not be an entirely original... | Read more »
You Can Play the Final Chapter of Lone W...
You Can Play the Final Chapter of Lone Wolf: Dawn Over V’taag Right Now Posted by Jessica Fisher on November 26th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Swords of Anima (Games)
Swords of Anima 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: A new tactical turn-based RPG experience. Command the Savior Rex Squad in an epic journey of courage and deception. Can you... | Read more »
Audio Defence: Zombie Arena
Audio Defence: Zombie Arena By Lee Hamlet on November 26th, 2014 Our Rating: :: DRAGS ITS FEETUniversal App - Designed for iPhone and iPad From the makers of Papa Sangre comes a defense game that forces players to listen carefully... | Read more »
Tales from the Borderland​s Will be Comi...
Tales from the Borderland​s Will be Coming to iOS by the End of the Year Posted by Jessica Fisher on November 26th, 2014 [ permalink ] Telltale Games has announced | Read more »
Sunburn! Review
Sunburn! Review By Campbell Bird on November 26th, 2014 Our Rating: :: DON'T DIE ALONEUniversal App - Designed for iPhone and iPad Platform through the depths of space to make sure your entire crew dies together in this satisfying... | Read more »

Price Scanner via MacPrices.net

2014 1.4GHz Mac mini on sale for $449, save $...
 B&H Photo has the new 1.4GHz Mac mini on sale for $449.99 including free shipping plus NY tax only. Their price is $50 off MSRP, and it’s the lowest price available for this new model. Adorama... Read more
Early Black Friday pricing on 27-inch 5K iMac...
 B&H Photo continues to offer Black Friday sale prices on the 27″ 3.5GHz 5K iMac, in stock today and on sale for $2299 including free shipping plus NY sales tax only. Their price is $200 off MSRP... Read more
Early Black Friday sale prices on iPad Air 2,...
 MacMall is discounting iPad Air 2s by up to $75 off MSRP as part of their Black Friday sale. Shipping is free: - 16GB iPad Air WiFi: $459 $40 off - 64GB iPad Air WiFi: $559 $40 off - 128GB iPad Air... Read more
Early Black Friday MacBook Air sale prices, $...
 MacMall has posted early Black Friday MacBook Air sale prices. Save $101 on all models for a limited time: - 11″ 1.4GHz/128GB MacBook Air: $798 - 11″ 1.4GHz/256GB MacBook Air: $998 - 13″ 1.4GHz/... Read more
Why iPhone 6 Tablet/Laptop Cannibalization Is...
247wallst.com blogger Douglas A. McIntyre noted last week that according to research posted on the Applovin blog site the iPhone 6 is outselling the iPhone 6 Plus by a wide margin . Hardly a surprise... Read more
Worldwide Tablet Growth Expected to Slow to 7...
The global tablet market is expected to record massive deceleration in 2014 with year-over-year growth slowing to 7.2%, down from 52.5% in 2013, according to a new forecast from International Data... Read more
Touchscreen Glove Company Announces New Produ...
Surrey, United Kingdom based TouchAbility specializes in design and manufacture of a wide variety of products compatible with touchscreen devices including smartphones, tablets and computers. Their... Read more
OtterBox Alpha Glass Screen Protectors for iP...
To complement the bigger, sharper displays on the latest Apple devices, OtterBox has introduced Alpha Glass screen protectors to the iPhone 6 and iPhone 6 Plus. The fortified glass screen protectors... Read more
Early Black Friday Mac Pro sale, 6-Core 3.5GH...
 B&H Photo has the 6-Core 3.5GHz Mac Pro on sale today for $3499 including free shipping plus NY sales tax. Their price is $500 off MSRP, and it’s the lowest price available for this model from... Read more
Early Black Friday sale price: 15-inch 2.2GHz...
 B&H Photo has the 2014 15″ 2.2GHz Retina MacBook Pro on sale today for $1699.99. Shipping is free, and B&H charges NY sales tax only. Their price is $300 off MSRP, equalling Best Buy’s price... Read more

Jobs Board

*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Senior Event Manager, *Apple* Retail Market...
…This senior level position is responsible for leading and imagining the Apple Retail Team's global event strategy. Delivering an overarching brand story; in-store, Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.