# All files / src/generator utils.js

100% Statements 31/31
89.47% Branches 17/19
100% Functions 5/5
100% Lines 31/31

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    24x
    24x
    24x
    24x
    24x
    24x

    24x
    465x
    465x
    465x

    465x

    464x
    464x

    464x

    24x
    641x

    641x
    641x

    641x

    24x
    137x

    5x

    5x

    9x

    118x

    24x
    139x

    24x

    137x

    24x
    24x
     // @flow
    import { builtinTypes } from "../Syntax";
    import opcode from "../emitter/opcode";
    import curry from "curry";
    import invariant from "invariant";
    import { I32, I64, F32, F64 } from "../emitter/value_type";
    import { LOCAL_INDEX, GLOBAL_INDEX, TYPE_CONST } from "../semantics/metadata";
    import type {
      IntermediateVariableType,
      IntermediateOpcodeType,
      RawOpcodeType,
    } from "./flow/types";
    import type { NodeType } from "../flow/types";

    export const scopeOperation = curry((op, node) => {
      const local = node.meta[LOCAL_INDEX];
      const _global = node.meta[GLOBAL_INDEX];
      const index = local != null ? local : _global;

      invariant(
        index != null,
        `Unefined index for scope Operation. Possibly missing metadata. op: ${JSON.stringify(
          op
        )} node: ${JSON.stringify(node, null, 2)}`
      );

      const kind = local != null ? op + "Local" : op + "Global";
      const params = [Number(index)];

      return {
        kind: opcode[kind],
        params,
        debug: `${node.value}<${node.type ? node.type : "?"}>`,
      };
    });

    export const getConstOpcode = (node: NodeType): IntermediateOpcodeType[] => {
      const nodeType = node.type || builtinTypes.i32;

      const kind: RawOpcodeType = opcode[nodeType + "Const"] || opcode.i32Const;
      const params = [Number(node.value)];

      return [
        {
          kind,
          params,
        },
      ];
    };

    // clean this up
    export const getType = (str: ?string): number => {
      switch (str) {
        case builtinTypes.f32:
          return F32;
        case builtinTypes.f64:
          return F64;
        case builtinTypes.i64:
          return I64;
        case builtinTypes.i32:
        default:
          return I32;
      }
    };

    export const isBuiltinType = (type: ?string): boolean => {
      return typeof type === "string" && builtinTypes[type] != null;
    };

    export const generateValueType = (
      node: NodeType
    ): IntermediateVariableType => ({
      mutable: node.meta[TYPE_CONST] ? 0 : 1,
      type: getType(node.type),
    });
    export const setInScope = scopeOperation("Set");
    export const getInScope = scopeOperation("Get");