public static MyError ArrayTypeError(AstNode node, int[] intIndices, Word word)
{
string type;
string value;
if (word.IsError())
{
type = word.GetType().Name;
value = "";
}
else
{
type = TypeConstants.GetMyTypeName(((PyObj)word).GetMyType());
value = ((PyObj)word).MyToString();
}
MyError error = new MyError(node.Span.Location.Line,
node.Span.Location.Column,
node.NodePath.StringValue,
"No se le puede asignar a un array con las dimensiones: [ " + String.Join(", ", intIndices) + " ]. Un objeto tipo: " + type + " valor: " + value,
MyError.ErrorType.Semantic,
MyError.ErrorLevel.Fatal);
AddError(error);
return(error);
}
public ValueDialog(TypeConstants type)
{
//
// Required for Windows Form Designer support
//
_typeProp = new TypeProp[]
{
new TypeProp(TypeConstants.ScaleFactor, DemosGlobalization.GetResxString(GetType(), "Resx_ScaleFactorPercent"), DemosGlobalization.GetResxString(GetType(), "Resx_ScaleFactor"), 0, true, 1, 1000, 1),
new TypeProp(TypeConstants.PaintIntensity, DemosGlobalization.GetResxString(GetType(), "Resx_PaintIntensity"), DemosGlobalization.GetResxString(GetType(), "Resx_PaintIntensity"), 0, true, -100, 100, 10),
new TypeProp(TypeConstants.PaintContrast, DemosGlobalization.GetResxString(GetType(), "Resx_PaintContrast"), DemosGlobalization.GetResxString(GetType(), "Resx_PaintContrast"), 0, true, -100, 100, 10),
new TypeProp(TypeConstants.PaintGamma, DemosGlobalization.GetResxString(GetType(), "Resx_PaintGamma"), DemosGlobalization.GetResxString(GetType(), "Resx_PaintGamma"), 0, true, 10, 500, 1),
new TypeProp(TypeConstants.AutoCrop, DemosGlobalization.GetResxString(GetType(), "Resx_AutoCrop"), DemosGlobalization.GetResxString(GetType(), "Resx_Threshold"), 0, true, 0, 244, 1),
new TypeProp(TypeConstants.Average, DemosGlobalization.GetResxString(GetType(), "Resx_Average"), DemosGlobalization.GetResxString(GetType(), "Resx_Dimension"), 3, false, 3, 255, 1),
new TypeProp(TypeConstants.Gaussian, DemosGlobalization.GetResxString(GetType(), "Resx_Gaussian"), DemosGlobalization.GetResxString(GetType(), "Resx_Radius"), 0, false, 1, 1000, 1),
new TypeProp(TypeConstants.Median, DemosGlobalization.GetResxString(GetType(), "Resx_Median"), DemosGlobalization.GetResxString(GetType(), "Resx_Dimension"), 2, false, 2, 64, 1),
new TypeProp(TypeConstants.Mosaic, DemosGlobalization.GetResxString(GetType(), "Resx_Mosac"), DemosGlobalization.GetResxString(GetType(), "Resx_Dimension"), 2, false, 2, 64, 1),
new TypeProp(TypeConstants.Oilify, DemosGlobalization.GetResxString(GetType(), "Resx_Oilify"), DemosGlobalization.GetResxString(GetType(), "Resx_Dimension"), 2, false, 2, 255, 1),
new TypeProp(TypeConstants.Posterize, DemosGlobalization.GetResxString(GetType(), "Resx_Posterize"), DemosGlobalization.GetResxString(GetType(), "Resx_Levels"), 2, false, 2, 64, 1),
new TypeProp(TypeConstants.Sharpen, DemosGlobalization.GetResxString(GetType(), "Resx_Sharpen"), DemosGlobalization.GetResxString(GetType(), "Resx_Sharpness"), 0, false, -100, 100, 10),
new TypeProp(TypeConstants.Min, DemosGlobalization.GetResxString(GetType(), "Resx_MinFilter"), DemosGlobalization.GetResxString(GetType(), "Resx_SampleSize"), 1, false, 1, 32, 1),
new TypeProp(TypeConstants.Max, DemosGlobalization.GetResxString(GetType(), "Resx_MaxFilter"), DemosGlobalization.GetResxString(GetType(), "Resx_SampleSize"), 1, false, 1, 32, 1),
new TypeProp(TypeConstants.HistoContrast, DemosGlobalization.GetResxString(GetType(), "Resx_HistoContrast"), DemosGlobalization.GetResxString(GetType(), "Resx_Contrast"), 0, false, -100, 100, 10),
new TypeProp(TypeConstants.Hue, DemosGlobalization.GetResxString(GetType(), "Resx_Hue"), DemosGlobalization.GetResxString(GetType(), "Resx_Angle"), 0, false, -360, 360, 1),
new TypeProp(TypeConstants.Solarize, DemosGlobalization.GetResxString(GetType(), "Resx_Solarize"), DemosGlobalization.GetResxString(GetType(), "Resx_Threshold"), 0, false, 0, 255, 1),
new TypeProp(TypeConstants.Temperature, DemosGlobalization.GetResxString(GetType(), "Resx_Temperature"), DemosGlobalization.GetResxString(GetType(), "Resx_Threshold"), 0, false, -1000, 1000, 1)
};
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
_type = type;
}
public static MyError BadAttributeError(PyObj pyObj, IdentifierSegment identifierSegment)
{
return(new MyError(String.Format("El atributo: {0} no existe en el tipo: {1}",
identifierSegment.Id,
TypeConstants.GetMyTypeName(pyObj.GetMyType()))
));
}
public static MyError ArrayDimensionError(AstNode node, Word indexWord)
{
string type;
string value;
if (indexWord.IsError())
{
type = indexWord.GetType().Name;
value = "";
}
else
{
type = TypeConstants.GetMyTypeName(((PyObj)indexWord).GetMyType());
value = ((PyObj)indexWord).MyToString();
}
MyError error = new MyError(node.Span.Location.Line,
node.Span.Location.Column,
node.NodePath.StringValue,
"Indice no valido en declaracion de Array: " + type + " valor: " + value,
MyError.ErrorType.Semantic,
MyError.ErrorLevel.Fatal);
AddError(error);
return(error);
}
public async Task <ResponseViewModel> CreateResponse(NewResponseViewModel response, ObjectId formId)
{
FormObjectViewModel form = await GetForm(formId);
List <FieldViewModel> fields = form.fields;
if (fields.Count != response.responseValues.Count)
{
throw new Exception("Responses do not match fields");
}
bool fieldsValid = ResponseUtils.ResponseValidator(new List <FieldViewModel>(fields),
new List <NewResponseValuesViewModel>(response.responseValues));
if (!fieldsValid)
{
throw new Exception("Responses do not match fields");
}
List <ResponseValueViewModel> responseValues = new List <ResponseValueViewModel>();
foreach (var responseValue in response.responseValues)
{
if (!TypeConstants.IsValidFieldType(responseValue.responseType))
{
throw new Exception("Invalid Response Type");
}
ResponseValueViewModel responseValueViewModel = new ResponseValueViewModel
{
Id = ObjectId.GenerateNewId(),
responseType = responseValue.responseType,
value = responseValue.value,
index = responseValue.index,
fieldId = ObjectId.Parse(responseValue.fieldId)
};
string responseType = responseValue.responseType;
if (responseType == TypeConstants.CHECKBOX_INPUT)
{
var values = Constants.ConvertJsonObject(responseValue.value);
responseValueViewModel.value = values;
}
responseValues.Add(responseValueViewModel);
}
ResponseViewModel responseViewModel = new ResponseViewModel
{
Id = ObjectId.GenerateNewId(),
createdBy = response.createdBy,
createdAt = DateTime.UtcNow,
formId = formId,
responseValues = responseValues
};
await responseCollection.InsertOneAsync(responseViewModel);
return(responseViewModel);
}
public static MyError BadProcedureError(PyObj pyObj, ProcedureSegment procedureSegment)
{
return(new MyError(String.Format("La funcion o metodo: {0} con: {1} argumentos no es una funcion o metodo valida para el tipo: {2}",
procedureSegment.Id,
procedureSegment.CountArguments,
TypeConstants.GetMyTypeName(pyObj.GetMyType()))
));
}
public TypeProp(TypeConstants type, string captionName, string valueName, int min, int max)
{
Type = type;
CaptionName = captionName;
ValueName = valueName;
Min = min;
Max = max;
}
public async Task <FormObjectViewModel> CreateForm(NewFormViewModel form)
{
ObjectId formId = ObjectId.GenerateNewId();
List <FieldViewModel> fields = new List <FieldViewModel>();
foreach (var field in form.fields)
{
string fieldType = field.fieldType;
if (!TypeConstants.IsValidFieldType(fieldType))
{
throw new Exception("Invalid Field Type");
}
FieldViewModel fieldViewModel = new FieldViewModel
{
Id = ObjectId.GenerateNewId(),
formId = formId,
fieldType = field.fieldType,
index = field.index,
title = field.title,
createdAt = DateTime.UtcNow
};
if (fieldType == TypeConstants.CHECKBOX_INPUT || fieldType == TypeConstants.DROP_DOWN_INPUT ||
fieldType == TypeConstants.RADIO_INPUT)
{
var values = Constants.ConvertJsonObject(field.value);
fieldViewModel.value = values;
}
else
{
fieldViewModel.value = field.value;
}
fields.Add(fieldViewModel);
}
if (fields.Count != 0)
{
await fieldCollection.InsertManyAsync(fields);
}
IEnumerable <ObjectId> fieldIds = from _ in fields
select _.Id;
FormViewModel formViewModel = new FormViewModel
{
Id = formId,
createdAt = DateTime.UtcNow,
createdBy = form.createdBy,
formTitle = form.title,
fields = fieldIds.ToList()
};
await formCollection.InsertOneAsync(formViewModel);
return(FormUtils.CombineFormAndFields(formViewModel, fields));
}
public virtual MyError UnaryError(UnaryOperator op, PyObj obj0)
{
return(new MyError(string.Format("No se puede realizar la operacion unaria: {0} ({1}). Con tipo: <{2}> y valor: <{3}>"
, op.ToString()
, op.ToStringSymbol()
, TypeConstants.GetMyTypeName(obj0.GetMyType())
, obj0.MyToString()
)));
}
public virtual MyError BinaryError(PyObj obj0, BinaryOperator op, PyObj obj1)
{
return(new MyError(string.Format("No se puede realizar la operacion binaria: {0} ({1}). Con tipos: <{2}, {3}> y valores: <{4}, {5}>"
, op.ToString()
, op.ToStringSymbol()
, TypeConstants.GetMyTypeName(obj0.GetMyType())
, TypeConstants.GetMyTypeName(obj1.GetMyType())
, obj0.MyToString()
, obj1.MyToString()
)));
}
public TypeProp(TypeConstants type, string captionName, string valueName, int initialValue, bool readInitialValue, int min, int max, int multiplyBy)
{
Type = type;
CaptionName = captionName;
ValueName = valueName;
InitialValue = initialValue;
ReadInitialValue = readInitialValue;
Min = min;
Max = max;
MultiplyBy = multiplyBy;
}
public ValueDialog(TypeConstants type)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
_type = type;
}
public override Word Visit(ClassNode classNode)
{
var className = ((MyString)classNode.IdentifierNode.Accept(this)).StringValue.ToLowerInvariant();
var classId = TypeConstants.AddType(className);
if (classId < 0)
{
return(ErrorFactory.AlreadyDefinedClass(classNode, className));
}
return(new ClassDefinition(classId, className, classNode, StaticEntity));
}
public static bool InterpretFromFileName(string filePath)
{
string src;
try
{
src = File.ReadAllText(filePath);
}
catch (Exception)
{
//Reprotar error de preprocesador
return(false);
}
var grammar = new PyUsacGrammar();
var langData = new LanguageData(grammar);
var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser
var parseTree = parser.Parse(src);
var root = parseTree.Root;
bool hasErrors = false;
foreach (var error in parseTree.ParserMessages)
{
if (error.Level == Irony.ErrorLevel.Error)
{
hasErrors = true;
}
ErrorHelper.ErrorFactory.CreateParsingError(error, filePath);
}
if (hasErrors)
{
return(false);
}
//var dotCode = GetDot(root);//Descomentar en debug mode! :)
var astBuilder = new PyAstBuilder(new AstContext(langData), filePath);
astBuilder.BuildAst(parseTree);
var programNode = (ProgramNode)parseTree.Root.AstNode;
//GetDot(programNode);//Descomentar en debug mode! :)
var entity = new StaticEntity(programNode);
entity.InitVisitor(true);
entity.InvokeMain();
TypeConstants.ClearTypeHashtable();
return(true);
}
public static MyError ForConditionError(AstNode node, Word word)
{
string type;
if (word.IsError())
{
type = word.GetType().Name;
}
else
{
type = TypeConstants.GetMyTypeName(((PyObj)word).GetMyType());
}
MyError error = new MyError(node.Span.Location.Line,
node.Span.Location.Column,
node.NodePath.StringValue,
"Condicion del FOR no es valida. Tipo: " + type + " se esperaba: " + TypeConstants.GetMyTypeName(TypeConstants.BOOLEAN),
MyError.ErrorType.Semantic,
MyError.ErrorLevel.Fatal);
AddError(error);
return(error);
}
public static MyError IncDecError(AstNode node, IncDecOperator op, Word word)
{
string type;
if (word.IsError())
{
type = word.GetType().Name;
}
else
{
type = TypeConstants.GetMyTypeName(((PyObj)word).GetMyType());
}
MyError error = new MyError(node.Span.Location.Line,
node.Span.Location.Column,
node.NodePath.StringValue,
"No se puede hacer " + op.ToStringSymbol() + " con un tipo: " + type,
MyError.ErrorType.Semantic,
MyError.ErrorLevel.Fatal);
AddError(error);
return(error);
}
public static MyError GraphError(AstNode node, string paramName, Word word)
{
string type;
if (word.IsError())
{
type = word.GetType().Name;
}
else
{
type = TypeConstants.GetMyTypeName(((PyObj)word).GetMyType());
}
MyError error = new MyError(node.Span.Location.Line,
node.Span.Location.Column,
node.NodePath.StringValue,
paramName + " de graph con un tipo: " + type,
MyError.ErrorType.Semantic,
MyError.ErrorLevel.Fatal);
AddError(error);
return(error);
}
public static MyError CantReturnError(AstNode node, Word word)
{
string type;
if (word.IsError())
{
type = word.GetType().Name;
}
else
{
type = TypeConstants.GetMyTypeName(((PyObj)word).GetMyType());
}
MyError error = new MyError(node.Span.Location.Line,
node.Span.Location.Column,
node.NodePath.StringValue,
"No se puede retornar un tipo: " + type + " se retorno null para poder continuar con la ejecucion",
MyError.ErrorType.Semantic,
MyError.ErrorLevel.Fatal);
AddError(error);
return(error);
}
public async Task <FieldViewModel> AddNewFieldToForm(NewFieldViewModel field, ObjectId formId)
{
ObjectId fieldObjectId = ObjectId.GenerateNewId();
string fieldType = field.fieldType;
if (!TypeConstants.IsValidFieldType(fieldType))
{
throw new Exception("Invalid Field Type");
}
FieldViewModel fieldViewModel = new FieldViewModel
{
Id = fieldObjectId,
formId = formId,
createdAt = DateTime.UtcNow,
index = field.index,
fieldType = field.fieldType,
title = field.title
};
if (fieldType == TypeConstants.CHECKBOX_INPUT || fieldType == TypeConstants.DROP_DOWN_INPUT ||
fieldType == TypeConstants.RADIO_INPUT)
{
var values = Constants.ConvertJsonObject(field.value);
fieldViewModel.value = values;
}
else
{
fieldViewModel.value = field.value;
}
await formCollection.UpdateOneAsync(_ => _.Id == formId,
Builders <FormViewModel> .Update.Push <ObjectId>(_ => _.fields, fieldObjectId));
await fieldCollection.InsertOneAsync(fieldViewModel);
return(fieldViewModel);
}
public Word Visit(IncDecExpr incDecExpr)
{
var result = incDecExpr.Value.Accept(this);
if (IsError(result))
{
return(result);
}
if (!IsMemoryBlock(result))
{
return(ErrorFactory.IncDecNonRefError(incDecExpr.Value, incDecExpr.IncDecOperator));
}
var memoryBlock = (MemoryBlock)result;
var pyObj = memoryBlock.Value;
var pyObjType = pyObj.GetMyType();
if (!TypeConstants.IsNumber(pyObjType))
{
return(ErrorFactory.IncDecError(incDecExpr, incDecExpr.IncDecOperator, pyObj));
}
var pyObjCopy = MyPrimitiveFactory.CreateCopy((MyPrimitive)pyObj);
switch (incDecExpr.IncDecOperator)
{
case IncDecOperator.PlusPlus:
memoryBlock.Value = (PyObj)pyObj.BinaryOperation(BinaryOperator.Plus, new MyInt(1));
break;
case IncDecOperator.MinusMinus:
memoryBlock.Value = (PyObj)pyObj.BinaryOperation(BinaryOperator.Minus, new MyInt(1));
break;
default:
throw new Exception("Operador Inc dec no valido: " + incDecExpr.IncDecOperator);
}
return(pyObjCopy);
}
public async Task <FieldViewModel> UpdateField(NewFieldViewModel field, ObjectId formId, ObjectId fieldId)
{
if (!TypeConstants.IsValidFieldType(field.fieldType))
{
throw new Exception("Invalid Field Type");
}
string fieldType = field.fieldType;
object fieldValue = field.value;
if (fieldType == TypeConstants.CHECKBOX_INPUT || fieldType == TypeConstants.DROP_DOWN_INPUT ||
fieldType == TypeConstants.RADIO_INPUT)
{
var values = Constants.ConvertJsonObject(field.value);
fieldValue = values;
}
UpdateResult fieldUpdateResult = await fieldCollection.UpdateOneAsync(
_ => _.Id == fieldId && _.formId == formId,
Builders <FieldViewModel> .Update
.Set(_ => _.title, field.title)
.Set(_ => _.fieldType, field.fieldType)
.Set(_ => _.index, field.index)
.Set(_ => _.value, fieldValue));
if (fieldUpdateResult.IsAcknowledged)
{
var fieldTask = await fieldCollection.FindAsync(_ => _.Id == fieldId);
return(await fieldTask.SingleOrDefaultAsync());
}
else
{
throw new Exception("Unable to update field content");
}
}
public void OnOpenCommandWindow( TypeConstants.CommandSelectType type )
{
this.inputArrowStateMachine.Change( (int)type );
}
public void SetCommandType( TypeConstants.CommandType commandType )
{
this.CommandType = commandType;
}
public ValueDialog(TypeConstants type)
{
InitializeComponent();
_type = type;
}
public static MyError BadIndexError(PyObj pyObj, IndexSegment indexSegment)
{
var indexValue = indexSegment.Index;
return(new MyError("El indice: " + indexValue.MyToString() + " (" + TypeConstants.GetMyTypeName(indexValue.GetMyType()) + ") no es un indice valido para el tipo: " + TypeConstants.GetMyTypeName(pyObj.GetMyType()) + " valor: " + pyObj.MyToString()));;
}
public TypeProp(TypeConstants type, string captionName)
{
Type = type;
CaptionName = captionName;
}
public FillDialog(bool isGray, TypeConstants type)
{
InitializeComponent();
_isGray = isGray;
_type = type;
}
