///////////////////////////////////////////////////////////////////////
// Class : CRenderer
// Method : declareDisplayChannel
// Description : Define a new displayChannel
// Return Value : The new display channel, NULL otherwise
// Comments :
CDisplayChannel *CRenderer::declareDisplayChannel(const char *type) {
CDisplayChannel *oChannel;
CVariable cVariable,*oVariable;
assert(declaredChannels != NULL);
if (parseVariable(&cVariable,NULL,type) == FALSE) {
return NULL;
}
if (declaredChannels->find(cVariable.name,oChannel) == TRUE) {
if ((oChannel->numSamples == cVariable.numFloats) &&
((cVariable.storage != STORAGE_GLOBAL) || oChannel->outType == cVariable.entry)) {
return oChannel;
} else {
error(CODE_SYSTEM,"Channel \"%s\" was previously defined differently\n",cVariable.name);
return NULL;
}
} else {
oVariable = declareVariable(NULL,type);
if (oVariable == NULL) {
error(CODE_SYSTEM,"Channel definition \"%s\" is ill formed\n",type);
} else {
const int samples = oVariable->numFloats;
const int outType = (oVariable->storage == STORAGE_GLOBAL) ? oVariable->entry : -1;
oChannel = new CDisplayChannel(oVariable->name,oVariable,samples,-1,outType);
declaredChannels->insert(oChannel->name,oChannel);
displayChannels->push(oChannel);
return oChannel;
}
}
return NULL;
}
string GarbledClassConstructor:: toString(int n)
{
string output = "";
output += declareVariable(n);
output += declareConstruction(n);
return output;
}
void Compiler::declareClass(DefClassExpr& classExpr, Module* module)
{
declareVariable(classExpr.pos(), classExpr.name(), module);
// Native classes have no fields or synthesized members.
if (classExpr.isNative()) return;
// Synthesize the constructor and field accessors.
Array<gc<DefExpr> > synthesizedMethods;
synthesizedMethods.add(synthesizeConstructor(classExpr));
// Create getters and setters for fields.
for (int i = 0; i < classExpr.fields().count(); i++)
{
synthesizedMethods.add(synthesizeGetter(classExpr, i));
if (classExpr.fields()[i]->isMutable())
{
synthesizedMethods.add(synthesizeSetter(classExpr, i));
}
}
// TODO(bob): Stuffing this back in the AST is a bit gross. An intermediate
// representation would help here.
classExpr.setSynthesizedMethods(synthesizedMethods);
// Declare the automatically-generated methods.
for (int i = 0; i < synthesizedMethods.count(); i++)
{
declareMultimethod(SignatureBuilder::build(*synthesizedMethods[i]));
}
}
bool findPassedParam(const string_type& name)
{
typename ScopeStack::reverse_iterator p = params_.rbegin()+1;
typename Scope::iterator i = p->find(name);
if(i == p->end())
return false;
declareVariable(i->second);
return true;
} // findPassedParam
void FunctionStatement::init(void *parser, bool ref,
const vector<ParameterPtr> ¶ms,
StatementListStatementPtr body,
bool has_call_to_get_args) {
m_ref = ref;
m_params = params;
m_body = body;
m_hasCallToGetArgs = has_call_to_get_args;
const CallInfo* cit1;
void* vt1;
if (get_call_info_no_eval(cit1, vt1, m_name)) {
m_invalid =
get_call_info_builtin(cit1, vt1, m_name->data(), m_name->hash()) ? -1 : 1;
}
bool seenOptional = false;
set<string> names;
m_callInfo.m_argCount = m_closureCallInfo.m_argCount = m_params.size();
for (unsigned int i = 0; i < m_params.size(); i++) {
ParameterPtr param = m_params[i];
std::string name = param->name();
if (names.find(name) != names.end()) {
raise_notice("%s:%d %s() has 2 parameters with the same name: $%s",
m_loc.file, m_loc.line0, m_name.c_str(), name.c_str());
} else {
names.insert(name);
}
if (!seenOptional) {
if (param->isOptional()) {
seenOptional = true;
}
} else if (!param->isOptional()) {
/*
raise_notice("%s:%d %s() has required parameter after optional one: $%s",
m_loc.file, m_loc.line0, m_name.c_str(), name.c_str());
*/
param->addNullDefault(parser);
}
if (param->isRef()) {
m_callInfo.m_refFlags |= 1 << i;
m_closureCallInfo.m_refFlags |= 1 << i;
}
if (param->getIdx() == -1) {
param->setIdx(declareVariable(name));
}
}
}
void Compiler::declareVariables(gc<Pattern> pattern, Module* module)
{
RecordPattern* record = pattern->asRecordPattern();
if (record != NULL)
{
for (int i = 0; i < record->fields().count(); i++)
{
declareVariables(record->fields()[i].value, module);
}
return;
}
VariablePattern* variable = pattern->asVariablePattern();
if (variable != NULL)
{
declareVariable(variable->pos(), variable->name(), module);
if (!variable->pattern().isNull())
{
declareVariables(variable->pattern(), module);
}
}
}
///////////////////////////////////////////////////////////////////////
// Class : CRenderer
// Method : initDeclarations
// Description : Init the declarations
// Return Value :
// Comments :
void CRenderer::initDeclarations() {
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// A L L O C A T E M E M O R Y
//
//
////////////////////////////////////////////////////////////////////////////////////////////
// Init the coordinate systems
definedCoordinateSystems = new CTrie<CNamedCoordinateSystem *>;
// Init the declared variables
declaredVariables = new CTrie<CVariable *>;
// Allocate the global variables array
globalVariables = new CArray<CVariable *>;
// This is the list of all variables
variables = NULL;
// Allocate the space for default display channels
declaredChannels = new CTrie<CDisplayChannel*>;
displayChannels = new CArray<CDisplayChannel*>;
// Zero is reserved as an invalid value
numKnownGlobalIds = 1;
// Global Ids
globalIdHash = new CTrie<CGlobalIdentifier *>;
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// R E G I S T E R O P T I O N S / A T T R I B U T E S
//
//
////////////////////////////////////////////////////////////////////////////////////////////
// Define the options
declareVariable(RI_ARCHIVE, "string");
declareVariable(RI_PROCEDURAL, "string");
declareVariable(RI_TEXTURE, "string");
declareVariable(RI_SHADER, "string");
declareVariable(RI_DISPLAY, "string");
declareVariable(RI_RESOURCE, "string");
declareVariable(RI_BUCKETSIZE, "int[2]");
declareVariable(RI_METABUCKETS, "int[2]");
declareVariable(RI_INHERITATTRIBUTES, "int");
declareVariable(RI_GRIDSIZE, "int");
declareVariable(RI_EYESPLITS, "int");
declareVariable(RI_TEXTUREMEMORY, "int");
declareVariable(RI_BRICKMEMORY, "int");
declareVariable(RI_NUMTHREADS, "int");
declareVariable(RI_THREADSTRIDE, "int");
declareVariable(RI_GEOCACHEMEMORY, "int");
declareVariable(RI_OTHRESHOLD, "color");
declareVariable(RI_ZTHRESHOLD, "color");
declareVariable(RI_RADIANCECACHE, "int");
declareVariable(RI_JITTER, "float");
declareVariable(RI_FALSECOLOR, "int");
declareVariable(RI_EMIT, "int");
declareVariable(RI_SAMPLESPECTRUM, "int");
declareVariable(RI_DEPTHFILTER, "string");
declareVariable(RI_MAXDEPTH, "int");
declareVariable(RI_ENDOFFRAME, "int");
declareVariable(RI_FILELOG, "string");
declareVariable(RI_PROGRESS, "int");
// File display variables
declareVariable("quantize", "float[4]");
declareVariable("dither", "float");
declareVariable("gamma", "float");
declareVariable("gain", "float");
declareVariable("near", "float");
declareVariable("far", "float");
declareVariable("Software", "string");
declareVariable("compression", "string");
declareVariable("NP", "float[16]");
declareVariable("Nl", "float[16]");
// Define the attributes
declareVariable(RI_NUMPROBES, "int[2]");
declareVariable(RI_MINSUBDIVISION, "int");
declareVariable(RI_MAXSUBDIVISION, "int");
declareVariable(RI_MINSPLITS, "int");
declareVariable(RI_BOUNDEXPAND, "float");
declareVariable(RI_BINARY, "int");
declareVariable(RI_RASTERORIENT, "int");
declareVariable(RI_SPHERE, "float");
declareVariable(RI_COORDINATESYSYTEM, "string");
declareVariable(RI_DISPLACEMENTS, "int");
declareVariable(RI_BIAS, "float");
declareVariable(RI_MAXDIFFUSEDEPTH, "int");
declareVariable(RI_MAXSPECULARDEPTH, "int");
declareVariable(RI_SAMPLEMOTION, "int");
declareVariable(RI_HANDLE, "string");
declareVariable(RI_FILEMODE, "string");
declareVariable(RI_MAXERROR, "float");
declareVariable(RI_MAXPIXELDIST, "float");
declareVariable(RI_GLOBALMAP, "string");
declareVariable(RI_CAUSTICMAP, "string");
declareVariable(RI_SHADINGMODEL, "string");
declareVariable(RI_ESTIMATOR, "int");
declareVariable(RI_ILLUMINATEFRONT, "int");
declareVariable(RI_TRANSMISSION, "int");
declareVariable(RI_CAMERA, "int");
declareVariable(RI_SPECULAR, "int");
declareVariable(RI_DIFFUSE, "int");
declareVariable(RI_PHOTON, "int");
declareVariable(RI_DIFFUSEHITMODE, "string");
declareVariable(RI_SPECULARHITMODE, "string");
declareVariable(RI_TRANSMISSIONHITMODE, "string");
declareVariable(RI_CAMERAHITMODE, "string");
declareVariable(RI_NAME, "string");
declareVariable(RI_HIDDEN, "int");
declareVariable(RI_BACKFACING, "int");
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// R E G I S T E R D E F A U L T V A R I A B L E S
//
//
////////////////////////////////////////////////////////////////////////////////////////////
CVariable *tmp;
tmp = declareVariable("P", "global vertex point",PARAMETER_P); assert(tmp->entry == VARIABLE_P);
tmp = declareVariable("Ps", "global vertex point",PARAMETER_PS); assert(tmp->entry == VARIABLE_PS);
tmp = declareVariable("N", "global varying normal",PARAMETER_N); assert(tmp->entry == VARIABLE_N);
tmp = declareVariable("Ng", "global varying normal",PARAMETER_NG); assert(tmp->entry == VARIABLE_NG);
tmp = declareVariable("dPdu", "global vertex vector",PARAMETER_DPDU); assert(tmp->entry == VARIABLE_DPDU);
tmp = declareVariable("dPdv", "global vertex vector",PARAMETER_DPDV); assert(tmp->entry == VARIABLE_DPDV);
tmp = declareVariable("L", "global varying vector",PARAMETER_L); assert(tmp->entry == VARIABLE_L);
tmp = declareVariable("Cs", "global varying color",PARAMETER_CS); assert(tmp->entry == VARIABLE_CS);
tmp = declareVariable("Os", "global varying color",PARAMETER_OS); assert(tmp->entry == VARIABLE_OS);
tmp = declareVariable("Cl", "global varying color",PARAMETER_CL); assert(tmp->entry == VARIABLE_CL);
tmp = declareVariable("Ol", "global varying color",PARAMETER_OL); assert(tmp->entry == VARIABLE_OL);
tmp = declareVariable("Ci", "global varying color",PARAMETER_CI); assert(tmp->entry == VARIABLE_CI);
tmp = declareVariable("Oi", "global varying color",PARAMETER_OI); assert(tmp->entry == VARIABLE_OI);
tmp = declareVariable("s", "global varying float",PARAMETER_S); assert(tmp->entry == VARIABLE_S);
tmp = declareVariable("t", "global varying float",PARAMETER_T); assert(tmp->entry == VARIABLE_T);
tmp = declareVariable("st", "varying float[2]",PARAMETER_S | PARAMETER_T);
tmp = declareVariable("du", "global varying float",PARAMETER_DU | PARAMETER_DERIVATIVE); assert(tmp->entry == VARIABLE_DU);
tmp = declareVariable("dv", "global varying float",PARAMETER_DV | PARAMETER_DERIVATIVE); assert(tmp->entry == VARIABLE_DV);
tmp = declareVariable("u", "global varying float",PARAMETER_U); assert(tmp->entry == VARIABLE_U);
tmp = declareVariable("v", "global varying float",PARAMETER_V); assert(tmp->entry == VARIABLE_V);
tmp = declareVariable("I", "global varying vector",PARAMETER_I); assert(tmp->entry == VARIABLE_I);
tmp = declareVariable("E", "global varying point",PARAMETER_E); assert(tmp->entry == VARIABLE_E);
tmp = declareVariable("alpha","global varying float",PARAMETER_ALPHA); assert(tmp->entry == VARIABLE_ALPHA);
tmp = declareVariable("time", "global varying float",PARAMETER_TIME); assert(tmp->entry == VARIABLE_TIME);
tmp = declareVariable("Pw", "global vertex htpoint",PARAMETER_P); tmp->entry = VARIABLE_PW;
tmp = declareVariable("Pz", "vertex float",PARAMETER_P); tmp->entry = VARIABLE_P;
tmp = declareVariable("ncomps","global uniform float",PARAMETER_NCOMPS); assert(tmp->entry == VARIABLE_NCOMPS);
tmp = declareVariable("dtime","global uniform float",PARAMETER_DTIME); assert(tmp->entry == VARIABLE_DTIME);
tmp = declareVariable("dPdtime","global varying vector",PARAMETER_DPDTIME);assert(tmp->entry == VARIABLE_DPDTIME);
tmp = declareVariable("width","global varying float",0); assert(tmp->entry == VARIABLE_WIDTH);
tmp = declareVariable("constantwidth","global constant float",0); assert(tmp->entry == VARIABLE_CONSTANTWIDTH);
tmp = declareVariable("Np","uniform normal",PARAMETER_NG);
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// R E G I S T E R D E F A U L T D I S P L A Y C H A N N E L S
//
//
////////////////////////////////////////////////////////////////////////////////////////////
CDisplayChannel *tmp2;
tmp2 = new CDisplayChannel("rgb",NULL,3,0);
displayChannels->push(tmp2);
declaredChannels->insert(tmp2->name,tmp2);
tmp2 = new CDisplayChannel("rgba",NULL,4,0);
displayChannels->push(tmp2);
declaredChannels->insert(tmp2->name,tmp2);
tmp2 = new CDisplayChannel("a",NULL,1,3);
displayChannels->push(tmp2);
declaredChannels->insert(tmp2->name,tmp2);
tmp2 = new CDisplayChannel("z",NULL,1,4);
displayChannels->push(tmp2);
declaredChannels->insert(tmp2->name,tmp2);
tmp2 = new CDisplayChannel("rgbaz",NULL,5,0);
displayChannels->push(tmp2);
declaredChannels->insert(tmp2->name,tmp2);
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// R E G I S T E R D E F A U L T C O O R D I N A T E S Y S T E M S
//
//
////////////////////////////////////////////////////////////////////////////////////////////
defineCoordinateSystem(coordinateCameraSystem,identityMatrix,identityMatrix,COORDINATE_CAMERA);
defineCoordinateSystem(coordinateWorldSystem,identityMatrix,identityMatrix,COORDINATE_WORLD);
defineCoordinateSystem(coordinateObjectSystem,identityMatrix,identityMatrix,COORDINATE_OBJECT);
defineCoordinateSystem(coordinateShaderSystem,identityMatrix,identityMatrix,COORDINATE_SHADER);
defineCoordinateSystem(coordinateLightSystem,identityMatrix,identityMatrix,COORDINATE_LIGHT);
defineCoordinateSystem(coordinateNDCSystem,identityMatrix,identityMatrix,COORDINATE_NDC);
defineCoordinateSystem(coordinateRasterSystem,identityMatrix,identityMatrix,COORDINATE_RASTER);
defineCoordinateSystem(coordinateScreenSystem,identityMatrix,identityMatrix,COORDINATE_SCREEN);
defineCoordinateSystem(coordinateCurrentSystem,identityMatrix,identityMatrix,COORDINATE_CURRENT);
// Define the default color systems
defineCoordinateSystem(colorRgbSystem,identityMatrix,identityMatrix,COLOR_RGB);
defineCoordinateSystem(colorHslSystem,identityMatrix,identityMatrix,COLOR_HSL);
defineCoordinateSystem(colorHsvSystem,identityMatrix,identityMatrix,COLOR_HSV);
defineCoordinateSystem(colorXyzSystem,identityMatrix,identityMatrix,COLOR_XYZ);
defineCoordinateSystem(colorCieSystem,identityMatrix,identityMatrix,COLOR_CIE);
defineCoordinateSystem(colorYiqSystem,identityMatrix,identityMatrix,COLOR_YIQ);
defineCoordinateSystem(colorXyySystem,identityMatrix,identityMatrix,COLOR_XYY);
}
void declareParam(Variable_instance_ptr param)
{
declareVariable(param);
} // declareParam
int main(){
freopen("lexer_output.txt", "r", stdin);
trieRoot = createNewTrieNode();
if(trieRoot == NULL){
perror("Could not create root node!!\n");
return 0;
}
envTop = NULL;
currentScope = totalVariables = 0;
addScope();
token t;
while(scanf("%d%d", &t.iden, &t.line) != EOF){
fgets(t.value, 1000, stdin);
int len = strlen(t.value);
t.value[len-1] = '\0';
if(t.value[0] == '-') t.value[0] = '\0';
t.line++;
lexemeStream[stream_size++] = t;
}
// int zz;
// for(zz=0;zz<stream_size;zz++)
// printf("%d ", lexemeStream[zz].iden); printf("\n");
int i, n = stream_size, lastLineOfDeclaration = -1, lastDataTypeOfDeclaration = -1;
int lastDataTypeOfAssignment = -1, lastLineOfAssignment = -1;
funcName[0] = '!'; funcName[1] = '\0';
int insideMain = 0, diff = 0;
funcParameterCount = 0;
for(i=0;i<n;i++){
if(lexemeStream[i].iden == MAIN) insideMain = 1;
if(i == 2){
if(lexemeStream[i].iden != MAIN){
assert(lexemeStream[i].iden == FUNC);
strcpy(funcName, lexemeStream[i+1].value);
}
i++;
continue;
}
//check for recursive function calls
if(lexemeStream[i].iden == FUNC && !insideMain){
printf("Semantic error: Recursive function calls not allowed.\n");
continue;
}
if(lexemeStream[i].iden == LSQ){
diff++;
continue;
}
if(lexemeStream[i].iden == RSQ){
diff--;
continue;
}
//store function parameter list
if(isDataType(lexemeStream[i].iden) && diff > 0 && !insideMain){
funcParameterType[funcParameterCount++] = lexemeStream[i].iden;
}
//for function calls inside main, check whether correct function name is used
//then check for correct number and types of parameters
if(insideMain && i > 0 && lexemeStream[i].iden == IDEN && lexemeStream[i-1].iden == FUNC){
if(strcmp(funcName, lexemeStream[i].value) > 0)
printf("Function named %s in line %d not declared.\n", lexemeStream[i].value, lexemeStream[i].line);
int j, argumentCount = 0, wrongType = 0;
for(j=i+1;j < stream_size && lexemeStream[j].iden != RSQ;j++){
if(lexemeStream[j].iden != IDEN) continue;
if(argumentCount < funcParameterCount && getDataType(lexemeStream[j]) != funcParameterType[argumentCount])
wrongType = lexemeStream[j].line;
argumentCount++;
}
if(argumentCount != funcParameterCount) printf("Incorrect number of function arguments in line %d.\n", lexemeStream[j].line);
if(wrongType > 0) printf("Type mismatch in function parameters in line %d.\n", wrongType);
i = j;
continue;
}
if(lexemeStream[i].iden == LAD){
addScope();
continue;
}
if(lexemeStream[i].iden == RAD){
deleteScope();
continue;
}
if(isDataType(lexemeStream[i].iden)){
lastLineOfDeclaration = lexemeStream[i].line;
lastDataTypeOfDeclaration = lexemeStream[i].iden;
// printf("setting lastlineOfDeclaration = %d because of %d.\n", lastLineOfDeclaration, lexemeStream[i].iden);
continue;
}
if(lexemeStream[i].iden == ASSIGN){
//line number of assignment operator
lastLineOfAssignment = lexemeStream[i].line;
continue;
}
if(lexemeStream[i].iden == IDEN){
insert(lexemeStream[i].value);
//check if variable is being declared or referenced
if(lastLineOfDeclaration == lexemeStream[i].line){
//declared
declareVariable(lexemeStream[i], lastDataTypeOfDeclaration);
continue;
}
//referenced
referenceVariable(lexemeStream[i]);
if(lexemeStream[i].line != lastLineOfAssignment){
lastDataTypeOfAssignment = getDataType(lexemeStream[i]);
continue;
}
if(lexemeStream[i].line == lastLineOfAssignment){
int dataType = getDataType(lexemeStream[i]);
if(dataType != lastDataTypeOfAssignment){
printf("Semantic error in line %d: Type mismatch between LHS and RHS in line %d.\n", lexemeStream[i].line, lastLineOfAssignment);
}
continue;
}
}
}
// int c = 0, cc = 0;
// EnvStackNode temp = envTop;
// while(temp != NULL){
// c++;
// EnvListNode ev = temp->ev;
// while(ev != NULL){
// cc++;
// ev = ev->next;
// }
// temp = temp->next;
// }
// printf("Total active scopes : %d and active variables = %d.\n", c, cc);
// printf("\ncheck variable stack of size = %d :\n", z);
// for(int i=0;i<z;i++){
// int idx = vvv[i];
// if(variableStack[idx] == NULL){
// printf("empty stack at idx = %d\n", idx);
// continue;
// }
// printf("idx = %d has the value = %s\n", idx, variableStack[idx]->node.name);
// }
return 0;
}
