Lines Matching full:foffset
164 return std::unique_ptr<Extension>(new Extension(extension.fOffset, extension.fName));
185 return std::unique_ptr<Block>(new Block(statement.fOffset,
226 return std::unique_ptr<Block>(new Block(block.fOffset, std::move(statements), fSymbolTable));
259 fErrors.error(size->fOffset, "array size must be positive");
275 auto var = std::unique_ptr<Variable>(new Variable(decl.fOffset, decl.fModifiers,
310 return std::unique_ptr<VarDeclarations>(new VarDeclarations(decl.fOffset,
363 return std::unique_ptr<Statement>(new Block(s.fOffset, std::move(empty),
367 return std::unique_ptr<Statement>(new IfStatement(s.fOffset, s.fIsStatic, std::move(test),
400 return std::unique_ptr<Statement>(new ForStatement(f.fOffset, std::move(initializer),
416 return std::unique_ptr<Statement>(new WhileStatement(w.fOffset, std::move(test),
431 return std::unique_ptr<Statement>(new DoStatement(d.fOffset, std::move(statement),
462 fErrors.error(caseValue->fOffset, "case value must be a constant");
468 fErrors.error(caseValue->fOffset, "duplicate case value");
480 cases.emplace_back(new SwitchCase(c->fOffset, std::move(caseValue),
483 return std::unique_ptr<Statement>(new SwitchStatement(s.fOffset, s.fIsStatic,
510 fErrors.error(result->fOffset, "may not return a value from a void function");
520 fErrors.error(r.fOffset, "expected function to return '" +
523 return std::unique_ptr<Statement>(new ReturnStatement(r.fOffset));
529 return std::unique_ptr<Statement>(new BreakStatement(b.fOffset));
531 fErrors.error(b.fOffset, "break statement must be inside a loop or switch");
538 return std::unique_ptr<Statement>(new ContinueStatement(c.fOffset));
540 fErrors.error(c.fOffset, "continue statement must be inside a loop");
546 return std::unique_ptr<Statement>(new DiscardStatement(d.fOffset));
660 Variable* var = new Variable(param->fOffset, param->fModifiers, name, *type,
679 fErrors.error(f.fOffset, "symbol '" + f.fName + "' was already defined");
694 FunctionDeclaration newDecl(f.fOffset, f.fModifiers, f.fName, parameters,
696 fErrors.error(f.fOffset, "functions '" + newDecl.description() +
704 fErrors.error(f.fOffset, "modifiers on parameter " +
712 fErrors.error(f.fOffset, "duplicate definition of " +
722 auto newDecl = std::unique_ptr<FunctionDeclaration>(new FunctionDeclaration(f.fOffset,
761 fOffset, *decl, std::move(body))));
782 fErrors.error(decl->fOffset,
794 fErrors.error(decl->fOffset,
802 fErrors.error(decl->fOffset,
812 Type* type = new Type(intf.fOffset, intf.fTypeName, fields);
826 fErrors.error(converted->fOffset, "array size must be positive");
842 Variable* var = new Variable(intf.fOffset, intf.fModifiers,
853 old->add(fields[i].fName, std::unique_ptr<Field>(new Field(intf.fOffset, *var,
861 return std::unique_ptr<InterfaceBlock>(new InterfaceBlock(intf.fOffset,
883 fErrors.error(value.fOffset, "expected a constant int");
891 ASTType enumType(e.fOffset, e.fTypeName, ASTType::kIdentifier_Kind, {});
906 value = std::unique_ptr<Expression>(new IntLiteral(fContext, e.fOffset, currentValue));
908 auto var = std::unique_ptr<Variable>(new Variable(e.fOffset, modifiers, e.fNames[i],
915 fProgramElements->push_back(std::unique_ptr<ProgramElement>(new Enum(e.fOffset, e.fTypeName,
935 fErrors.error(type.fOffset, "unknown type '" + type.fName + "'");
944 return std::unique_ptr<Expression>(new BoolLiteral(fContext, expr.fOffset,
947 return std::unique_ptr<Expression>(new IntLiteral(fContext, expr.fOffset,
950 return std::unique_ptr<Expression>(new FloatLiteral(fContext, expr.fOffset,
968 fErrors.error(identifier.fOffset, "unknown identifier '" + identifier.fText + "'");
977 identifier.fOffset,
983 identifier.fOffset,
1000 identifier.fOffset,
1006 VariableReference* base = new VariableReference(identifier.fOffset, field->fOwner,
1015 return std::unique_ptr<TypeReference>(new TypeReference(fContext, identifier.fOffset,
1024 return std::unique_ptr<Section>(new Section(s.fOffset, s.fName, s.fArgument, s.fText));
1041 fErrors.error(expr->fOffset, "expected '" + type.description() + "', but found '" +
1258 return std::unique_ptr<Expression>(new BoolLiteral(fContext, left.fOffset, result));
1260 #define RESULT(t, op) std::unique_ptr<Expression>(new t ## Literal(fContext, left.fOffset, \
1273 fErrors.error(right.fOffset, "division by zero");
1279 fErrors.error(right.fOffset, "division by zero");
1307 fErrors.error(right.fOffset, "division by zero");
1392 fErrors.error(expression.fOffset, String("type mismatch: '") +
1409 result = std::unique_ptr<Expression>(new BinaryExpression(expression.fOffset,
1438 fErrors.error(expression.fOffset, "ternary operator result mismatch: '" +
1459 return std::unique_ptr<Expression>(new TernaryExpression(expression.fOffset,
1754 fErrors.error(expression.fOffset,
1761 fErrors.error(expression.fOffset,
1766 return std::unique_ptr<Expression>(new IntLiteral(fContext, base->fOffset,
1771 return std::unique_ptr<Expression>(new FloatLiteral(fContext, base->fOffset,
1777 fErrors.error(expression.fOffset,
1786 fErrors.error(expression.fOffset,
1795 fErrors.error(expression.fOffset,
1801 return std::unique_ptr<Expression>(new BoolLiteral(fContext, base->fOffset,
1807 fErrors.error(expression.fOffset,
1829 return std::unique_ptr<Expression>(new TypeReference(fContext, base->fOffset,
1833 fErrors.error(base->fOffset, "array size must be a constant");
1839 fErrors.error(base->fOffset, "expected array, but found '" + base->fType.description() +
1865 fErrors.error(base->fOffset, "type '" + base->fType.description() + "' does not have a "
1873 fErrors.error(base->fOffset, "cannot swizzle type '" + base->fType.description() + "'");
1909 fErrors.error(base->fOffset, String::printf("invalid swizzle component '%c'",
1916 fErrors.error(base->fOffset, "too many components in swizzle mask '" + fields + "'");
1979 return std::unique_ptr<Expression>(new TypeReference(fContext, base->fOffset,
1982 fErrors.error(expression.fOffset, "'[]' must follow a type name");
1997 return this->call(expression.fOffset, std::move(base), std::move(arguments));
2002 return this->getCap(expression.fOffset, field);
2005 return this->getArg(expression.fOffset, field);
2008 return this->convertTypeField(base->fOffset, ((TypeReference&) *base).fValue,
2017 fErrors.error(base->fOffset, "cannot swizzle value of type '" +
2024 fErrors.error(expression.fOffset,
2033 fErrors.error(expression.fOffset,
2048 fErrors.error(expr.fOffset, "expected '(' to begin function call");
2051 fErrors.error(expr.fOffset, "expected '(' to begin constructor invocation");
2055 fErrors.error(expr.fOffset, "invalid expression");
2078 fErrors.error(expr.fOffset,
2090 fErrors.error(expr.fOffset,
2105 fErrors.error(expr.fOffset, "cannot assign to '" + expr.description() + "'");
