Lines Matching full:foffset
168 return std::unique_ptr<Extension>(new Extension(extension.fOffset, extension.fName));
189 return std::unique_ptr<Block>(new Block(statement.fOffset,
230 return std::unique_ptr<Block>(new Block(block.fOffset, std::move(statements), fSymbolTable));
263 fErrors.error(size->fOffset, "array size must be positive");
279 auto var = std::unique_ptr<Variable>(new Variable(decl.fOffset, decl.fModifiers,
311 return std::unique_ptr<VarDeclarations>(new VarDeclarations(decl.fOffset,
364 return std::unique_ptr<Statement>(new Block(s.fOffset, std::move(empty),
368 return std::unique_ptr<Statement>(new IfStatement(s.fOffset, s.fIsStatic, std::move(test),
401 return std::unique_ptr<Statement>(new ForStatement(f.fOffset, std::move(initializer),
417 return std::unique_ptr<Statement>(new WhileStatement(w.fOffset, std::move(test),
432 return std::unique_ptr<Statement>(new DoStatement(d.fOffset
463 fErrors.error(caseValue->fOffset, "case value must be a constant");
469 fErrors.error(caseValue->fOffset, "duplicate case value");
481 cases.emplace_back(new SwitchCase(c->fOffset, std::move(caseValue),
484 return std::unique_ptr<Statement>(new SwitchStatement(s.fOffset, s.fIsStatic,
511 fErrors.error(result->fOffset, "may not return a value from a void function");
521 fErrors.error(r.fOffset, "expected function to return '" +
524 return std::unique_ptr<Statement>(new ReturnStatement(r.fOffset));
530 return std::unique_ptr<Statement>(new BreakStatement(b.fOffset));
532 fErrors.error(b.fOffset, "break statement must be inside a loop or switch");
539 return std::unique_ptr<Statement>(new ContinueStatement(c.fOffset));
541 fErrors.error(c.fOffset, "continue statement must be inside a loop");
547 return std::unique_ptr<Statement>(new DiscardStatement(d.fOffset));
661 Variable* var = new Variable(param->fOffset, param->fModifiers, name, *type,
680 fErrors.error(f.fOffset, "symbol '" + f.fName + "' was already defined");
695 FunctionDeclaration newDecl(f.fOffset, f.fModifiers, f.fName, parameters,
697 fErrors.error(f.fOffset, "functions '" + newDecl.description() +
705 fErrors.error(f.fOffset, "modifiers on parameter " +
713 fErrors.error(f.fOffset, "duplicate definition of " +
723 auto newDecl = std::unique_ptr<FunctionDeclaration>(new FunctionDeclaration(f.fOffset,
762 new FunctionDefinition(f.fOffset, *decl, std::move(body))));
782 fErrors.error(decl->fOffset,
794 fErrors.error(decl->fOffset,
802 fErrors.error(decl->fOffset,
811 Type* type = new Type(intf.fOffset, intf.fTypeName, fields);
825 fErrors.error(converted->fOffset, "array size must be positive");
841 Variable* var = new Variable(intf.fOffset, intf.fModifiers,
852 old->add(fields[i].fName, std::unique_ptr<Field>(new Field(intf.fOffset, *var,
860 return std::unique_ptr<InterfaceBlock>(new InterfaceBlock(intf.fOffset,
882 fErrors.error(value.fOffset, "expected a constant int");
890 ASTType enumType(e.fOffset, e.fTypeName, ASTType::kIdentifier_Kind, {});
905 value = std::unique_ptr<Expression>(new IntLiteral(fContext, e.fOffset, currentValue));
907 auto var = std::unique_ptr<Variable>(new Variable(e.fOffset, modifiers, e.fNames[i],
914 fProgramElements->push_back(std::unique_ptr<ProgramElement>(new Enum(e.fOffset, e.fTypeName,
934 fErrors.error(type.fOffset, "unknown type '" + type.fName + "'");
943 return std::unique_ptr<Expression>(new BoolLiteral(fContext, expr.fOffset,
946 return std::unique_ptr<Expression>(new IntLiteral(fContext, expr.fOffset,
949 return std::unique_ptr<Expression>(new FloatLiteral(fContext, expr.fOffset,
967 fErrors.error(identifier.fOffset, "unknown identifier '" + identifier.fText + "'");
976 identifier.fOffset,
982 identifier.fOffset,
999 identifier.fOffset,
1005 VariableReference* base = new VariableReference(identifier.fOffset, field->fOwner,
1014 return std::unique_ptr<TypeReference>(new TypeReference(fContext, identifier.fOffset,
1023 return std::unique_ptr<Section>(new Section(s.fOffset, s.fName, s.fArgument, s.fText));
1040 fErrors.error(expr->fOffset, "expected '" + type.description() + "', but found '" +
1257 return std::unique_ptr<Expression>(new BoolLiteral(fContext, left.fOffset, result));
1259 #define RESULT(t, op) std::unique_ptr<Expression>(new t ## Literal(fContext, left.fOffset, \
1272 fErrors.error(right.fOffset, "division by zero");
1278 fErrors.error(right.fOffset, "division by zero");
1306 fErrors.error(right.fOffset, "division by zero");
1391 fErrors.error(expression.fOffset, String("type mismatch: '") +
1408 result = std::unique_ptr<Expression>(new BinaryExpression(expression.fOffset,
1437 fErrors.error(expression.fOffset, "ternary operator result mismatch: '" +
1458 return std::unique_ptr<Expression>(new TernaryExpression(expression.fOffset,
1753 fErrors.error(expression.fOffset,
1760 fErrors.error(expression.fOffset,
1765 return std::unique_ptr<Expression>(new IntLiteral(fContext, base->fOffset,
1770 return std::unique_ptr<Expression>(new FloatLiteral(fContext, base->fOffset,
1776 fErrors.error(expression.fOffset,
1785 fErrors.error(expression.fOffset,
1794 fErrors.error(expression.fOffset,
1800 return std::unique_ptr<Expression>(new BoolLiteral(fContext, base->fOffset,
1806 fErrors.error(expression.fOffset,
1828 return std::unique_ptr<Expression>(new TypeReference(fContext, base->fOffset,
1832 fErrors.error(base->fOffset, "array size must be a constant");
1838 fErrors.error(base->fOffset, "expected array, but found '" + base->fType.description() +
1864 fErrors.error(base->fOffset, "type '" + base->fType.description() + "' does not have a "
1872 fErrors.error(base->fOffset, "cannot swizzle type '" + base->fType.description() + "'");
1908 fErrors.error(base->fOffset, String::printf("invalid swizzle component '%c'",
1915 fErrors.error(base->fOffset, "too many components in swizzle mask '" + fields + "'");
1978 return std::unique_ptr<Expression>(new TypeReference(fContext, base->fOffset,
1981 fErrors.error(expression.fOffset, "'[]' must follow a type name");
1996 return this->call(expression.fOffset, std::move(base), std::move(arguments));
2001 return this->getCap(expression.fOffset, field);
2004 return this->getArg(expression.fOffset, field);
2007 return this->convertTypeField(base->fOffset, ((TypeReference&) *base).fValue,
2016 fErrors.error(base->fOffset, "cannot swizzle value of type '" +
2023 fErrors.error(expression.fOffset,
2032 fErrors.error(expression.fOffset,
2047 fErrors.error(expr.fOffset, "expected '(' to begin function call");
2050 fErrors.error(expr.fOffset, "expected '(' to begin constructor invocation");
2054 fErrors.error(expr.fOffset, "invalid expression");
2077 fErrors.error(expr.fOffset,
2089 fErrors.error(expr.fOffset,
2104 fErrors.error(expr.fOffset, "cannot assign to '" + expr.description() + "'");
