示例#1
0
/// Parse multiplication and division
word36 ParseFactors() {
    word36 num1 = ParseAtom();
    for(;;) {
        // Skip spaces
        while(*expr == ' ')
            expr++;
        /// Save the operation and position
        char op = *expr;
        char* pos = expr;
        if(op != '/' && op != '*' && op != '%')
            return num1;
        expr++;
        word36 num2 = ParseAtom();
        // Perform the saved operation
        if(op == '/' || op == '%') {
            // Handle division/modulus by zero
            if(num2 == 0) {
                _err = EEE_DIVIDE_BY_ZERO;
                _err_pos = pos;
                return 0;
            }
            if (op == '/')
                num1 /= num2;
            else
                num1 %= num2;
        }
        else
            num1 *= num2;
    }
}
示例#2
0
M4Err ghnt_Read(Atom *s, BitStream *bs, u64 *read)
{
	Atom *a;
	u64 sr;
	M4Err e;
	HintSampleEntryAtom *ptr = (HintSampleEntryAtom *)s;
	if (ptr == NULL) return M4BadParam;

	BS_ReadData(bs, ptr->reserved, 6);
	ptr->dataReferenceIndex = BS_ReadInt(bs, 16);
	*read += 8;
	ptr->HintTrackVersion = BS_ReadInt(bs, 16);
	ptr->LastCompatibleVersion = BS_ReadInt(bs, 16);
	ptr->MaxPacketSize = BS_ReadInt(bs, 32);
	*read += 8;

	while (*read < ptr->size) {
		e = ParseAtom(&a, bs, &sr);
		if (e) return e;
		e = ChainAddEntry(ptr->HintDataTable, a);
		if (e) return e;
		*read += a->size;
	}
	if (*read != ptr->size) return M4ReadAtomFailed;
	return M4OK;
}
示例#3
0
M4Err tx3g_Read(Atom *s, BitStream *bs, u64 *read)
{
	M4Err e;
	u64 sr;
	Atom *a;
	TextSampleEntryAtom *ptr = (TextSampleEntryAtom*)s;

	BS_ReadData(bs, (unsigned char*)ptr->reserved, 6);
	ptr->dataReferenceIndex = BS_ReadInt(bs, 16);
	ptr->displayFlags = BS_ReadInt(bs, 32);
	ptr->horizontal_justification = BS_ReadInt(bs, 8);
	ptr->vertical_justification = BS_ReadInt(bs, 8);
	ptr->back_color = gpp_read_rgba(bs);
	gpp_read_box(bs, &ptr->default_box);
	gpp_read_style(bs, &ptr->default_style);
	*read += 18 + GPP_BOX_SIZE + GPP_STYLE_SIZE;

	while (*read < ptr->size) {
		e = ParseAtom(&a, bs, &sr);
		if (e) return e;
		*read += a->size;
		if (a->type==FontTableAtomType) {
			if (ptr->font_table) DelAtom((Atom *) ptr->font_table);
			ptr->font_table = (FontTableAtom *)a;
		} else {
			DelAtom(a);
		}
	}
	if (*read != ptr->size) return M4ReadAtomFailed;
	return M4OK;
}
示例#4
0
void
nsAttrValue::ParseStringOrAtom(const nsAString& aValue)
{
  PRUint32 len = aValue.Length();
  // Don't bother with atoms if it's an empty string since
  // we can store those efficently anyway.
  if (len && len <= NS_ATTRVALUE_MAX_STRINGLENGTH_ATOM) {
    ParseAtom(aValue);
  }
  else {
    SetTo(aValue);
  }
}
示例#5
0
void DwRfc1521Tokenizer::ParseToken()
{
    // Assume the field body has already been extracted.  That is, we don't
    // have to watch for the end of the field body or folding.  We just
    // treat any CRs or LFs as white space.
    mTokenStart = mNextStart;
    mTokenLength = 0;
    mTkType = eTkNull;
    if (mTokenStart >= mString.length()) {
        return;
    }
    // Skip leading space.  Also, since control chars are not permitted
    // in atoms, skip these, too.
    while (1) {
        if (mTokenStart >= mString.length()) {
            return;
        }
        if (!isspace(mString[mTokenStart]) && !iscntrl(mString[mTokenStart]))
            break;
        ++mTokenStart;
    }
    char ch = mString[mTokenStart];
    // Quoted string
    if (ch == '"') {
        mTkType = eTkQuotedString;
        ParseQuotedString();
    }
    // Comment
    else if (ch == '(') {
        mTkType = eTkComment;
        ParseComment();
    }
    // Domain literal
    else if (ch == '[') {
        mTkType = eTkDomainLiteral;
        ParseDomainLiteral();
    }
    // Special
    else if (istspecial(ch)) {
        mTkType = eTkTspecial;
        mTokenLength = 1;
        mToken = mString.substr(mTokenStart, 1);
        mNextStart = mTokenStart + 1;
    }
    // Atom
    else {
        mTkType = eTkToken;
        ParseAtom();
    }
    if (mDebugOut) PrintToken(mDebugOut);
}
示例#6
0
M4Err amr3_Read(Atom *s, BitStream *bs, u64 *read)
{
	M4Err e;
	u64 sub_read;
	AMRSampleEntryAtom *ptr = (AMRSampleEntryAtom *)s;
	if (ptr == NULL) return M4BadParam;

	ReadAudioSampleEntry((AudioSampleEntryAtom*)s, bs, read);

	e = ParseAtom((Atom **)&ptr->amr_info, bs, &sub_read);
	if (e) return e;
	*read += sub_read;
	if (*read != s->size) return M4ReadAtomFailed;
	return M4OK;
}
示例#7
0
M4Err h263_Read(Atom *s, BitStream *bs, u64 *read)
{
	M4Err e;
	u64 sub_read;
	H263SampleEntryAtom *ptr = (H263SampleEntryAtom *)s;
	if (ptr == NULL) return M4BadParam;

	ReadVideoSampleEntry((VisualSampleEntryAtom *)ptr, bs, read);

	e = ParseAtom((Atom **)&ptr->h263_config, bs, &sub_read);
	if (e) return e;
	*read += sub_read;
	if (*read != ptr->size) return M4ReadAtomFailed;
	return M4OK;
}
示例#8
0
M4Err avc1_Read(Atom *s, BitStream *bs, u64 *read)
{
	M4Err e;
	u64 sr;
	Atom *a;
	AVCSampleEntryAtom *ptr = (AVCSampleEntryAtom *)s;

	ReadVideoSampleEntry((VisualSampleEntryAtom *)ptr, bs, read);
	
	while (*read < ptr->size) {
		e = ParseAtom(&a, bs, &sr);
		if (e) return e;
		*read += a->size;
		e = avc1_AddAtom(ptr, a);
		if (e) return e;
	}
	AVC_RewriteESDescriptor(ptr);
	return (*read != ptr->size) ? M4ReadAtomFailed : M4OK;
}
示例#9
0
文件: parse.cpp 项目: gatgui/gcore
// Piece ::= Atom [ Repeat ]
Instruction* ParsePiece(const char **ppc, ParseInfo &info)
{
  Instruction *i = ParseAtom(ppc, info);
  if (i)
  {
    bool failed = false;
    Repeat *r = ParseRepeat(ppc, failed, info);
    if (r)
    {
      r->setInstruction(i);
      i = r;
    }
    else if (failed)
    {
      delete i;
      return 0;
    }
  }
  return i;
}
示例#10
0
//Add this funct to handle incomplete files...
//bytesExpected is 0 most of the time. If the file is incomplete, bytesExpected
//is the number of bytes missing to parse the atom...
M4Err ParseRootAtom(Atom **outAtom, BitStream *bs, u64 *bytesExpected)
{
	M4Err ret;
	u64 read;
	//first make sure we can at least get the atom size and type...
	//18 = size (int32) + type (int32)
	if (BS_Available(bs) < 8) {
		*bytesExpected = 8;
		return M4UncompleteFile;
	}
	ret = ParseAtom(outAtom, bs, &read);
	if (ret == M4UncompleteFile) {
		*bytesExpected = (*outAtom)->size - read - BS_Available(bs);
		//rewind our BitStream for next parsing
		BS_Rewind(bs, read);
		DelAtom(*outAtom);
		*outAtom = NULL;
	}
	return ret;
}
示例#11
0
// I kept the same interface, because.. well.. it seemed to make sense at the time.
int qtmovie_read(stream_t *file, demux_res_t *demux_res)
{
	// Our parameter object..
	qtmovie_t	qtmovie;

	// Our filesize
	long		fileSize;

	// We haven't found the mdat chunk yet..
	g_FoundMdatAtom		= 0;
	g_IsM4AFile			= 0;
	g_IsAppleLossless	= 0;
	g_StopParsing		= 0;
	
    // construct the stream;
    qtmovie.stream	= file;
    qtmovie.res		= demux_res;

	// Find the file length..
	stream_seek( file, 0, SEEK_END );
	fileSize = stream_tell( file );
	stream_seek( file, 0, SEEK_SET );
	
	// find the goo inside..
	ParseAtom( 0, fileSize, &qtmovie );
		
	// Return our state to the caller..
	if ( g_FoundMdatAtom && g_IsM4AFile && g_IsAppleLossless )
		return 1;
	else
	{
		// Something didn't go right, so we attempt to clear the allocations that were made during
		// the failed call, before returning that it failed to the caller.
		free( demux_res->codecdata );
		free( demux_res->time_to_sample );
		free( demux_res->sample_byte_size );
		return 0;
	}
}
示例#12
0
/*
 *      NAME
 *		QuerySCCData - Query for the SCC data on the root window
 *
 *      SYNOPSIS
 */
static void
QuerySCCDataRGB(Display *dpy, Window root)
/*
 *      DESCRIPTION
 *
 *      RETURNS
 *		None
 */
{
    char *property_return, *pChar;
    int  i, j;
    int  count, format, cType, nTables;
    unsigned long nitems, nbytes_return;
    Atom MatricesAtom, CorrectAtom;
    VisualID visualID;
    XVisualInfo vinfo_template, *vinfo_ret;
    int nvis;
    static char *visual_strings[] = {
	"StaticGray",
	"GrayScale",
	"StaticColor",
	"PseudoColor",
	"TrueColor",
	"DirectColor"
	};

    /*
     * Get Matrices
     */
    MatricesAtom = ParseAtom (dpy, XDCCC_MATRIX_ATOM_NAME, True);
    if (MatricesAtom != None) {
	if (_XcmsGetProperty (dpy, root, MatricesAtom, &format, &nitems,
			  &nbytes_return, &property_return) == XcmsFailure) {
	    format = 0;
	} else if (nitems != 18) {
	    printf ("Property %s had invalid length of %ld\n",
		    XDCCC_MATRIX_ATOM_NAME, nitems);
	    if (property_return) {
		XFree (property_return);
	    }
	    return;
	}
    } 
    if (MatricesAtom == None || !format) {
	printf ("Could not find property %s\n", XDCCC_MATRIX_ATOM_NAME);
    } else if (format != 32) {
	printf ("Data in property %s not in 32 bit format\n",
		XDCCC_MATRIX_ATOM_NAME);
    } else {
	pChar = property_return;
	printf ("Screen: %d\n", DefaultScreen(dpy));
	printf ("Querying property %s\n", XDCCC_MATRIX_ATOM_NAME);
	printf ("\tXYZtoRGB matrix :\n");
	for (i = 0; i < 3; i++) {
	    printf ("\t");
	    for (j = 0; j < 3; j++) {
		printf ("\t%8.5f", 
			(long)_XcmsGetElement(format, &pChar, &nitems)
			/ (XcmsFloat) XDCCC_NUMBER);
	    }
	    printf ("\n");
	}
	printf ("\tRGBtoXYZ matrix :\n");
	for (i = 0; i < 3; i++) {
	    printf ("\t");
	    for (j = 0; j < 3; j++) {
		printf ("\t%8.5f", 
			(long) _XcmsGetElement(format, &pChar, &nitems)
			/ (XcmsFloat) XDCCC_NUMBER);
	    }
	    printf ("\n");
	}
	XFree (property_return);
    }


    /*
     * Get Intensity Tables
     */
    CorrectAtom = XInternAtom (dpy, XDCCC_CORRECT_ATOM_NAME, True);
    if (CorrectAtom != None) {
	if (_XcmsGetProperty (dpy, root, CorrectAtom, &format, &nitems,
			  &nbytes_return, &property_return) == XcmsFailure) {
	    format = 0;
	} else if (nitems <= 0) {
            printf ("Property %s had invalid length of %ld\n",
		    XDCCC_CORRECT_ATOM_NAME, nitems);
	    if (property_return) {
		XFree (property_return);
	    }
	    return;
	}
    }
    if (CorrectAtom == None || !format) {
	printf ("Could not find property %s\n", XDCCC_CORRECT_ATOM_NAME);
    } else {
	printf ("\nQuerying property %s\n", XDCCC_CORRECT_ATOM_NAME);
	pChar = property_return;

	while (nitems) {
	    switch (format) {
	      case 8:
		/*
		 * Must have at least:
		 *		VisualID0
		 *		VisualID1
		 *		VisualID2
		 *		VisualID3
		 *		type
		 *		count
		 *		length
		 *		intensity1
		 *		intensity2
		 */
		if (nitems < 9) {
		    goto IntensityTblError;
		}
		count = 3;
		break;
	      case 16:
		/*
		 * Must have at least:
		 *		VisualID0
		 *		VisualID3
		 *		type
		 *		count
		 *		length
		 *		intensity1
		 *		intensity2
		 */
		if (nitems < 7) {
		    goto IntensityTblError;
		}
		count = 1;
		break;
	      case 32:
		/*
		 * Must have at least:
		 *		VisualID0
		 *		type
		 *		count
		 *		length
		 *		intensity1
		 *		intensity2
		 */
		if (nitems < 6) {
		    goto IntensityTblError;
		}
		count = 0;
		break;
	      default:
		goto IntensityTblError;
	    }

	    /*
	     * Get VisualID
	     */
	    visualID = _XcmsGetElement(format, &pChar, &nitems);
	    /* add the depth, class, and bits info in output */
	    vinfo_template.visualid = visualID;
	    vinfo_ret = XGetVisualInfo(dpy, VisualIDMask, &vinfo_template, 
				       &nvis);
	    while (count--) {
		visualID = visualID << format;
		visualID |= _XcmsGetElement(format, &pChar, &nitems);
	    }

	    if (vinfo_ret != NULL) {
		printf 
		 ("\n\tVisualID: 0x%lx class: %s depth: %d bits_per_rgb: %d\n",
		  visualID, visual_strings[vinfo_ret->class],
		  vinfo_ret->depth, vinfo_ret->bits_per_rgb);
	    }
	    else
	    printf ("\n\tVisualID: 0x%lx\n", visualID);
	    XFree(vinfo_ret);
	    cType = _XcmsGetElement(format, &pChar, &nitems);
	    printf ("\ttype: %d\n", cType);
	    nTables = _XcmsGetElement(format, &pChar, &nitems);
	    printf ("\tcount: %d\n", nTables);

	    switch (cType) {
	      case 0:
		/* Red Table should always exist */
		printf ("\tRed Conversion Table:\n");
		PrintTableType0(format, &pChar, &nitems);
		if (nTables > 1) {
		    printf ("\tGreen Conversion Table:\n");
		    PrintTableType0(format, &pChar, &nitems);
		    printf ("\tBlue Conversion Table:\n");
		    PrintTableType0(format, &pChar, &nitems);
		}
		break;
	      case 1:
		/* Red Table should always exist */
		printf ("\tRed Conversion Table:\n");
		PrintTableType1(format, &pChar, &nitems);
		if (nTables > 1) {
		    printf ("\tGreen Conversion Table:\n");
		    PrintTableType1(format, &pChar, &nitems);
		    printf ("\tBlue Conversion Table:\n");
		    PrintTableType1(format, &pChar, &nitems);
		}
	        break;
	      default:
		goto IntensityTblError;
	    }
	}    
示例#13
0
文件: sendOSC.c 项目: Angeldude/pd
static void sendOSC_sendtyped(t_sendOSC *x, t_symbol *s, int argc, t_atom *argv)
{
  char messageName[MAXPDSTRING];
  //  char *token;
  typedArg args[MAX_ARGS];
  int i;

  messageName[0] = '\0'; // empty

  if(argc>MAX_ARGS) 
  {
    post ("sendOSC: too many arguments! (max: %d)", MAX_ARGS);
	return;
  }

  // this sock needs to be larger than 0, not >= ..
  if (x->x_htmsocket > 0)
    { 
#ifdef DEBUG
    post ("sendOSC: type tags? %d", useTypeTags);
#endif 

    atom_string(&argv[0], messageName, MAXPDSTRING);
//    messageName = strtok(targv[0], ",");
    for (i = 0; i < argc-1; i++)
    {
//      token = strtok(targv[i],",");

      args[i] = ParseAtom(&argv[i+1]);
#ifdef DEBUG
      switch (args[i].type)
	  {
        case INT_osc:
          printf("cell-cont: %d\n", args[i].datum.i);
          break;
        case FLOAT_osc:
          printf("cell-cont: %f\n", args[i].datum.f);
          break;
        case STRING_osc:
          printf("cell-cont: %s\n", args[i].datum.s);
          break;
        case NOTYPE_osc:
          printf("unknown type\n");
          break;
      }
      printf("  type-id: %d\n", args[i].type);
#endif
      }
      
    if(WriteMessage(x->x_oscbuf, messageName, i, args))
	{
		post("sendOSC: usage error, write-msg failed: %s", OSC_errorMessage);
		return;
      }
      
    if(!x->x_bundle)
	{
		SendBuffer(x->x_htmsocket, x->x_oscbuf);
		OSC_initBuffer(x->x_oscbuf, SC_BUFFER_SIZE, bufferForOSCbuf);
      }
      
    }
  else post("sendOSC: not connected");
}
示例#14
0
文件: regexp.c 项目: sfraize/TemuTerm
struct Expression* ParseRepeatedExpression(const RegexpTokenType* token_stream, int* pos) {
    struct Expression * atom = NULL;
    int origpos = *pos;
    int is_greedy = 1;
    int lower_bound, upper_bound;

    atom = ParseAtom(token_stream, pos);
    if (atom == NULL) {  /* All RepeatedExpression terms start with Atom */
	goto parse_error;
    }
    switch (token_stream[*pos]) {
    case ZERO_OR_MORE: lower_bound = 0; upper_bound = INFINITY; (*pos)++; break;
    case ONE_OR_MORE:  lower_bound = 1; upper_bound = INFINITY; (*pos)++; break;
    case ZERO_OR_ONE:  lower_bound = 0; upper_bound = 1;        (*pos)++; break;
    case REPEAT_OPEN: {
	int i, upper_bound_pos;
	/* Validity check */
	for(i=*pos + 1; token_stream[i] != REPEAT_COMMA && token_stream[i] != REPEAT_CLOSE; i++) {
	    if (!isdigit(token_stream[i])) /* including == 0 */
		goto parse_error;
	}
	if (token_stream[i] == REPEAT_CLOSE) {
	    upper_bound_pos = *pos + 1;
	} else {
	    upper_bound_pos = i + 1;
	    for(i++; token_stream[i] != REPEAT_CLOSE; i++) {
		if (!isdigit(token_stream[i])) /* including == 0 */
		    goto parse_error;
	    }
	}
	lower_bound = tokens_to_nat(token_stream + *pos + 1);
	if (lower_bound == -1) {
	    goto parse_error;
	}
	if (token_stream[upper_bound_pos] == REPEAT_CLOSE) {
	    upper_bound = INFINITY;
	} else {
	    upper_bound = tokens_to_nat(token_stream + upper_bound_pos);
	    if (upper_bound == -1 || upper_bound < lower_bound) {
		goto parse_error;
	    }
	}
	(*pos) = i + 1;
	break;
    }
    default:
	/* RepeatedExpression := Atom */
	return atom;
    }
    /* Check for nongreedy mark */
    if (token_stream[*pos] == NONGREEDY_MARK) {
	is_greedy = 0;
	(*pos)++;
    }
    /* All other RepeatedExpression rules */
    { 
	struct RepeatedExpression* result =
	    malloc(sizeof(struct RepeatedExpression));
	result->base.typecode = REPEATED_EXPRESSION_TYPE;
	result->base.group_number = NO_GROUP;
	result->expression_repeated = atom;
	result->lower_bound = lower_bound;
	result->upper_bound = upper_bound;
	result->is_greedy   = is_greedy;
	return (struct Expression*)result;
    }
parse_error:
    if (atom  != NULL) destroy_expression(atom);
    *pos = origpos;
    return NULL;
}
示例#15
0
void DwRfc1521Tokenizer::ParseToken()
{
    // Assume the field body has already been extracted.  That is, we don't
    // have to watch for the end of the field body or folding.  We just
    // treat any CRs or LFs as white space.
    mTokenStart = mNextStart;
    mTokenLength = 0;
    mTkType = eTkNull;
    // Skip leading space.  Also, since control chars are not permitted
    // in atoms, skip these, too.
    while(1)
    {
        if(mTokenStart >= mString.length())
        {
            return;
        }
        if(isnotspaceorcntrl(mString[mTokenStart]))
            break;
        ++mTokenStart;
    }
    char ch = mString[mTokenStart];
    switch(ch)
    {
    // Quoted string
    case '"':
        mTkType = eTkQuotedString;
        ParseQuotedString();
        break;
    // Comment
    case '(':
        mTkType = eTkComment;
        ParseComment();
        break;
    // Domain literal
    case '[':
        mTkType = eTkDomainLiteral;
        ParseDomainLiteral();
        break;
    // Special
    case ')':
    case '<':
    case '>':
    case '@':
    case ',':
    case ';':
    case ':':
    case '\\':
    case '/':
    case ']':
    case '?':
    case '=':
        mTkType = eTkTspecial;
        mTokenLength = 1;
        mToken = mString.substr(mTokenStart, 1);
        mNextStart = mTokenStart + 1;
        break;
    default:
        mTkType = eTkToken;
        ParseAtom();
        break;
    }
    if(mDebugOut) PrintToken(mDebugOut);
}
示例#16
0
void*
NewJulie(
	Symbol*	,
	short	iArgC,
	Atom*	iArgV)
	
	{
	tJulie*	me	= NIL;
	double	z0Real	= 0.0, 
			z0Imag	= 0.0, 
			cReal	= 0.0, 
			cImag	= 0.0;
	
	// Take all initialization arguments as passed to us.
	// This is a little dull for the Julia set, but there is no "natural" alternative
	switch (iArgC) {
		default:
			error("%s: ignoring spurious arguments", kClassName);
			// fall into next case...
		case 4:
			if ( ParseAtom(iArgV + 3, false, true, 0, NIL, kClassName) )
				cImag = iArgV[3].a_w.w_float;
			// fall into next case...
		case 3:
			if ( ParseAtom(iArgV + 2, false, true, 0, NIL, kClassName) )
				cReal = iArgV[2].a_w.w_float;
			// fall into next case...
		case 2:
			if ( ParseAtom(iArgV + 1, false, true, 0, NIL, kClassName) )
				z0Imag = iArgV[1].a_w.w_float;
			// fall into next case...
		case 1:
			if ( ParseAtom(iArgV, false, true, 0, NIL, kClassName) )
				z0Real = iArgV[0].a_w.w_float;
			// fall into next case...
		case 0:
			break;
		}

	// Let Max/MSP allocate us, our inlets, and outlets.
	me = (tJulie*) newobject(gObjectClass);
		if (me == NIL) goto punt;
	
	dsp_setup(&(me->coreObject), 4);				// All four inlets accept signal vectors

	outlet_new(me, "signal");						// Two outlets (for real and imaginary
	outlet_new(me, "signal");						// components of Julia set elements)
	
	//
	// Store initial values
	//
	me->zReal		= me->z0Real
					= z0Real;
	me->zImag		= me->z0Imag
					= z0Imag;
	me->cReal		= cReal;
	me->cImag		= cImag;
	
	//
	// All done
	//
punt:
	return me;
	}
示例#17
0
static void ParseAtom( int startOffset, int stopOffset, qtmovie_t* qtmovie )
{
  long			currentOffset;

  int			containerAtom;
  int			atomSize;
  unsigned int	atomName;
  char			atomHeader[ 10 ];

  if ( g_StopParsing )
	return;

  currentOffset = startOffset;
  while ( currentOffset < stopOffset)
  {
    // Seek to the atom header
    stream_seek( qtmovie->stream, currentOffset, SEEK_SET );

	memset( atomHeader, 0, 10 );

    // Read it in.. we only want the atom name & size..	they're always there..
    stream_read( qtmovie->stream, 8, atomHeader );

    // Now pull out the bits we need..
    atomSize = ReadUnsignedInt( &atomHeader[ 0 ] );
    atomName = ReadUnsignedInt( &atomHeader[ 4 ] );

    // See if it's a container atom.. if it is, then recursively call ParseAtom on it...
    for ( containerAtom = 0; containerAtom < ( sizeof( g_ContainerAtoms ) / sizeof( unsigned int ) ); containerAtom++ )
    {
      if ( atomName == g_ContainerAtoms[ containerAtom ] )
      {
        ParseAtom( stream_tell( qtmovie->stream ), currentOffset + atomSize, qtmovie );
        break;
      }
    }

	if ( atomName == g_FtypAtomName )
	{
		void* pAtomData = GetAtomData( qtmovie, atomSize );
		ProcessFtypAtom( pAtomData, qtmovie );
		FreeAtomData( pAtomData );
	}
	else
	if ( atomName == g_StsdAtomName )
	{
		void* pAtomData = GetAtomData( qtmovie, atomSize );
		ProcessStsdAtom( pAtomData, qtmovie );
		FreeAtomData( pAtomData );
	}
	else
	if ( atomName == g_SttsAtomName )
	{
		void* pAtomData = GetAtomData( qtmovie, atomSize );
		ProcessSttsAtom( pAtomData, qtmovie );
		FreeAtomData( pAtomData );
	}
	else
	if ( atomName == g_StszAtomName )
	{
		void* pAtomData = GetAtomData( qtmovie, atomSize );
		ProcessStszAtom( pAtomData, qtmovie );
		FreeAtomData( pAtomData );
	}
	else
	if ( atomName == g_MdatAtomName )
	{
		g_FoundMdatAtom = 1;
		g_StopParsing = 1;
	}

    // If we've got a zero sized atom, then it's all over.. force the offset to trigger a stop.
    if ( atomSize == 0 )
      currentOffset = stopOffset;
    else
      currentOffset += atomSize;	
  }

  // Everything seems to have gone ok...
  return;
}
示例#18
0
文件: parse.cpp 项目: gatgui/gcore
// Atom ::= "(" Expression ")" | "[" [^] Range "]" | Characters
Instruction* ParseAtom(const char **ppc, ParseInfo &info)
{
  Instruction *i = 0;
  const char *pc = *ppc;
  
  switch (*pc)
  {
    case '(':
    {
      Group::TriState dnl = Group::Inherit;
      Group::TriState nc = Group::Inherit;
      Group::TriState ml = Group::Inherit;
      bool capture = true;
      bool consume = true;
      bool invert = false;
      bool reverse = false;
      std::string name = "";
      
      ++pc;
      
      if (*pc == '?')
      {
        ++pc;
        if (*pc == '#')
        {
          // skip everything until ) and from behave as if ParseAtom was
          // called starting next character
          ++pc;
          while (*pc != ')')
          {
            if (*pc == '\0')
            {
              return 0;
            }
            ++pc;
          }
          *ppc = ++pc;
          return ParseAtom(ppc, info);
        }
        if (*pc == ':')
        {
          capture = false;
          ++pc;
        }
        else if (*pc == '(')
        {
          // conditional
          ++pc;
          
          std::string cond;
          while (*pc != ')')
          {
            if (*pc == '\0')
            {
              return 0;
            }
            cond.push_back(*pc);
            ++pc;
          }
          ++pc;
          
          Instruction *ci = ParseExpression(&pc, info);
          if (!ci || *pc != ')')
          {
            if (ci)
            {
              delete ci;
            }
            return 0;
          }
          ++pc;
          
          Alternative *alt = dynamic_cast<Alternative*>(ci);
          Instruction *ifTrue, *ifFalse;
          if (alt == 0)
          {
            ifTrue = ci;
            ifFalse = 0;
          }
          else
          {
            ifTrue = alt->first()->clone();
            ifFalse = alt->second()->clone();
            delete alt;
          }
          
          *ppc = pc;
          int index = 0;
          if (sscanf(cond.c_str(), "%d", &index) != 1)
          {
            return new Conditional(cond, ifTrue, ifFalse);
          }
          else
          {
            return new Conditional(index, ifTrue, ifFalse);
          }
        }
        else if (*pc == 'P')
        {
          ++pc;
          if (*pc == '<')
          {
            ++pc;
            while (*pc != '>')
            {
              if (*pc == '\0')
              {
                return 0;
              }
              name.push_back(*pc);
              ++pc;
            }
            ++pc;
          }
          else if (*pc == '=')
          {
            std::string name;
            ++pc;
            while (*pc != ')')
            {
              if (*pc == '\0')
              {
                return 0;
              }
              name.push_back(*pc);
              ++pc;
            }
            ++pc;
            *ppc = pc;
            return new Backsubst(name);
          }
          else
          {
            return 0;
          }
        }
        else if (*pc == '=')
        {
          // positive lookahead
          capture = false;
          consume = false;
          ++pc;
        }
        else if (*pc == '!')
        {
          // negative lookahead
          capture = false;
          consume = false;
          invert = true;
          ++pc;
        }
        else if (*pc == '<')
        {
          ++pc;
          if (*pc == '=')
          {
            // positive lookbehind
            capture = false;
            consume = false;
            reverse = true;
            ++pc;
          }
          else if (*pc == '!')
          {
            // negative lookbehind
            capture = false;
            consume = false;
            reverse = true;
            invert = true;
            ++pc;
          }
          else
          {
            Log::PrintError("[gcore] rex/ParseAtom: Invalid group format");
            return 0;
          }
        }
        else if (*pc == 'i' || *pc == 'm' || *pc == 's' || *pc == '-')
        {
          //capture = false;
          //consume = false;
          if (*pc == 'i')
          {
            // case sensitive off
            nc = Group::On;
            ++pc;
          }
          if (*pc == 'm')
          {
            // multiline on (. matches \r\n)
            ml = Group::On;
            ++pc;
          }
          if (*pc == 's')
          {
            // dot matches new line on
            dnl = Group::On;
            ++pc;
          }
          if (*pc == '-')
          {
            ++pc;
            if (*pc == 'i')
            {
              // case sensitive on
              nc = Group::Off;
              ++pc;
            }
            if (*pc == 'm')
            {
              // multiline off
              ml = Group::Off;
              ++pc;
            }
            if (*pc == 's')
            {
              // dot matches newline off
              dnl = Group::Off;
              ++pc;
            }
          }
          if (*pc != ':' && *pc != ')')
          {
            // either followed by : or group end (meaning we just want to change exp exec flags)
            Log::PrintError("[gcore] rex/ParseAtom: Invalid group format");
            return 0;
          }
          
          if (*pc == ':')
          {
            ++pc;
            // would having a closing parent here be problematic
          }
          else
          {
            capture = false;
            consume = false;
          }
        }
      }
      
      int gidx = (capture ? (++(info.numGroups)) : -1);
      unsigned short flags = (unsigned short)(reverse ? Rex::Reverse : 0);
      
      if (*pc != ')')
      {
        i = ParseExpression(&pc, info);
      }

      if (*pc != ')')
      {
        if (i)
        {
          delete i;
        }
        return 0;
      }
      
#ifdef _DEBUG_REX
      Log::PrintDebug("[gcore] rex/ParseAtom: Create group");
      Log::SetIndentLevel(Log::GetIndentLevel()+1);
      Log::PrintDebug("index: %d", gidx);
      Log::PrintDebug("invert: %d", invert);
      Log::PrintDebug("consume: %d", consume);
      Log::PrintDebug("flags: %d", flags);
      Log::PrintDebug("nc: %d", nc);
      Log::PrintDebug("ml: %d", ml);
      Log::PrintDebug("dnl: %d", dnl);
      Log::PrintDebug("name: %d", name.c_str());
      Log::PrintDebug("code: ");
      if (i)
      {
        std::ostringstream oss;
        
        Log::SetIndentLevel(Log::GetIndentLevel()+1)
        i->toStream(oss);
        Log::PrintDebug(oss.str().c_str());
        Log::SetIndentLevel(Log::GetIndentLevel()-1)
      }
      Log::SetIndentLevel(Log::GetIndentLevel()-1);
#endif
      
      i = new Group(gidx, i, !consume, invert, flags, nc, ml, dnl, name);
      
#ifdef _DEBUG_REX
      Log::PrintDebug("[gcore] rex/ParseAtom: Group created");
#endif
      ++pc;
      
      break;
    }
    case '[':
    {
      bool inv = false;
      ++pc;
      if (*pc == '^')
      {
        inv = true;
        ++pc;
      }
      i = ParseRange(&pc, inv, info);
      if (!i)
      {
        return 0;
      }
      if (*pc != ']')
      {
        Log::PrintError("[gcore] rex/ParseAtom: Invalid character '%c' in expression, expected ']'", *pc);
        if (i)
        {
          delete i;
        }
        return 0;
      }
      ++pc;
      break;
    }
    default:
      i = ParseCharacters(&pc, info);
      if (!i)
      {
        i = ParseZerowidth(&pc, info);
        if (!i)
        {
          return 0;
        }
      }
  }
  *ppc = pc;
  return i;
}